{"text": "// Copyright 2012 Jesse Windle - jesse.windle@gmail.com\r\n\r\n// This program is free software: you can redistribute it and/or\r\n// modify it under the terms of the GNU General Public License as\r\n// published by the Free Software Foundation, either version 3 of the\r\n// License, or (at your option) any later version.\r\n\r\n// This program is distributed in the hope that it will be useful, but\r\n// WITHOUT ANY WARRANTY; without even the implied warranty of\r\n// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\r\n// General Public License for more details.\r\n\r\n// You should have received a copy of the GNU General Public License\r\n// along with this program.  If not, see\r\n// <http://www.gnu.org/licenses/>.\r\n\r\n/*********************************************************************\r\n\r\n  This class wraps GSL's random number generator and random\r\n  distribution functions into a class.  We use the Mersenne Twister\r\n  for random number generation since it has a large period, which is\r\n  what we want for MCMC simulation.\r\n\r\n  When compiling include -lgsl -lcblas -llapack .\r\n\r\n*********************************************************************/\r\n\r\n#ifndef __BASICRNG__\r\n#define __BASICRNG__\r\n\r\n#include <stdio.h>\r\n#include <gsl/gsl_rng.h>\r\n#include <gsl/gsl_randist.h>\r\n#include <gsl/gsl_cdf.h>\r\n#include <gsl/gsl_sf.h>\r\n\r\n#include <iostream>\r\n#include <fstream>\r\n#include <ctime>\r\n#include <string>\r\n#include <cmath>\r\n\r\nusing std::string;\r\nusing std::ofstream;\r\nusing std::ifstream;\r\n\r\n//////////////////////////////////////////////////////////////////////\r\n\t\t\t      // RNG //\r\n//////////////////////////////////////////////////////////////////////\r\n\r\nclass BasicRNG {\r\n\r\n protected:\r\n\r\n  gsl_rng * r;\r\n\r\n public:\r\n\r\n  // Constructors and destructors.\r\n  BasicRNG(unsigned long seed);\r\n\r\n  virtual ~BasicRNG()\r\n    { gsl_rng_free (r); }\r\n\r\n  // Assignment=\r\n  BasicRNG& operator=(const BasicRNG& rng);\r\n\r\n  // Read / Write / Set\r\n  bool read (const string& filename);\r\n  bool write(const string& filename);\r\n  void set(unsigned long seed);\r\n\r\n  // Get rng -- be careful.  Needed for other random variates.\r\n  gsl_rng* getrng() { return r; }\r\n\r\n  // Random variates.\r\n  double unif  ();                             // Uniform\r\n  double expon_mean(double mean);     // Exponential\r\n  double expon_rate(double rate);                  // Exponential\r\n  double chisq (double df);                    // Chisq\r\n  double norm  (double sd);                    // Normal\r\n  double norm  (double mean , double sd);      // Normal\r\n  double gamma_scale (double shape, double scale); // Gamma_Scale\r\n  double gamma_rate  (double shape, double rate);  // Gamma_Rate\r\n  double igamma(double shape, double scale);   // Inv-Gamma\r\n  double flat  (double a=0  , double b=1  );   // Flat\r\n  double beta  (double a=1.0, double b=1.0);   // Beta\r\n\r\n  int bern  (double p);                     // Bernoulli\r\n\r\n  // CDF\r\n  static double p_norm (double x, int use_log=0);\r\n  static double p_gamma_rate(double x, double shape, double rate, int use_log=0);\r\n\r\n  // Density\r\n  static double d_beta(double x, double a, double b);\r\n\r\n  // Utility\r\n  static double Gamma (double x, int use_log=0);\r\n\r\n}; // BasicRNG\r\n\r\n#endif\r\n\r\n////////////////////////////////////////////////////////////////////////////////\r\n\t\t\t\t // APPENDIX //\r\n////////////////////////////////////////////////////////////////////////////////\r\n\r\n// If you make everything inline within the same translation unit then that\r\n// function will not be callable from anohter translation unit.  You can see\r\n// that the function is missing by using the nm command.\r\n", "meta": {"hexsha": "7f4e4d2325ee598eba308e62c0838fc9f64856cb", "size": 3611, "ext": "h", "lang": "C", "max_stars_repo_path": "src/polyagamma/GRNG.h", "max_stars_repo_name": "TeoGiane/SPMIX", "max_stars_repo_head_hexsha": "d63dff8af7523fc1e8e11d2c2906daa16aaff4dc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-12-22T09:35:09.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-22T09:35:09.000Z", "max_issues_repo_path": "src/polyagamma/GRNG.h", "max_issues_repo_name": "TeoGiane/SPMIX", "max_issues_repo_head_hexsha": "d63dff8af7523fc1e8e11d2c2906daa16aaff4dc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/polyagamma/GRNG.h", "max_forks_repo_name": "TeoGiane/SPMIX", "max_forks_repo_head_hexsha": "d63dff8af7523fc1e8e11d2c2906daa16aaff4dc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-01-18T21:31:01.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-18T21:31:01.000Z", "avg_line_length": 32.2410714286, "max_line_length": 82, "alphanum_fraction": 0.5768485184, "num_tokens": 791, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4493926344647597, "lm_q2_score": 0.10230471199815194, "lm_q1q2_score": 0.04597498404300801}}
{"text": "/*\n *  specialfunctionsmodule.h\n *\n *  This file is part of NEST.\n *\n *  Copyright (C) 2004 The NEST Initiative\n *\n *  NEST is free software: you can redistribute it and/or modify\n *  it under the terms of the GNU General Public License as published by\n *  the Free Software Foundation, either version 2 of the License, or\n *  (at your option) any later version.\n *\n *  NEST is distributed in the hope that it will be useful,\n *  but WITHOUT ANY WARRANTY; without even the implied warranty of\n *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n *  GNU General Public License for more details.\n *\n *  You should have received a copy of the GNU General Public License\n *  along with NEST.  If not, see <http://www.gnu.org/licenses/>.\n *\n */\n\n#ifndef SPECIALFUNCTIONSMODULE_H\n#define SPECIALFUNCTIONSMODULE_H\n/*\n    SLI Module implementing functions from the GNU Science Library.\n    The GSL is available from sources.redhat.com/gsl.\n*/\n\n/*\n    NOTE: Special functions are available only if the GSL is installed.\n          If no GSL is available, calling special functions will result\n          in a SLI error message.  HEP 2002-09-19.\n*/\n\n// Generated includes:\n#include \"config.h\"\n\n// Includes from sli:\n#include \"slifunction.h\"\n#include \"slimodule.h\"\n\n#ifdef HAVE_GSL\n// External include:\n#include <gsl/gsl_integration.h>\n#endif\n\n// NOTE: all gsl headers are included in specialfunctionsmodule.cc\n\nclass SpecialFunctionsModule : public SLIModule\n{\n\n  // Part 1: Methods pertaining to the module ----------------------\n\npublic:\n  SpecialFunctionsModule( void ){};\n  // ~SpecialFunctionsModule(void);\n\n  // The Module is registered by a call to this Function:\n  void init( SLIInterpreter* );\n\n  // This function will return the name of our module:\n  const std::string name( void ) const;\n\n\n  // Part 2: Classes for the implemented functions -----------------\n\n\npublic:\n  /**\n   * Classes which implement the GSL Funktions.\n   * These must be public, since we want to export\n   * objects of these.\n   */\n  class GammaIncFunction : public SLIFunction\n  {\n  public:\n    GammaIncFunction()\n    {\n    }\n    void execute( SLIInterpreter* ) const;\n  };\n  class LambertW0Function : public SLIFunction\n  {\n  public:\n    LambertW0Function()\n    {\n    }\n    void execute( SLIInterpreter* ) const;\n  };\n  class LambertWm1Function : public SLIFunction\n  {\n  public:\n    LambertWm1Function()\n    {\n    }\n    void execute( SLIInterpreter* ) const;\n  };\n\n  class ErfFunction : public SLIFunction\n  {\n  public:\n    ErfFunction()\n    {\n    }\n    void execute( SLIInterpreter* ) const;\n  };\n\n  class ErfcFunction : public SLIFunction\n  {\n  public:\n    ErfcFunction()\n    {\n    }\n    void execute( SLIInterpreter* ) const;\n  };\n\n  class GaussDiskConvFunction : public SLIFunction\n  {\n  public:\n    void execute( SLIInterpreter* ) const;\n\n    // need constructor and destructor to set up integration workspace\n    GaussDiskConvFunction( void );\n    ~GaussDiskConvFunction( void );\n\n  private:\n    // quadrature parameters, see GSL Reference\n    static const int MAX_QUAD_SIZE;\n    static const double QUAD_ERR_LIM;\n    static const double QUAD_ERR_SCALE;\n\n// integration workspace\n#ifdef HAVE_GSL\n    gsl_integration_workspace* w_;\n\n    /**\n     * Integrand function.\n     * @note This function must be static with C linkage so that it can\n     *       be passed to the GSL. Alternatively, one could define it\n     *       outside the class.\n     */\n    static double f_( double, void* );\n    static gsl_function F_; // GSL wrapper struct for it\n#endif\n  };\n\n  // Part 3: One instatiation of each new function class -----------\n\npublic:\n  const GammaIncFunction gammaincfunction;\n  const LambertW0Function lambertw0function;\n  const LambertWm1Function lambertwm1function;\n  const ErfFunction erffunction;\n  const ErfcFunction erfcfunction;\n  const GaussDiskConvFunction gaussdiskconvfunction;\n\n  // Part 3b: Internal variables\nprivate:\n};\n\n\n// Part 4: Documentation for all functions -------------------------\n\n/* BeginDocumentation\n\nName: Gammainc - incomplete gamma function\n\nSynopsis: x a Gammainc -> result\n\nDescription: Computes the incomplete Gamma function\n             int(t^(a-1)*exp(-t), t=0..x) / Gamma(a)\n\nParameters:  x      (double): upper limit of integration\n             a      (double): order of Gamma function\n\nExamples: 2.2 1.5 Gammainc -> 0.778615\n\nAuthor: H E Plesser\n\nFirstVersion: 2001-07-26\n\nRemarks: This is the incomplete Gamma function P(a,x) defined as no. 6.5.1\n         in Abramowitz&Stegun.  Requires the GSL.\n\nReferences: http://sources.redhat.com/gsl/ref\n*/\n\n/* BeginDocumentation\n\nName: Erf - error function\n\nSynopsis: x Erf -> result\n\nDescription: Computes the error function\n             erf(x) = 2/sqrt(pi) int_0^x dt exp(-t^2)\n\nParameters:  x (double): error function argument\n\nExamples: 0.5 erf -> 0.5205\n\nAuthor: H E Plesser\n\nFirstVersion: 2001-07-30\n\nRemarks: Requires the GSL.\n\nReferences: http://sources.redhat.com/gsl/ref\n\nSeeAlso: Erfc\n*/\n\n/* BeginDocumentation\n\nName: Erfc - complementary error function\n\nSynopsis: x Erfc -> result\n\nDescription: Computes the error function\n             erfc(x) = 1 - erf(x) = 2/sqrt(pi) int_x^inf dt exp(-t^2)\n\nParameters:  x (double): error function argument\n\nExamples: 0.5 erfc -> 0.4795\n\nAuthor: H E Plesser\n\nFirstVersion: 2001-07-30\n\nRemarks: Requires the GSL.\n\nReferences: http://sources.redhat.com/gsl/ref\n\nSeeAlso: Erf\n*/\n\n/* BeginDocumentation\n\nName:GaussDiskConv - Convolution of a Gaussian with an excentric disk\n\nSynopsis:R r0 GaussDiskConv -> result\n\nDescription:Computes the convolution of an excentric normalized Gaussian\nwith a disk\n\n       C[R, r0] = IInt[ disk(rvec; R) * Gauss(rvec - r_0vec) d^2rvec ]\n                = 2 Int[ r Exp[-r0^2-r^2] I_0[2 r r_0] dr, r=0..R]\n\nParameters:R   radius of the disk, centered at origin\nr0  distance of Gaussian center from origin\n\nExamples:SLI ] 3.2 2.3 GaussDiskConv =\n0.873191\n\nAuthor:H E Plesser\n\nFirstVersion: 2002-07-12\n\nRemarks:This integral is needed to compute the response of a DOG model to\n excentric light spots, see [1].  For technicalities, see [2].  Requires GSL.\n\nReferences: [1] G. T. Einevoll and P. Heggelund, Vis Neurosci 17:871-885 (2000).\n [2] Hans E. Plesser, Convolution of an Excentric Gaussian with a Disk,\n     Technical Report, arken.nlh.no/~itfhep, 2002\n\n*/\n\n#endif\n", "meta": {"hexsha": "d1bc798c4aaa9d2f2a616a101dcd5ea63a0c6cd8", "size": 6323, "ext": "h", "lang": "C", "max_stars_repo_path": "NEST-14.0-FPGA/sli/specialfunctionsmodule.h", "max_stars_repo_name": "OpenHEC/SNN-simulator-on-PYNQcluster", "max_stars_repo_head_hexsha": "14f86a76edf4e8763b58f84960876e95d4efc43a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 45.0, "max_stars_repo_stars_event_min_datetime": "2019-12-09T06:45:53.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-29T12:16:41.000Z", "max_issues_repo_path": "NEST-14.0-FPGA/sli/specialfunctionsmodule.h", "max_issues_repo_name": "zlchai/SNN-simulator-on-PYNQcluster", "max_issues_repo_head_hexsha": "14f86a76edf4e8763b58f84960876e95d4efc43a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2020-05-23T05:34:21.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-08T02:33:46.000Z", "max_forks_repo_path": "NEST-14.0-FPGA/sli/specialfunctionsmodule.h", "max_forks_repo_name": "OpenHEC/SNN-simulator-on-PYNQcluster", "max_forks_repo_head_hexsha": "14f86a76edf4e8763b58f84960876e95d4efc43a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 10.0, "max_forks_repo_forks_event_min_datetime": "2019-12-09T06:45:59.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-25T09:32:56.000Z", "avg_line_length": 23.5055762082, "max_line_length": 80, "alphanum_fraction": 0.6925510043, "num_tokens": 1682, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47268347662043286, "lm_q2_score": 0.08389037953940537, "lm_q1q2_score": 0.03965359625569376}}
{"text": "/* bcls.c\n   $Revision: 282 $ $Date: 2006-12-17 17:38:00 -0800 (Sun, 17 Dec 2006) $\n\n   ---------------------------------------------------------------------\n   This file is part of BCLS (Bound-Constrained Least Squares).\n\n   Copyright (C) 2006 Michael P. Friedlander, Department of Computer\n   Science, University of British Columbia, Canada. All rights\n   reserved. E-mail: <mpf@cs.ubc.ca>.\n\n   BCLS is free software; you can redistribute it and/or modify it\n   under the terms of the GNU Lesser General Public License as\n   published by the Free Software Foundation; either version 2.1 of the\n   License, or (at your option) any later version.\n\n   BCLS is distributed in the hope that it will be useful, but WITHOUT\n   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General\n   Public License for more details.\n\n   You should have received a copy of the GNU Lesser General Public\n   License along with BCLS; if not, write to the Free Software\n   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301\n   USA\n   ---------------------------------------------------------------------\n*/\n/*!\n  \\file\n  BCLS user-callable library routines.\n*/\n\n#include <cblas.h>\n#include <stdlib.h>\n#include <stdio.h>\n#include <float.h>\n#include <math.h>\n#include <assert.h>\n#include <setjmp.h>\n\n#include \"bcls.h\"\n#include \"bclib.h\"\n#include \"bcsolver.h\"\n#include \"bcversion.h\"\n\n/*!\n\n  \\brief Malloc wrapper.  Private to this file.\n\n  Pointer to the newly allocated memory,\n  or NULL if malloc returned an eror.\n  \n  \\param[in]  len   Number of elements needed\n  \\param[in]  size  Memory needed for each element.\n  \\param[in]  who   Short character description of the memory needed.\n  \n  \\return Pointer to the newly allocated memory.\n\n*/\nstatic void *\nxmalloc (int len, size_t size, char * who)\n{\n    register void *value = malloc(len * size);\n    if (value == NULL)\n\tfprintf( stderr, \"Not enough memory to allocate %s.\\n\", who );\n    return value;\n}\n\n/*!\n\n  \\brief Create a BCLS problem instance.\n\n  This routine create a BCLS problem.  It *must* be called before any\n  other BCLS routine.  It will create and initialize a new BCLS\n  problem with enough space to accomodate the specified problem.  The\n  problem is then initialized using bcls_init_prob.\n\n  In order to re-initialize the BCLS problem instance, but not\n  deallocate memory that's already sufficient for an equal or smaller\n  size problem, use bcls_init_prob.\n\n  \\param[in] mmax  Maximum number of rows    in any A.\n  \\param[in] nmax  Maximum number of columns in any A.\n\n  \\return Return a pointer to a new BCLS problem.  If the return is\n  NULL, then the initialization failed.\n\n*/\nBCLS *\nbcls_create_prob( int mmax, int nmax )\n{\n    int mnmax = imax( nmax, mmax );\n\n    assert( mmax > 0 && nmax > 0 );\n    \n    // Allocate the problem.\n    BCLS *ls = (BCLS *)xmalloc(1, sizeof(BCLS), \"ls\" );\n\n    // Check if the problem has been successfully allocated.\n    if (ls == NULL) {\n\tfprintf( stderr, \"XXX Could not allocate a BCLS problem.\\n\");\n\treturn ls;\n    }\n\n    // -----------------------------------------------------------------\n    // Allocate workspace vectors large enough to accomdate the problem.\n    // -----------------------------------------------------------------\n\n    // Record the maximum alloted workspace.\n    ls->mmax = mmax;\n    ls->nmax = nmax;\n\n    // Residual: r(m+n).\n    ls->r = (double *)xmalloc( mmax+nmax, sizeof(double), \"r\" );\n    if (ls->r == NULL) goto error;\n\n    // Gradient: g(n).\n    ls->g = (double *)xmalloc( nmax, sizeof(double), \"g\" );\n    if (ls->g == NULL) goto error;\n\n    // Search direction, full space: dx(n).\n    ls->dx = (double *)xmalloc( nmax, sizeof(double), \"dx\" );\n    if (ls->dx == NULL) goto error;\n\n    // Search direction, subspace: dxFree(n).\n    ls->dxFree = (double *)xmalloc( nmax, sizeof(double), \"dxFree\" );\n    if (ls->dxFree == NULL) goto error;\n\n    // Step to each breakpoint: aBreak(n).\n    ls->aBreak = (double *)xmalloc( nmax, sizeof(double), \"aBreak\" );\n    if (ls->aBreak == NULL) goto error;\n\n    // Indices of each breakpoint: iBreak(n).\n    ls->iBreak = (int *)xmalloc( nmax, sizeof(int), \"iBreak\" );\n    if (ls->iBreak == NULL) goto error;\n\n    // Variable indices: ix(n).\n    ls->ix = (int *)xmalloc( nmax, sizeof(int), \"ix\" );\n    if (ls->ix == NULL) goto error;\n\n    // Workspace: wrk_v( max(n, m) ).\n    ls->wrk_u = (double *)xmalloc( mnmax, sizeof(double), \"wrk_u\" );\n    if (ls->wrk_u == NULL) goto error;\n\n    // Workspace: wrk_v( max(n, m) ).\n    ls->wrk_v = (double *)xmalloc( mnmax, sizeof(double), \"wrk_v\" );\n    if (ls->wrk_v == NULL) goto error;\n\n    // Workspace: wrk_w( max(n, m) ).\n    ls->wrk_w = (double *)xmalloc( mnmax, sizeof(double), \"wrk_w\" );\n    if (ls->wrk_w == NULL) goto error;\n\n    // -----------------------------------------------------------------\n    // Initialize this new problem instance.\n    // -----------------------------------------------------------------\n    bcls_init_prob( ls );\n\n    // -----------------------------------------------------------------\n    // Exits.\n    // -----------------------------------------------------------------\n\n    // Successfull exit.\n    return ls;\n\n error:\n    // Unsuccessful exit.\n    bcls_free_prob( ls );\n    return ls;\n}\n\n/*!\n\n  \\brief Initialize a BCLS problem.\n  \n  Initialize a BCLS problem.  You can call this routine to \"reset\" a\n  BCLS problem, i.e., reset all parameter values.  Note that it is\n  automatically called by bcls_create_prob.\n\n  \\param[in,out] ls  BCLS problem context.\n\n*/\nvoid\nbcls_init_prob( BCLS *ls )\n{\n    // Some quick error checking.\n    assert( ls->mmax > 0 && ls->nmax > 0 );\n\n    // Check if the problem has been successfully allocated.\n    if (ls == NULL) {\n\tfprintf( stderr, \"XXX The BCLS problem is NULL.\\n\");\n\treturn;\n    }\n    \n    // Initialize the problem structure.\n    ls->print_info    =  NULL;\n    ls->print_hook    =  NULL;\n    ls->fault_info    =  NULL;\n    ls->fault_hook    =  NULL;\n    ls->Aprod         =  NULL;\n    ls->Usolve        =  NULL;\n    ls->CallBack      =  NULL;\n    ls->UsrWrk        =  NULL;\n    ls->anorm         =  NULL;\n    ls->print_level   =  1;\n    ls->proj_search   =  BCLS_PROJ_SEARCH_EXACT;\n    ls->newton_step   =  BCLS_NEWTON_STEP_LSQR;\n    ls->minor_file    =  NULL;\n    ls->itnMaj        =  0;\n    ls->itnMajLim     =  5  * (ls->nmax);\n    ls->itnMin        =  0;\n    ls->itnMinLim     =  10 * (ls->nmax);\n    ls->nAprodT       =  0;\n    ls->nAprodF       =  0;\n    ls->nAprod1       =  0;\n    ls->nUsolve       =  0;\n    ls->m             =  0;\n    ls->n             =  0;\n    ls->unconstrained =  0;\n    ls->damp          =  0.0;\n    ls->damp_min      =  1.0e-4;\n    ls->exit          =  BCLS_EXIT_UNDEF;\n    ls->soln_rNorm    = -1.0;\n    ls->soln_dInf     =  0.0;\n    ls->soln_jInf     = -1;\n    ls->soln_stat     =  BCLS_SOLN_UNDEF;\n    ls->optTol        =  1.0e-6;\n    ls->conlim        =  1.0 / ( 10.0 * sqrt( DBL_EPSILON ) );\n    ls->mu            =  1.0e-2;\n    ls->backtrack     =  1.0e-1;\n    ls->backtrack_limit = 10;\n\n    // Initialize timers.\n    bcls_timer( &(ls->stopwatch[BCLS_TIMER_TOTAL] ),  BCLS_TIMER_INIT );\n    ls->stopwatch[BCLS_TIMER_TOTAL].name = \"Total time\";\n\n    bcls_timer( &(ls->stopwatch[BCLS_TIMER_APROD] ),  BCLS_TIMER_INIT );\n    ls->stopwatch[BCLS_TIMER_APROD].name = \"Total time for Aprod\";\n\n    bcls_timer( &(ls->stopwatch[BCLS_TIMER_USOLVE] ),  BCLS_TIMER_INIT );\n    ls->stopwatch[BCLS_TIMER_USOLVE].name = \"Total time for Usolve\";\n\n    bcls_timer( &(ls->stopwatch[BCLS_TIMER_LSQR] ),  BCLS_TIMER_INIT );\n    ls->stopwatch[BCLS_TIMER_LSQR].name = \"Total time for LSQR\";\n\n    // Initialize constants.\n    ls->eps         = DBL_EPSILON;\n    ls->eps2        = pow( DBL_EPSILON, 0.50 );\n    ls->eps3        = pow( DBL_EPSILON, 0.75 );\n    ls->epsx        = ls->eps3;\n    ls->epsfixed    = DBL_EPSILON;\n    ls->BigNum      = BCLS_INFINITY;\n\n    return;\n}\n\n/*!\n\n  \\brief Free and reinitialize all resources in an existing BCLS problem.\n\n  \\return\n  - 0: no errors\n  - 1: the BCLS problem is NULL (ie, does not exist).\n\n*/\nint\nbcls_free_prob( BCLS *ls )\n{\n    // Report an error if it's already NULL.\n    if (ls == NULL) return 1;\n\n    // Deallocate the workspace.\n    assert( ls->r       != NULL ); free( ls->r       );\n    assert( ls->g       != NULL ); free( ls->g       );\n    assert( ls->dx      != NULL ); free( ls->dx      );\n    assert( ls->dxFree  != NULL ); free( ls->dxFree  );\n    assert( ls->aBreak  != NULL ); free( ls->aBreak  );\n    assert( ls->iBreak  != NULL ); free( ls->iBreak  );\n    assert( ls->ix      != NULL ); free( ls->ix      );\n    assert( ls->wrk_u   != NULL ); free( ls->wrk_u   );\n    assert( ls->wrk_v   != NULL ); free( ls->wrk_v   );\n    assert( ls->wrk_w   != NULL ); free( ls->wrk_w   );\n    \n    // Deallocate the BCLS problem.\n    free( ls );\n    \n    return 0;\n}\n\n/*!\n\n  \n  \\brief Install a print-hook routine.\n\n  This routine installs a user-defined print-hook routine.\n  \n  The parameter info is a transit pointer passed to the hook routine.\n  \n  The parameter hook is an entry point to the user-defined print-hook\n  routine. This routine is called by the routine \"print\" every time an\n  informative message should be output. The routine \"print\" passes to\n  the hook routine the transit pointer info and the character string\n  msg, which contains the message. If the hook routine returns zero,\n  the routine print prints the message in an usual way. Otherwise, if\n  the hook routine returns non-zero, the message is not printed.\n  \n  In order to uninstall the hook routine the parameter hook should be\n  specified as NULL (in this case the parameter info is ignored).\n\n  \\param[in,out] ls    BCLS problem context.\n  \\param[in]     info  Transit pointer passed to the hook routine.\n  \\param[in]     hook  Pointer to the print-hook routine.\n\n*/\nvoid\nbcls_set_print_hook( BCLS *ls,\n\t\t     void *info,\n\t\t     int (*hook)(void *info, char *msg))\n{\n    ls->print_info = info;\n    ls->print_hook = hook;\n    return;\n}\n\n/*!\n\n  \\brief Install a fault-hook routine.\n\n  This routine installs a user-defined fault-hook routine.\n\n  The parameter info is a transit pointer passed to the hook routine.\n\n  The parameter \"hook\" is an entry point to the user-defined\n  fault-hook routine. This routine is called by the routine\n  \"bcls_fault\" every time an error message should be output. The\n  routine \"bcls_fault\" passes to the hook routine the transit pointer\n  info and the character string msg, which contains the message. If\n  the hook routine returns zero, the routine print prints the message\n  in an usual way. Otherwise, if the hook routine returns non-zero,\n  the message is not printed.\n\n  In order to uninstall the hook routine the parameter hook should be\n  specified as NULL (in this case the parameter info is ignored).\n\n  \\param[in,out] ls    BCLS problem context.\n  \\param[in]     info  Transit pointer passed to the hook routine.\n  \\param[in]     hook  Pointer to the fault-hook routine.\n\n*/\nvoid\nbcls_set_fault_hook( BCLS *ls,\n\t\t     void *info,\n\t\t     int (*hook)(void *info, char *msg))\n{\n    ls->fault_info = info;\n    ls->fault_hook = hook;\n    return;\n}\n\n/*!\n\n  \\brief Give BCLS access to set of column weights.\n\n  Define a set of column weights.  BCLS will use these to scale the\n  steepest-descent steps.\n\n  \\param[in,out] ls     BCLS problem context.\n  \\param[in]     anorm  Array of columns norms of A.\n\n*/\nvoid\nbcls_set_anorm( BCLS *ls,\n                double anorm[] )\n{\n    ls->anorm = anorm;\n    return;\n}\n\n/*!\n\n  \\brief Install a user-defined preconditioning routine.\n \n  Replace each subproblem\n  \\f[\n  \\def\\minimize{\\displaystyle\\mathop{\\hbox{minimize}}}\n  \\minimize_x \\| Ax - b \\|\n  \\f]\n  with\n  \\f[\n  \\def\\minimize{\\displaystyle\\mathop{\\hbox{minimize}}}\n  \\minimize_y \\| AU^{-1}y - b \\|\n  \\quad\\mbox{with}\\quad\n  Ux = y.\n  \\f]\n\n  \\param[in,out]  ls     BCLS problem context.\n  \\param[in]      Usolve Pointer to the user's preconditioning routine.\n\n*/\nvoid\nbcls_set_usolve( BCLS *ls,\n                 int (*Usolve)( int mode, int m, int n, int nix,\n                                int ix[], double v[], double w[],\n                                void *UsrWrk ) )\n{\n    assert( Usolve != NULL );\n    ls->Usolve = Usolve;\n    return;\n}\n\n\n/*!\n\n  \\brief Compute the column norms of A.\n\n  Compute the columns norms of A.  Each column of A is generated by\n  multiplying A by a unit vector.  The two-norm squared of each\n  column is stored in aprod.\n  \n  This routine must be called *after* bcls_create_prob.  (As with any\n  other BCLS routine.)\n\n  \\param[in]      ls      BCLS problem context.\n  \\param[in]      m       Number of rows in A.\n  \\param[in]      n       Number of columns in A.\n  \\param[in]      Aprod   User's matrix-product routine.\n  \\param[in,out]  UsrWrk  Pointer to user's workspace (could be NULL).\n  \\param[out]     anorm   Vector of column norms of A.\n  \n  \\return Returns any error codes returned by the user's aprod\n  routine.\n\n*/\nint\nbcls_compute_anorm( BCLS *ls, int n, int m,\n                    int (*Aprod)\n                    ( int mode, int m, int n, int nix,\n                      int ix[], double x[], double y[], void *UsrWrk ),\n                    void *UsrWrk,\n                    double anorm[] )\n{    \n    // Make sure that the problem instance has been created.\n    assert( ls    != NULL );\n    assert( anorm != NULL );\n\n    int j;\n    int err;\n    const int mode = 1;         // Always:  aj = A*ej.\n    const int nix  = 1;         // Only one column is ever needed.\n    int    *ix = ls->ix;\n    double *e  = ls->wrk_u;\n    double *aj = ls->wrk_v;\n\n    bcls_dload( n, 1.0, e, 1 );\n    \n    for (j = 0; j < n; j++) {\n\n        // Multiply A times the jth unit vector.\n        ix[0] = j;\n        \n        // aj <- A * ej.\n        err = Aprod( mode, m, n, nix, ix, e, aj, UsrWrk );\n\n        // Exit if Aprod returned an error.\n        if (err) break;\n\n        // Compute the norm of aj and store it in anorm.\n        anorm[j] = cblas_dnrm2( m, aj, 1 );\n\n        // Make sure that the column norm is too small.\n        anorm[j] = fmax( BCLS_MIN_COLUMN_NORM, anorm[j] );\n    }\n\n    return err;\n}\n\n/*!\n\n  \\brief Load the problem into the BCLS data structure.\n\n  The routiens loads the complete problem description into a BCLS\n  problem instance.  No work is really being done: only the various\n  structure elements are being set to point to the right places.\n\n  \\param[in,out]  ls      BCLS problem context.\n  \\param[in]      m       Number of rows in A.  Note: m <= mmax.\n  \\param[in]      n       Number of columns in A.  Note: n <= nmax.\n  \\param[in]      Aprod   Hook to user's matrix-vector product routine.\n  \\param[in,out]  UsrWrk  Transit pointer passed directly to Aprod/Usolve.\n  \\param[in]      damp    Regularization parameter.\n  \\param[in,out]  x       The starting point.\n  \\param[in]      b       The RHS vector.\n  \\param[in]      c       Defines a linear term (set to NULL if one doesn't exist).\n  \\param[in]      bl      Lower bounds on x.\n  \\param[in]      bu      Upper bounds on x.\n\n*/\nvoid\nbcls_set_problem_data( BCLS *ls, int m, int n,\n\t\t       int (*Aprod)( int mode, int m, int n, int nix,\n\t\t\t\t     int ix[], double x[], double y[],\n\t\t\t\t     void *UsrWrk ),\n\t\t       void *UsrWrk, double damp,\n\t\t       double x[], double b[], double c[],\n\t\t       double bl[], double bu[] )\n{\n    assert( m <= ls->mmax );\n    assert( n <= ls->nmax );\n\n    assert( Aprod  != NULL ); ls->Aprod  = Aprod;\n    assert( m      >= 0    ); ls->m      = m;\n    assert( n      >= 0    ); ls->n      = n;\n                              ls->UsrWrk = UsrWrk;\n    assert( damp   >= 0.0  ); ls->damp   = damp;\n    assert( x      != NULL ); ls->x      = x;\n    assert( b      != NULL ); ls->b      = b;\n                              ls->c      = c;\n    assert( bl     != NULL ); ls->bl     = bl;\n    assert( bu     != NULL ); ls->bu     = bu;\n\n    return;\n}\n\n/*!\n\n  \\brief Return an exit message.\n\n  \\param[in] flag  The code of the error.\n\n  \\return Error messsage.\n\n*/\nchar *\nbcls_exit_msg( int flag )\n{\n    char *msg;\n\n    if      (flag==BCLS_EXIT_CNVGD)  msg=\"Optimal solution found\";\n    else if (flag==BCLS_EXIT_MAJOR)  msg=\"Too many major iterations\";\n    else if (flag==BCLS_EXIT_MINOR)  msg=\"Too many minor iterations\";\n    else if (flag==BCLS_EXIT_UNBND)  msg=\"Found direction of infinite descent\";\n    else if (flag==BCLS_EXIT_INFEA)  msg=\"Bounds are inconsistent\";\n    else if (flag==BCLS_EXIT_APROD)  msg=\"Aprod requested immediate exit\";\n    else if (flag==BCLS_EXIT_USOLVE) msg=\"Usolve requested immediate exit\";\n    else if (flag==BCLS_EXIT_CALLBK) msg=\"CallBack requested immediate exit\";\n    else                             msg=\"Undefined exit\";\n\n    return msg;\n}\n\n/*!\n\n  \\brief Solve the current problem instance.\n\n  \\return\n   -  #BCLS_EXIT_CNVGD (0) - Successful exit.  Found an optimal solution.\n   -  #BCLS_EXIT_MAJOR     - Too many major iterations.\n   -  #BCLS_EXIT_MINOR     - Too many inner iterations.\n   -  #BCLS_EXIT_UNBND     - Found direction of infinite descent.\n   -  #BCLS_EXIT_INFEA     - Bounds are inconsistent.\n   -  #BCLS_EXIT_APROD     - Aprod  requested immediate exit.\n   -  #BCLS_EXIT_USOLVE    - Usolve requested immediate exit.\n\n*/\nint\nbcls_solve_prob( BCLS *ls )\n{\n    int err;\n    int jpInf;\n    const int preconditioning = ls->Usolve != NULL;\n    double pInf, timeTot;\n    double bNorm;  // Norm of the RHS (or 1.0, which ever is bigger).\n    BCLS_timer watch;\n\n    // Print the banner.\n    //PRINT1(\" ----------------------------------------------------\\n\");\n    //PRINT1(\" BCLS -- Bound-Constrained Least Squares, Version %s\\n\",\n    //      bcls_version_info() );\n    //PRINT1(\" Compiled on %s\\n\",  bcls_compilation_info() );\n    //PRINT1(\" ----------------------------------------------------\\n\");\n\n    // -----------------------------------------------------------------\n    // Print parameters and diagnostic information.\n    // -----------------------------------------------------------------\n    bcls_print_params( ls );\n\n    // Examine the bounds and print a summary about them.\n    // Also check if the problem is feasible!\n    err = bcls_examine_bnds( ls, ls->n, ls->bl, ls->bu );\n    if (err) {\n\tls->exit = err;\n        goto direct_exit;\n    }\n\n    // Set the return for longjmp.  First call to setjmp returns 0.\n    err = setjmp(ls->jmp_env);\n    if (err) {\n        ls->exit = err;\n        goto direct_exit;\n    }\n\n    // Compute and print some statistics about the column scales.\n    bcls_examine_column_scales( ls, ls->anorm );\n\n    // Print a log header.\n    //    PRINT1(\"\\n %5s  %5s    %9s  %9s  %11s  %9s %7s %7s %7s\\n\",\n    //\t   \"Major\",\"Minor\",\"Residual\",\"xNorm\",\"Optimal\",\n    //\t   ls->newton_step == BCLS_NEWTON_STEP_LSQR\n    //\t   ? \"LSQR\" : \"CGLS\",\n    //\t   \"nSteps\", \"Free\", \"OptFac\");\n\n    // -----------------------------------------------------------------\n    // Call the BCLS solver.\n    // -----------------------------------------------------------------\n    bcls_timer( &(ls->stopwatch[BCLS_TIMER_TOTAL]), BCLS_TIMER_START );\n\n    bcls_solver( ls, ls->m, ls->n, &bNorm,\n\t\t ls->x, ls->b, ls->c, ls->bl, ls->bu, ls->r, ls->g,\n\t\t ls->dx, ls->dxFree, ls->ix,\n\t\t ls->aBreak, ls->iBreak, ls->anorm );\n\n    bcls_timer( &(ls->stopwatch[BCLS_TIMER_TOTAL]), BCLS_TIMER_STOP );\n\n\n    // =================================================================\n    // Exits.\n    // =================================================================\n direct_exit:\n    // -----------------------------------------------------------------\n    // Check feasibility and print a solution summary (iterations, etc.)\n    // -----------------------------------------------------------------\n    bcls_primal_inf( ls->n, ls->x, ls->bl, ls->bu, &pInf, &jpInf );\n\n    //PRINT1(\"\\n\");\n    //    PRINT1(\" BCLS Exit %4d -- %s\\n\",ls->exit, bcls_exit_msg(ls->exit));\n    //PRINT1(\"\\n\");\n    //PRINT1(\" No. of iterations      %8d %7s\", ls->itnMin, \"\");\n    //PRINT1(\" Objective value       %17.9e\\n\", ls->soln_obj  );\n    //PRINT1(\" No. of major iterations%8d %7s\", ls->itnMaj, \"\");\n    //PRINT1(\" Optimality           (%7d) %8.1e\\n\",\n    //\t   ls->soln_jInf,ls->soln_dInf);\n    //PRINT1(\" No. of calls to Aprod  %8d\", ls->nAprodT);\n\n    //if (ls->proj_search == BCLS_PROJ_SEARCH_EXACT)\n    //   PRINT1(\" (%5d)\", ls->nAprod1 );\n    //else\n    //  PRINT1(\"  %5s \", \"\");\n    // PRINT1(\" Norm of RHS            %16.1e\\n\", bNorm);\n    // if (pInf > ls->eps)\n    //  PRINT1(\" Feasibility          (%7d) %7.1e\\n\", jpInf, pInf);\n    //if (preconditioning)\n    //  PRINT1(\" No. of calls to Usolve %8d\\n\", ls->nUsolve);\n    //PRINT1(\"\\n\");\n\n    // -----------------------------------------------------------------\n    // Print timing statistics.\n    // -----------------------------------------------------------------\n    //timeTot = fmax(ls->eps,ls->stopwatch[BCLS_TIMER_TOTAL].total);\n\n    //watch   = ls->stopwatch[BCLS_TIMER_TOTAL];\n    //timeTot = fmax(1e-6, watch.total); // Safeguard against timeTot = 0.\n\n    //PRINT1(\" %-25s %5.1f (%4.2f) secs\\n\",\n    //\t   watch.name, watch.total, 1.0 );\n\n    //watch = ls->stopwatch[BCLS_TIMER_LSQR];\n    //PRINT1(\" %-25s %5.1f (%4.2f) secs\\n\",\n    //\t   watch.name, watch.total, watch.total / timeTot );\n\n    //    watch = ls->stopwatch[BCLS_TIMER_APROD];\n    //PRINT1(\" %-25s %5.1f (%4.2f) secs\\n\",\n    //\t   watch.name, watch.total, watch.total / timeTot );\n\n    // Only print time for Usolve is user provided this routine.\n    //if (preconditioning) {\n      //  watch = ls->stopwatch[BCLS_TIMER_USOLVE];\n      //PRINT1(\" %-25s %5.1f (%4.2f) secs\\n\",\n      //       watch.name, watch.total, watch.total / timeTot );\n    //}\n\n    return (ls->exit + err);\n}\n", "meta": {"hexsha": "6c5670b51069f1e2f0f17e9110bf58bf0f353ac1", "size": 21731, "ext": "c", "lang": "C", "max_stars_repo_path": "bcls-0.1/src/bcls.c", "max_stars_repo_name": "echristakopoulou/glslim", "max_stars_repo_head_hexsha": "ad8e783e83b881042aaf97b985e5cba9aa1e9b9a", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2019-12-16T01:56:55.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-04T04:45:41.000Z", "max_issues_repo_path": "bcls-0.1/src/bcls.c", "max_issues_repo_name": "echristakopoulou/glslim", "max_issues_repo_head_hexsha": "ad8e783e83b881042aaf97b985e5cba9aa1e9b9a", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "bcls-0.1/src/bcls.c", "max_forks_repo_name": "echristakopoulou/glslim", "max_forks_repo_head_hexsha": "ad8e783e83b881042aaf97b985e5cba9aa1e9b9a", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2020-03-05T07:46:30.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-24T13:00:19.000Z", "avg_line_length": 31.9104258443, "max_line_length": 83, "alphanum_fraction": 0.564171, "num_tokens": 6134, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4960938294709195, "lm_q2_score": 0.07696084363512665, "lm_q1q2_score": 0.03817979963826262}}
{"text": "#ifndef ARRAY_H\n#define ARRAY_H\n\n#include <cstdarg>\n#include <cstdio>\n#include <cstdlib>\n#include <cassert>\n#include <iostream>\n#include <algorithm>\n#include <charm++.h>\n#if CMK_HAS_CBLAS\n#include <cblas.h>\n#endif\n\nnamespace CharjArray {\n  class Range {\n  public:\n    int size, start, stop;\n    Range() {}\n    Range(int size_) : size(size_), start(0), stop(size) {}\n    Range(int start_, int stop_) :\n    size(stop_ - start_), start(start_), stop(stop_) {\n      assert(stop >= start);\n    }\n    void pup(PUP::er& p) { \n        p | size;\n        p | start;\n        p | stop;\n    }\n  };\n\n  template<int dims>\n  class Domain {\n  public:\n    Range ranges[dims];\n    \n    Domain() {}\n\n    Domain(Range ranges_[]) {\n      for (int i = 0; i < dims; i++) \n\tranges[i] = ranges_[i];      \n    }\n\n    Domain(Range range) {\n      ranges[0] = range;\n    }\n\n    Domain(Range range1, Range range2) {\n      // TODO: fix Charj generator so it uses the array\n      ranges[0] = range1;\n      ranges[1] = range2;\n    }\n\n    int size() const {\n      int total = 0;\n\n      for (int i = 0; i < dims; i++)\n\tif (total == 0)\n\t  total = ranges[i].size;\n\telse\n\t  total *= ranges[i].size;\n\n      return total;\n    }\n\n    void pup(PUP::er& p) { \n        for (int i=0; i<dims; ++i) p | ranges[i];\n    }\n  };\n\n  template<int dims>\n  class RowMajor {\n  public:\n    static int access(const int i, const Domain<dims> &d) {\n      return i - d.ranges[0].start;\n    }\n    static int access(const int i, const int j, const Domain<dims> &d) {\n      return (i - d.ranges[0].start) * d.ranges[1].size + j -\n        d.ranges[1].start;\n    }\n    // Generic access method, not used right now.\n    // static int access(const int *i, const Domain<dims> &d) {\n    //   int off = i[0];\n    //   int dimoff = 1;\n    //   for (int j = ndims-1; j > 0; --j) {\n    //     dimoff *= d.ranges[j].size;\n    //     off += dimoff * (i[j] - d.ranges[j].start);\n    //   }\n    //   return off;\n    // }\n  };\n\n  template<int dims>\n  class ColMajor {\n  public:\n    static int access(const int i, const Domain<dims> &d) {\n      return i - d.ranges[0].start;\n    }\n    static int access(const int i, const int j, const Domain<dims> &d) {\n      return (j - d.ranges[1].start) * d.ranges[1].size + i -\n        d.ranges[0].start;\n    }\n  };\n\n  template<class type, int dims = 1, class atype = RowMajor<dims> >\n  class Array {\n  private:\n    Domain<dims> domain;\n    type *block;\n    int ref_cout;\n    bool did_init;\n    Array* ref_parent;\n\n  public:\n    Array(Domain<dims> domain_) : ref_parent(0), did_init(false) {\n      init(domain_);\n    }\n\n    Array(type **block_) : did_init(false) {\n      block = *block_;\n    }\n\n    Array(type& block_) : did_init(false) {\n      block = &block_;\n    }\n\n    Array() : ref_parent(0), did_init(false) {\n\n    }\n\n    Array(Array* parent, Domain<dims> domain_)\n        : ref_parent(parent), did_init(false) {\n      domain = domain_;\n      block = parent->block;\n    }\n\n    void init(Domain<dims> &domain_) {\n      domain = domain_;\n      //if (atype == ROW_MAJOR)\n      block = new type[domain.size()];\n      //printf(\"Array: allocating memory, size=%d, base pointer=%p\\n\",\n      //       domain.size(), block);\n      did_init = true;\n    }\n\n    type* raw() { return block; }\n\n    ~Array() {\n      if (did_init) delete[] block;\n    }\n\n    /*type* operator[] (const Domain<dims> &domain) {\n      return block[domain.ranges[0].size];\n      }*/\n\n    type& operator[] (const int i) {\n      return block[atype::access(i, domain)];\n    }\n\n    const type& operator[] (const int i) const {\n      return block[atype::access(i, domain)];\n    }\n\n    type& access(const int i) {\n      return this->operator[](i);\n    }\n\n    type& access(const int i, const int j) {\n      //printf(\"Array: accessing, index (%d,%d), offset=%d, base pointer=%p\\n\",\n      //i, j, atype::access(i, j, domain), block);\n      return block[atype::access(i, j, domain)];\n    }\n\n    type& access(const int i, const Range r) {\n      Domain<1> d(r);\n      //printf(\"Array: accessing subrange, size = %d, range (%d,%d), base pointer=%p\\n\",\n      //d.size(), r.start, r.stop, block);\n      type* buf = new type[d.size()];\n      for (int j = 0; j < d.size(); j++) {\n        //printf(\"Array: copying element (%d,%d), base pointer=%p\\n\", i, j, block);\n        buf[j] = block[atype::access(i, j, domain)];\n      }\n      return *buf;\n    }\n\n    const type& access(const int i, const int j) const {\n      return block[atype::access(i, j, domain)];\n    }\n\n    Array<type, dims, atype>* operator[] (const Domain<dims> &domain) {\n      return new Array<type, dims, atype>(this, domain);\n    }\n\n    int size() const {\n      return domain.size();\n    }\n\n    int size(int dim) const {\n      return domain.ranges[dim].size;\n    }\n\n    void pup(PUP::er& p) { \n        p | domain;\n        if (p.isUnpacking()) {\n            block = new type[domain.size()];\n        }\n        PUParray(p, block, domain.size());\n    }\n\n    void fill(const type &t) {\n      for (int i = 0; i < domain.size(); ++i)\n\tblock[i] = t;\n    }\n\n    /// Do these arrays have the same shape and contents?\n    bool operator==(const Array &rhs) const\n    {\n      for (int i = 0; i < dims; ++i)\n\tif (this->size(i) != rhs.size(i))\n\t  return false;\n\n      for (int i = 0; i < this->size(); ++i)\n\tif (this->block[i] != rhs.block[i])\n\t  return false;\n\n      return true;\n    }\n    bool operator!=(const Array &rhs) const\n    {\n      return !(*this == rhs);\n    }\n  };\n\n  /**\n     A local Matrix class for various sorts of linear-algebra work.\n\n     Indexed from 0, to reflect the C-heritage of Charj.\n   */\n  template <typename V, class atype = RowMajor<2> >\n  class Matrix : public Array<V, 2, atype>\n  {\n  public:\n    Matrix() { }\n    /// A square matrix\n    Matrix(unsigned int n) : Array<V,2,atype>(Domain<2>(n,n)) { }\n\n    /// A identity matrix\n    static Matrix* ident(int n)\n    {\n      Matrix *ret = new Matrix(n);\n      ret->fill(0);\n\n      for (int i = 0; i < n; ++i)\n\tret->access(i,i) = 1;\n\n      return ret;\n    }\n  };\n\n  template <typename T, class atype = RowMajor<1> >\n  class Vector : public Array<T, 1, atype>\n  {\n  public:\n    Vector() { }\n    Vector(unsigned int n) : Array<T, 1, atype>(Range(n)) { }\n  };\n\n  /// Compute the inner (dot) product v1^T * v2\n  // To compute v1^H * v2, call as dot(v1.C(), v2)\n  template<typename T, class atype1, class atype2>\n  T dot(const Vector<T, atype1> *pv1, const Vector<T, atype2> *pv2)\n  {\n    const Vector<T, atype1> &v1 = *pv1, &v2 = *pv2;\n    assert(v1.size() == v2.size());\n    // XXX: This default initialization worries me some, since it\n    // won't necessarily be an additive identity for all T. - Phil\n    T ret = T();\n    int size = v1.size();\n    for (int i = 0; i < size; ++i)\n      ret += v1[i] * v2[i];\n    return ret;\n  }\n#if CMK_HAS_CBLAS\n  template <>\n  float dot<float, RowMajor<1>, RowMajor<1> >(const Vector<float, RowMajor<1> > *pv1,\n\t\t\t\t\t      const Vector<float, RowMajor<1> > *pv2)\n  {\n    const Vector<float, RowMajor<1> > &v1 = *pv1, &v2 = *pv2;\n    assert(v1.size() == v2.size());\n    return cblas_sdot(v1.size(), &(v1[0]), 1, &(v2[0]), 1);\n  }\n  template <>\n  double dot<double, RowMajor<1>, RowMajor<1> >(const Vector<double, RowMajor<1> > *pv1,\n\t\t\t\t\t\tconst Vector<double, RowMajor<1> > *pv2)\n  {\n    const Vector<double, RowMajor<1> > &v1 = *pv1, &v2 = *pv2;\n    assert(v1.size() == v2.size());\n    return cblas_ddot(v1.size(), &(v1[0]), 1, &(v2[0]), 1);\n  }\n#endif\n\n  /// Computer the 1-norm of the given vector\n  template<typename T, class atype>\n    T norm1(const Vector<T, atype> *pv)\n  {\n    const Vector<T, atype> &v = *pv;\n    // XXX: See comment about additive identity in dot(), above\n    T ret = T();\n    int size = v.size();\n    for (int i = 0; i < size; ++i)\n      ret += v[i];\n    return ret;\n  }\n\n  /// Compute the Euclidean (2) norm of the given vector\n  template<typename T, class atype>\n    T norm2(const Vector<T, atype> *pv)\n  {\n    const Vector<T, atype> &v = *pv;\n    // XXX: See comment about additive identity in dot(), above\n    T ret = T();\n    int size = v.size();\n    for (int i = 0; i < size; ++i)\n      ret += v[i] * v[i];\n    return sqrt(ret);\n  }\n#if CMK_HAS_CBLAS\n  template<>\n    float norm2<float, RowMajor<1> >(const Vector<float, RowMajor<1> > *pv)\n  {\n    const Vector<float, RowMajor<1> > &v = *pv;\n    return cblas_snrm2(v.size(), &(v[0]), 1);\n  }\n  template<>\n    double norm2<double, RowMajor<1> >(const Vector<double, RowMajor<1> > *pv)\n  {\n    const Vector<double, RowMajor<1> > &v = *pv;\n    return cblas_dnrm2(v.size(), &(v[0]), 1);\n  }\n#endif\n\n  /// Compute the infinity (max) norm of the given vector\n  // Will fail on zero-length vectors\n  template<typename T, class atype>\n    T normI(const Vector<T, atype> *pv)\n  {\n    const Vector<T, atype> &v = *pv;\n    T ret = v[0];\n    int size = v.size();\n    for (int i = 1; i < size; ++i)\n      ret = max(ret, v[i]);\n    return ret;\n  }\n\n  /// Scale a vector by some constant\n  template<typename T, typename U, class atype>\n    void scale(const T &t, Vector<U, atype> *pv)\n  {\n    const Vector<T, atype> &v = *pv;\n    int size = v.size();\n    for (int i = 0; i < size; ++i)\n      v[i] = t * v[i];\n  }\n#if CMK_HAS_CBLAS\n  template<>\n    void scale<float, float, RowMajor<1> >(const float &t,\n\t\t\t\t\t   Vector<float, RowMajor<1> > *pv)\n  {\n    Vector<float, RowMajor<1> > &v = *pv;\n    cblas_sscal(v.size(), t, &(v[0]), 1);\n  }\n  template<>\n    void scale<double, double, RowMajor<1> >(const double &t,\n\t\t\t\t\t     Vector<double, RowMajor<1> > *pv)\n  {\n    Vector<double, RowMajor<1> > &v = *pv;\n    cblas_dscal(v.size(), t, &(v[0]), 1);\n  }\n#endif\n\n  /// Add one vector to a scaled version of another\n  template<typename T, typename U, class atype>\n    void axpy(const T &a, const Vector<U, atype> *px, Vector<U, atype> *py)\n  {\n    Vector<T, atype> &x = *px;\n    const Vector<T, atype> &y = *py;\n    int size = x.size();\n    assert(size == y.size());\n    for (int i = 0; i < size; ++i)\n      x[i] = a * x[i] + y[i];\n  }\n#if CMK_HAS_CBLAS\n  template<>\n    void axpy<float, float, RowMajor<1> >(const float &a,\n\t\t\t\t\t  const Vector<float, RowMajor<1> > *px,\n\t\t\t\t\t  Vector<float, RowMajor<1> > *py)\n  {\n    const Vector<float, RowMajor<1> > &x = *px;\n    Vector<float, RowMajor<1> > &y = *py;\n    int size = x.size();\n    assert(size == y.size());\n    cblas_saxpy(size, a, &(x[0]), 1, &(y[0]), 1);\n  }\n  template<>\n    void axpy<double, double, RowMajor<1> >(const double &a,\n\t\t\t\t\t  const Vector<double, RowMajor<1> > *px,\n\t\t\t\t\t  Vector<double, RowMajor<1> > *py)\n  {\n    const Vector<double, RowMajor<1> > &x = *px;\n    Vector<double, RowMajor<1> > &y = *py;\n    int size = x.size();\n    assert(size == y.size());\n    cblas_daxpy(size, a, &(x[0]), 1, &(y[0]), 1);\n  }\n#endif\n}\n\n#endif\n", "meta": {"hexsha": "f3b248ce11b4b67b29cab17b3abfa0aadd09e74f", "size": 10729, "ext": "h", "lang": "C", "max_stars_repo_path": "NAMD_2.12_Source/charm-6.7.1/src/langs/charj/src/charj/libs/Array.h", "max_stars_repo_name": "scottkwarren/config-db", "max_stars_repo_head_hexsha": "fb5c3da2465e5cff0ad30950493b11d452bd686b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2019-01-17T20:07:23.000Z", "max_stars_repo_stars_event_max_datetime": "2019-01-17T20:07:23.000Z", "max_issues_repo_path": "NAMD_2.12_Source/charm-6.7.1/src/langs/charj/src/charj/libs/Array.h", "max_issues_repo_name": "scottkwarren/config-db", "max_issues_repo_head_hexsha": "fb5c3da2465e5cff0ad30950493b11d452bd686b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "NAMD_2.12_Source/charm-6.7.1/src/langs/charj/src/charj/libs/Array.h", "max_forks_repo_name": "scottkwarren/config-db", "max_forks_repo_head_hexsha": "fb5c3da2465e5cff0ad30950493b11d452bd686b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.6062052506, "max_line_length": 88, "alphanum_fraction": 0.5543853108, "num_tokens": 3371, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4687906266262437, "lm_q2_score": 0.07807816407233609, "lm_q1q2_score": 0.0366023114612971}}
{"text": "// Copyright (c) 2017, Lawrence Livermore National Security, LLC. Produced at\n// the Lawrence Livermore National Laboratory. LLNL-CODE-734707. All Rights\n// reserved. See files LICENSE and NOTICE for details.\n//\n// This file is part of CEED, a collection of benchmarks, miniapps, software\n// libraries and APIs for efficient high-order finite element and spectral\n// element discretizations for exascale applications. For more information and\n// source code availability see http://github.com/ceed.\n//\n// The CEED research is supported by the Exascale Computing Project 17-SC-20-SC,\n// a collaborative effort of two U.S. Department of Energy organizations (Office\n// of Science and the National Nuclear Security Administration) responsible for\n// the planning and preparation of a capable exascale ecosystem, including\n// software, applications, hardware, advanced system engineering and early\n// testbed platforms, in support of the nation's exascale computing imperative.\n\n//                        libCEED + PETSc Example: CEED BPs\n//\n// This example demonstrates a simple usage of libCEED with PETSc to solve the\n// CEED BP benchmark problems, see http://ceed.exascaleproject.org/bps.\n//\n// The code uses higher level communication protocols in DMPlex.\n//\n// Build with:\n//\n//     make bps [PETSC_DIR=</path/to/petsc>] [CEED_DIR=</path/to/libceed>]\n//\n// Sample runs:\n//\n//     ./bps -problem bp1 -degree 3\n//     ./bps -problem bp2 -degree 3\n//     ./bps -problem bp3 -degree 3\n//     ./bps -problem bp4 -degree 3\n//     ./bps -problem bp5 -degree 3 -ceed /cpu/self\n//     ./bps -problem bp6 -degree 3 -ceed /gpu/cuda\n//\n//TESTARGS -ceed {ceed_resource} -test -problem bp5 -degree 3 -ksp_max_it_clip 15,15\n\n/// @file\n/// CEED BPs example using PETSc with DMPlex\n/// See bpsraw.c for a \"raw\" implementation using a structured grid.\nconst char help[] = \"Solve CEED BPs using PETSc with DMPlex\\n\";\n\n#include <stdbool.h>\n#include <string.h>\n#include <ceed.h>\n#include <petsc.h>\n#include <petscdmplex.h>\n#include <petscksp.h>\n#include <petscsys.h>\n\n#include \"bps.h\"\n#include \"include/bpsproblemdata.h\"\n#include \"include/petscmacros.h\"\n#include \"include/petscutils.h\"\n#include \"include/matops.h\"\n#include \"include/structs.h\"\n#include \"include/libceedsetup.h\"\n\n#if PETSC_VERSION_LT(3,12,0)\n#ifdef PETSC_HAVE_CUDA\n#include <petsccuda.h>\n// Note: With PETSc prior to version 3.12.0, providing the source path to\n//       include 'cublas_v2.h' will be needed to use 'petsccuda.h'.\n#endif\n#endif\n\n// -----------------------------------------------------------------------------\n// Utilities\n// -----------------------------------------------------------------------------\n\n// Utility function, compute three factors of an integer\nstatic void Split3(PetscInt size, PetscInt m[3], bool reverse) {\n  for (PetscInt d=0, size_left=size; d<3; d++) {\n    PetscInt try = (PetscInt)PetscCeilReal(PetscPowReal(size_left, 1./(3 - d)));\n    while (try * (size_left / try) != size_left) try++;\n    m[reverse ? 2-d : d] = try;\n    size_left /= try;\n  }\n}\n\nstatic int Max3(const PetscInt a[3]) {\n  return PetscMax(a[0], PetscMax(a[1], a[2]));\n}\n\nstatic int Min3(const PetscInt a[3]) {\n  return PetscMin(a[0], PetscMin(a[1], a[2]));\n}\n\n// -----------------------------------------------------------------------------\n// Parameter structure for running problems\n// -----------------------------------------------------------------------------\ntypedef struct RunParams_ *RunParams;\nstruct RunParams_ {\n  MPI_Comm comm;\n  PetscBool test_mode, read_mesh, user_l_nodes, write_solution;\n  char *filename, *hostname;\n  PetscInt local_nodes, degree, q_extra, dim, num_comp_u, *mesh_elem;\n  PetscInt ksp_max_it_clip[2];\n  PetscMPIInt ranks_per_node;\n  BPType bp_choice;\n  PetscLogStage solve_stage;\n};\n\n// -----------------------------------------------------------------------------\n// Main body of program, called in a loop for performance benchmarking purposes\n// -----------------------------------------------------------------------------\nstatic PetscErrorCode RunWithDM(RunParams rp, DM dm,\n                                const char *ceed_resource) {\n  PetscErrorCode ierr;\n  double my_rt_start, my_rt, rt_min, rt_max;\n  PetscInt xl_size, l_size, g_size;\n  PetscScalar *r;\n  Vec X, X_loc, rhs, rhs_loc;\n  Mat mat_O;\n  KSP ksp;\n  UserO user_O;\n  Ceed ceed;\n  CeedData ceed_data;\n  CeedQFunction qf_error;\n  CeedOperator op_error;\n  CeedVector rhs_ceed, target;\n  VecType vec_type;\n  PetscMemType mem_type;\n\n  PetscFunctionBeginUser;\n  // Set up libCEED\n  CeedInit(ceed_resource, &ceed);\n  CeedMemType mem_type_backend;\n  CeedGetPreferredMemType(ceed, &mem_type_backend);\n\n  ierr = DMGetVecType(dm, &vec_type); CHKERRQ(ierr);\n  if (!vec_type) { // Not yet set by user -dm_vec_type\n    switch (mem_type_backend) {\n    case CEED_MEM_HOST: vec_type = VECSTANDARD; break;\n    case CEED_MEM_DEVICE: {\n      const char *resolved;\n      CeedGetResource(ceed, &resolved);\n      if (strstr(resolved, \"/gpu/cuda\")) vec_type = VECCUDA;\n      else if (strstr(resolved, \"/gpu/hip/occa\"))\n        vec_type = VECSTANDARD; // https://github.com/CEED/libCEED/issues/678\n      else if (strstr(resolved, \"/gpu/hip\")) vec_type = VECHIP;\n      else vec_type = VECSTANDARD;\n    }\n    }\n    ierr = DMSetVecType(dm, vec_type); CHKERRQ(ierr);\n  }\n\n  // Create global and local solution vectors\n  ierr = DMCreateGlobalVector(dm, &X); CHKERRQ(ierr);\n  ierr = VecGetLocalSize(X, &l_size); CHKERRQ(ierr);\n  ierr = VecGetSize(X, &g_size); CHKERRQ(ierr);\n  ierr = DMCreateLocalVector(dm, &X_loc); CHKERRQ(ierr);\n  ierr = VecGetSize(X_loc, &xl_size); CHKERRQ(ierr);\n  ierr = VecDuplicate(X, &rhs); CHKERRQ(ierr);\n\n  // Operator\n  ierr = PetscMalloc1(1, &user_O); CHKERRQ(ierr);\n  ierr = MatCreateShell(rp->comm, l_size, l_size, g_size, g_size,\n                        user_O, &mat_O); CHKERRQ(ierr);\n  ierr = MatShellSetOperation(mat_O, MATOP_MULT,\n                              (void(*)(void))MatMult_Ceed); CHKERRQ(ierr);\n  ierr = MatShellSetOperation(mat_O, MATOP_GET_DIAGONAL,\n                              (void(*)(void))MatGetDiag); CHKERRQ(ierr);\n  ierr = MatShellSetVecType(mat_O, vec_type); CHKERRQ(ierr);\n\n  // Print summary\n  if (!rp->test_mode) {\n    PetscInt P = rp->degree + 1, Q = P + rp->q_extra;\n\n    const char *used_resource;\n    CeedGetResource(ceed, &used_resource);\n\n    VecType vec_type;\n    ierr = VecGetType(X, &vec_type); CHKERRQ(ierr);\n\n    PetscInt c_start, c_end;\n    ierr = DMPlexGetHeightStratum(dm, 0, &c_start, &c_end); CHKERRQ(ierr);\n    PetscMPIInt comm_size;\n    ierr = MPI_Comm_size(rp->comm, &comm_size); CHKERRQ(ierr);\n    ierr = PetscPrintf(rp->comm,\n                       \"\\n-- CEED Benchmark Problem %d -- libCEED + PETSc --\\n\"\n                       \"  MPI:\\n\"\n                       \"    Hostname                           : %s\\n\"\n                       \"    Total ranks                        : %d\\n\"\n                       \"    Ranks per compute node             : %d\\n\"\n                       \"  PETSc:\\n\"\n                       \"    PETSc Vec Type                     : %s\\n\"\n                       \"  libCEED:\\n\"\n                       \"    libCEED Backend                    : %s\\n\"\n                       \"    libCEED Backend MemType            : %s\\n\"\n                       \"  Mesh:\\n\"\n                       \"    Number of 1D Basis Nodes (P)       : %d\\n\"\n                       \"    Number of 1D Quadrature Points (Q) : %d\\n\"\n                       \"    Global nodes                       : %D\\n\"\n                       \"    Local Elements                     : %D\\n\"\n                       \"    Owned nodes                        : %D\\n\"\n                       \"    DoF per node                       : %D\\n\",\n                       rp->bp_choice+1, rp->hostname, comm_size,\n                       rp->ranks_per_node, vec_type, used_resource,\n                       CeedMemTypes[mem_type_backend],\n                       P, Q, g_size/rp->num_comp_u, c_end - c_start, l_size/rp->num_comp_u,\n                       rp->num_comp_u);\n    CHKERRQ(ierr);\n  }\n\n  // Create RHS vector\n  ierr = VecDuplicate(X_loc, &rhs_loc); CHKERRQ(ierr);\n  ierr = VecZeroEntries(rhs_loc); CHKERRQ(ierr);\n  ierr = VecGetArrayAndMemType(rhs_loc, &r, &mem_type); CHKERRQ(ierr);\n  CeedVectorCreate(ceed, xl_size, &rhs_ceed);\n  CeedVectorSetArray(rhs_ceed, MemTypeP2C(mem_type), CEED_USE_POINTER, r);\n\n  ierr = PetscMalloc1(1, &ceed_data); CHKERRQ(ierr);\n  ierr = SetupLibceedByDegree(dm, ceed, rp->degree, rp->dim, rp->q_extra,\n                              rp->dim, rp->num_comp_u, g_size, xl_size, bp_options[rp->bp_choice],\n                              ceed_data, true, rhs_ceed, &target); CHKERRQ(ierr);\n\n  // Gather RHS\n  CeedVectorTakeArray(rhs_ceed, MemTypeP2C(mem_type), NULL);\n  ierr = VecRestoreArrayAndMemType(rhs_loc, &r); CHKERRQ(ierr);\n  ierr = VecZeroEntries(rhs); CHKERRQ(ierr);\n  ierr = DMLocalToGlobal(dm, rhs_loc, ADD_VALUES, rhs); CHKERRQ(ierr);\n  CeedVectorDestroy(&rhs_ceed);\n\n  // Create the error QFunction\n  CeedQFunctionCreateInterior(ceed, 1, bp_options[rp->bp_choice].error,\n                              bp_options[rp->bp_choice].error_loc, &qf_error);\n  CeedQFunctionAddInput(qf_error, \"u\", rp->num_comp_u, CEED_EVAL_INTERP);\n  CeedQFunctionAddInput(qf_error, \"true_soln\", rp->num_comp_u, CEED_EVAL_NONE);\n  CeedQFunctionAddOutput(qf_error, \"error\", rp->num_comp_u, CEED_EVAL_NONE);\n\n  // Create the error operator\n  CeedOperatorCreate(ceed, qf_error, CEED_QFUNCTION_NONE, CEED_QFUNCTION_NONE,\n                     &op_error);\n  CeedOperatorSetField(op_error, \"u\", ceed_data->elem_restr_u,\n                       ceed_data->basis_u, CEED_VECTOR_ACTIVE);\n  CeedOperatorSetField(op_error, \"true_soln\", ceed_data->elem_restr_u_i,\n                       CEED_BASIS_COLLOCATED, target);\n  CeedOperatorSetField(op_error, \"error\", ceed_data->elem_restr_u_i,\n                       CEED_BASIS_COLLOCATED, CEED_VECTOR_ACTIVE);\n\n  // Set up Mat\n  user_O->comm = rp->comm;\n  user_O->dm = dm;\n  user_O->X_loc = X_loc;\n  ierr = VecDuplicate(X_loc, &user_O->Y_loc); CHKERRQ(ierr);\n  user_O->x_ceed = ceed_data->x_ceed;\n  user_O->y_ceed = ceed_data->y_ceed;\n  user_O->op = ceed_data->op_apply;\n  user_O->ceed = ceed;\n\n  ierr = KSPCreate(rp->comm, &ksp); CHKERRQ(ierr);\n  {\n    PC pc;\n    ierr = KSPGetPC(ksp, &pc); CHKERRQ(ierr);\n    if (rp->bp_choice == CEED_BP1 || rp->bp_choice == CEED_BP2) {\n      ierr = PCSetType(pc, PCJACOBI); CHKERRQ(ierr);\n      ierr = PCJacobiSetType(pc, PC_JACOBI_ROWSUM); CHKERRQ(ierr);\n    } else {\n      ierr = PCSetType(pc, PCNONE); CHKERRQ(ierr);\n    }\n    ierr = KSPSetType(ksp, KSPCG); CHKERRQ(ierr);\n    ierr = KSPSetNormType(ksp, KSP_NORM_NATURAL); CHKERRQ(ierr);\n    ierr = KSPSetTolerances(ksp, 1e-10, PETSC_DEFAULT, PETSC_DEFAULT,\n                            PETSC_DEFAULT); CHKERRQ(ierr);\n  }\n  ierr = KSPSetOperators(ksp, mat_O, mat_O); CHKERRQ(ierr);\n\n  // First run's performance log is not considered for benchmarking purposes\n  ierr = KSPSetTolerances(ksp, 1e-10, PETSC_DEFAULT, PETSC_DEFAULT, 1);\n  CHKERRQ(ierr);\n  my_rt_start = MPI_Wtime();\n  ierr = KSPSolve(ksp, rhs, X); CHKERRQ(ierr);\n  my_rt = MPI_Wtime() - my_rt_start;\n  ierr = MPI_Allreduce(MPI_IN_PLACE, &my_rt, 1, MPI_DOUBLE, MPI_MIN, rp->comm);\n  CHKERRQ(ierr);\n  // Set maxits based on first iteration timing\n  if (my_rt > 0.02) {\n    ierr = KSPSetTolerances(ksp, 1e-10, PETSC_DEFAULT, PETSC_DEFAULT,\n                            rp->ksp_max_it_clip[0]);\n    CHKERRQ(ierr);\n  } else {\n    ierr = KSPSetTolerances(ksp, 1e-10, PETSC_DEFAULT, PETSC_DEFAULT,\n                            rp->ksp_max_it_clip[1]);\n    CHKERRQ(ierr);\n  }\n  ierr = KSPSetFromOptions(ksp); CHKERRQ(ierr);\n\n  // Timed solve\n  ierr = VecZeroEntries(X); CHKERRQ(ierr);\n  ierr = PetscBarrier((PetscObject)ksp); CHKERRQ(ierr);\n\n  // -- Performance logging\n  ierr = PetscLogStagePush(rp->solve_stage); CHKERRQ(ierr);\n\n  // -- Solve\n  my_rt_start = MPI_Wtime();\n  ierr = KSPSolve(ksp, rhs, X); CHKERRQ(ierr);\n  my_rt = MPI_Wtime() - my_rt_start;\n\n  // -- Performance logging\n  ierr = PetscLogStagePop();\n\n  // Output results\n  {\n    KSPType ksp_type;\n    KSPConvergedReason reason;\n    PetscReal rnorm;\n    PetscInt its;\n    ierr = KSPGetType(ksp, &ksp_type); CHKERRQ(ierr);\n    ierr = KSPGetConvergedReason(ksp, &reason); CHKERRQ(ierr);\n    ierr = KSPGetIterationNumber(ksp, &its); CHKERRQ(ierr);\n    ierr = KSPGetResidualNorm(ksp, &rnorm); CHKERRQ(ierr);\n    if (!rp->test_mode || reason < 0 || rnorm > 1e-8) {\n      ierr = PetscPrintf(rp->comm,\n                         \"  KSP:\\n\"\n                         \"    KSP Type                           : %s\\n\"\n                         \"    KSP Convergence                    : %s\\n\"\n                         \"    Total KSP Iterations               : %D\\n\"\n                         \"    Final rnorm                        : %e\\n\",\n                         ksp_type, KSPConvergedReasons[reason], its,\n                         (double)rnorm); CHKERRQ(ierr);\n    }\n    if (!rp->test_mode) {\n      ierr = PetscPrintf(rp->comm,\"  Performance:\\n\"); CHKERRQ(ierr);\n    }\n    {\n      PetscReal max_error;\n      ierr = ComputeErrorMax(user_O, op_error, X, target, &max_error);\n      CHKERRQ(ierr);\n      PetscReal tol = 5e-2;\n      if (!rp->test_mode || max_error > tol) {\n        ierr = MPI_Allreduce(&my_rt, &rt_min, 1, MPI_DOUBLE, MPI_MIN, rp->comm);\n        CHKERRQ(ierr);\n        ierr = MPI_Allreduce(&my_rt, &rt_max, 1, MPI_DOUBLE, MPI_MAX, rp->comm);\n        CHKERRQ(ierr);\n        ierr = PetscPrintf(rp->comm,\n                           \"    Pointwise Error (max)              : %e\\n\"\n                           \"    CG Solve Time                      : %g (%g) sec\\n\",\n                           (double)max_error, rt_max, rt_min); CHKERRQ(ierr);\n      }\n    }\n    if (!rp->test_mode) {\n      ierr = PetscPrintf(rp->comm,\n                         \"    DoFs/Sec in CG                     : %g (%g) million\\n\",\n                         1e-6*g_size*its/rt_max,\n                         1e-6*g_size*its/rt_min); CHKERRQ(ierr);\n    }\n  }\n\n  if (rp->write_solution) {\n    PetscViewer vtk_viewer_soln;\n\n    ierr = PetscViewerCreate(rp->comm, &vtk_viewer_soln); CHKERRQ(ierr);\n    ierr = PetscViewerSetType(vtk_viewer_soln, PETSCVIEWERVTK); CHKERRQ(ierr);\n    ierr = PetscViewerFileSetName(vtk_viewer_soln, \"solution.vtu\"); CHKERRQ(ierr);\n    ierr = VecView(X, vtk_viewer_soln); CHKERRQ(ierr);\n    ierr = PetscViewerDestroy(&vtk_viewer_soln); CHKERRQ(ierr);\n  }\n\n  // Cleanup\n  ierr = VecDestroy(&X); CHKERRQ(ierr);\n  ierr = VecDestroy(&X_loc); CHKERRQ(ierr);\n  ierr = VecDestroy(&user_O->Y_loc); CHKERRQ(ierr);\n  ierr = MatDestroy(&mat_O); CHKERRQ(ierr);\n  ierr = PetscFree(user_O); CHKERRQ(ierr);\n  ierr = CeedDataDestroy(0, ceed_data); CHKERRQ(ierr);\n\n  ierr = VecDestroy(&rhs); CHKERRQ(ierr);\n  ierr = VecDestroy(&rhs_loc); CHKERRQ(ierr);\n  ierr = KSPDestroy(&ksp); CHKERRQ(ierr);\n  CeedVectorDestroy(&target);\n  CeedQFunctionDestroy(&qf_error);\n  CeedOperatorDestroy(&op_error);\n  CeedDestroy(&ceed);\n  PetscFunctionReturn(0);\n}\n\nstatic PetscErrorCode Run(RunParams rp, PetscInt num_resources,\n                          char *const *ceed_resources, PetscInt num_bp_choices,\n                          const BPType *bp_choices) {\n  PetscInt ierr;\n  DM dm;\n\n  PetscFunctionBeginUser;\n  // Setup DM\n  if (rp->read_mesh) {\n    ierr = DMPlexCreateFromFile(PETSC_COMM_WORLD, rp->filename, PETSC_TRUE, &dm);\n    CHKERRQ(ierr);\n  } else {\n    if (rp->user_l_nodes) {\n      // Find a nicely composite number of elements no less than global nodes\n      PetscMPIInt size;\n      ierr = MPI_Comm_size(rp->comm, &size); CHKERRQ(ierr);\n      for (PetscInt g_elem =\n             PetscMax(1, size * rp->local_nodes / PetscPowInt(rp->degree, rp->dim));\n           ;\n           g_elem++) {\n        Split3(g_elem, rp->mesh_elem, true);\n        if (Max3(rp->mesh_elem) / Min3(rp->mesh_elem) <= 2) break;\n      }\n    }\n    ierr = DMPlexCreateBoxMesh(PETSC_COMM_WORLD, rp->dim, PETSC_FALSE,\n                               rp->mesh_elem,\n                               NULL, NULL, NULL, PETSC_TRUE, &dm); CHKERRQ(ierr);\n  }\n\n  {\n    DM dm_dist = NULL;\n    PetscPartitioner part;\n\n    ierr = DMPlexGetPartitioner(dm, &part); CHKERRQ(ierr);\n    ierr = PetscPartitionerSetFromOptions(part); CHKERRQ(ierr);\n    ierr = DMPlexDistribute(dm, 0, NULL, &dm_dist); CHKERRQ(ierr);\n    if (dm_dist) {\n      ierr = DMDestroy(&dm); CHKERRQ(ierr);\n      dm  = dm_dist;\n    }\n  }\n  // Disable default VECSTANDARD *after* distribution (which creates a Vec)\n  ierr = DMSetVecType(dm, NULL); CHKERRQ(ierr);\n\n  for (PetscInt b = 0; b < num_bp_choices; b++) {\n    DM dm_deg;\n    VecType vec_type;\n    PetscInt q_extra = rp->q_extra;\n    rp->bp_choice = bp_choices[b];\n    rp->num_comp_u = bp_options[rp->bp_choice].num_comp_u;\n    rp->q_extra = q_extra < 0 ? bp_options[rp->bp_choice].q_extra : q_extra;\n    ierr = DMClone(dm, &dm_deg); CHKERRQ(ierr);\n    ierr = DMGetVecType(dm, &vec_type); CHKERRQ(ierr);\n    ierr = DMSetVecType(dm_deg, vec_type); CHKERRQ(ierr);\n    // Create DM\n    PetscInt dim;\n    ierr = DMGetDimension(dm_deg, &dim); CHKERRQ(ierr);\n    ierr = SetupDMByDegree(dm_deg, rp->degree, rp->num_comp_u, dim,\n                           bp_options[rp->bp_choice].enforce_bc,\n                           bp_options[rp->bp_choice].bc_func); CHKERRQ(ierr);\n    for (PetscInt r = 0; r < num_resources; r++) {\n      ierr = RunWithDM(rp, dm_deg, ceed_resources[r]); CHKERRQ(ierr);\n    }\n    ierr = DMDestroy(&dm_deg); CHKERRQ(ierr);\n    rp->q_extra = q_extra;\n  }\n\n  ierr = DMDestroy(&dm); CHKERRQ(ierr);\n  PetscFunctionReturn(0);\n}\n\nint main(int argc, char **argv) {\n  PetscInt ierr, comm_size;\n  RunParams rp;\n  MPI_Comm comm;\n  char filename[PETSC_MAX_PATH_LEN];\n  char *ceed_resources[30];\n  PetscInt num_ceed_resources = 30;\n  char hostname[PETSC_MAX_PATH_LEN];\n\n  PetscInt dim = 3, mesh_elem[3] = {3, 3, 3};\n  PetscInt num_degrees = 30, degree[30] = {}, num_local_nodes = 2,\n                                          local_nodes[2] = {};\n  PetscMPIInt ranks_per_node;\n  PetscBool degree_set;\n  BPType bp_choices[10];\n  PetscInt num_bp_choices = 10;\n\n  // Initialize PETSc\n  ierr = PetscInitialize(&argc, &argv, NULL, help);\n  if (ierr) return ierr;\n  comm = PETSC_COMM_WORLD;\n  ierr = MPI_Comm_size(comm, &comm_size);\n  if (ierr != MPI_SUCCESS) return ierr;\n  #if defined(PETSC_HAVE_MPI_PROCESS_SHARED_MEMORY)\n  {\n    MPI_Comm splitcomm;\n    ierr = MPI_Comm_split_type(comm, MPI_COMM_TYPE_SHARED, 0, MPI_INFO_NULL,\n                               &splitcomm);\n    CHKERRQ(ierr);\n    ierr = MPI_Comm_size(splitcomm, &ranks_per_node); CHKERRQ(ierr);\n    ierr = MPI_Comm_free(&splitcomm); CHKERRQ(ierr);\n  }\n  #else\n  ranks_per_node = -1; // Unknown\n  #endif\n\n  // Setup all parameters needed in Run()\n  ierr = PetscMalloc1(1, &rp); CHKERRQ(ierr);\n  rp->comm = comm;\n\n  // Read command line options\n  ierr = PetscOptionsBegin(comm, NULL, \"CEED BPs in PETSc\", NULL);\n  CHKERRQ(ierr);\n  {\n    PetscBool set;\n    ierr = PetscOptionsEnumArray(\"-problem\", \"CEED benchmark problem to solve\",\n                                 NULL,\n                                 bp_types, (PetscEnum *)bp_choices, &num_bp_choices, &set);\n    CHKERRQ(ierr);\n    if (!set) {\n      bp_choices[0] = CEED_BP1;\n      num_bp_choices = 1;\n    }\n  }\n  rp->test_mode = PETSC_FALSE;\n  ierr = PetscOptionsBool(\"-test\",\n                          \"Testing mode (do not print unless error is large)\",\n                          NULL, rp->test_mode, &rp->test_mode, NULL); CHKERRQ(ierr);\n  rp->write_solution = PETSC_FALSE;\n  ierr = PetscOptionsBool(\"-write_solution\", \"Write solution for visualization\",\n                          NULL, rp->write_solution, &rp->write_solution, NULL);\n  CHKERRQ(ierr);\n  degree[0] = rp->test_mode ? 3 : 2;\n  ierr = PetscOptionsIntArray(\"-degree\",\n                              \"Polynomial degree of tensor product basis\", NULL,\n                              degree, &num_degrees, &degree_set); CHKERRQ(ierr);\n  if (!degree_set)\n    num_degrees = 1;\n  rp->q_extra = PETSC_DECIDE;\n  ierr = PetscOptionsInt(\"-q_extra\",\n                         \"Number of extra quadrature points (-1 for auto)\", NULL,\n                         rp->q_extra, &rp->q_extra, NULL); CHKERRQ(ierr);\n  {\n    PetscBool set;\n    ierr = PetscOptionsStringArray(\"-ceed\",\n                                   \"CEED resource specifier (comma-separated list)\", NULL,\n                                   ceed_resources, &num_ceed_resources, &set); CHKERRQ(ierr);\n    if (!set) {\n      ierr = PetscStrallocpy( \"/cpu/self\", &ceed_resources[0]); CHKERRQ(ierr);\n      num_ceed_resources = 1;\n    }\n  }\n  ierr = PetscGetHostName(hostname, sizeof hostname); CHKERRQ(ierr);\n  ierr = PetscOptionsString(\"-hostname\", \"Hostname for output\", NULL, hostname,\n                            hostname, sizeof(hostname), NULL); CHKERRQ(ierr);\n  rp->read_mesh = PETSC_FALSE;\n  ierr = PetscOptionsString(\"-mesh\", \"Read mesh from file\", NULL, filename,\n                            filename, sizeof(filename), &rp->read_mesh);\n  CHKERRQ(ierr);\n  rp->filename = filename;\n  if (!rp->read_mesh) {\n    PetscInt tmp = dim;\n    ierr = PetscOptionsIntArray(\"-cells\", \"Number of cells per dimension\", NULL,\n                                mesh_elem, &tmp, NULL); CHKERRQ(ierr);\n  }\n  local_nodes[0] = 1000;\n  ierr = PetscOptionsIntArray(\"-local_nodes\",\n                              \"Target number of locally owned nodes per \"\n                              \"process (single value or min,max)\",\n                              NULL, local_nodes, &num_local_nodes, &rp->user_l_nodes);\n  CHKERRQ(ierr);\n  if (num_local_nodes < 2)\n    local_nodes[1] = 2 * local_nodes[0];\n  {\n    PetscInt two = 2;\n    rp->ksp_max_it_clip[0] = 5;\n    rp->ksp_max_it_clip[1] = 20;\n    ierr = PetscOptionsIntArray(\"-ksp_max_it_clip\",\n                                \"Min and max number of iterations to use during benchmarking\",\n                                NULL, rp->ksp_max_it_clip, &two, NULL); CHKERRQ(ierr);\n  }\n  if (!degree_set) {\n    PetscInt max_degree = 8;\n    ierr = PetscOptionsInt(\"-max_degree\",\n                           \"Range of degrees [1, max_degree] to run with\",\n                           NULL, max_degree, &max_degree, NULL);\n    CHKERRQ(ierr);\n    for (PetscInt i = 0; i < max_degree; i++)\n      degree[i] = i + 1;\n    num_degrees = max_degree;\n  }\n  {\n    PetscBool flg;\n    PetscInt p = ranks_per_node;\n    ierr = PetscOptionsInt(\"-p\", \"Number of MPI ranks per node\", NULL,\n                           p, &p, &flg);\n    CHKERRQ(ierr);\n    if (flg) ranks_per_node = p;\n  }\n\n  ierr = PetscOptionsEnd();\n  CHKERRQ(ierr);\n\n  // Register PETSc logging stage\n  ierr = PetscLogStageRegister(\"Solve Stage\", &rp->solve_stage);\n  CHKERRQ(ierr);\n\n  rp->hostname = hostname;\n  rp->dim = dim;\n  rp->mesh_elem = mesh_elem;\n  rp->ranks_per_node = ranks_per_node;\n\n  for (PetscInt d = 0; d < num_degrees; d++) {\n    PetscInt deg = degree[d];\n    for (PetscInt n = local_nodes[0]; n < local_nodes[1]; n *= 2) {\n      rp->degree = deg;\n      rp->local_nodes = n;\n      ierr = Run(rp, num_ceed_resources, ceed_resources,\n                 num_bp_choices, bp_choices); CHKERRQ(ierr);\n    }\n  }\n  // Clear memory\n  ierr = PetscFree(rp); CHKERRQ(ierr);\n  for (PetscInt i=0; i<num_ceed_resources; i++) {\n    ierr = PetscFree(ceed_resources[i]); CHKERRQ(ierr);\n  }\n  return PetscFinalize();\n}\n", "meta": {"hexsha": "ed7ecd797d4ac1cf574915e74d4dbb4d25ce9748", "size": 23369, "ext": "c", "lang": "C", "max_stars_repo_path": "examples/petsc/bps.c", "max_stars_repo_name": "AdelekeBankole/libCEED", "max_stars_repo_head_hexsha": "aae8ce39fa1e28b745979a9cbffc67a790eb3f5e", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 123.0, "max_stars_repo_stars_event_min_datetime": "2018-01-29T02:04:05.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-21T18:13:48.000Z", "max_issues_repo_path": "examples/petsc/bps.c", "max_issues_repo_name": "AdelekeBankole/libCEED", "max_issues_repo_head_hexsha": "aae8ce39fa1e28b745979a9cbffc67a790eb3f5e", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 781.0, "max_issues_repo_issues_event_min_datetime": "2017-12-22T17:20:35.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-29T21:34:34.000Z", "max_forks_repo_path": "examples/petsc/bps.c", "max_forks_repo_name": "AdelekeBankole/libCEED", "max_forks_repo_head_hexsha": "aae8ce39fa1e28b745979a9cbffc67a790eb3f5e", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 41.0, "max_forks_repo_forks_event_min_datetime": "2017-12-27T22:35:13.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-01T13:02:07.000Z", "avg_line_length": 38.3727422003, "max_line_length": 98, "alphanum_fraction": 0.5986563396, "num_tokens": 6299, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.49609382947091957, "lm_q2_score": 0.06954175173725284, "lm_q1q2_score": 0.03449923392744973}}
{"text": "/*\n Copyright (C) 2002 M. Marques, A. Castro, A. Rubio, G. Bertsch, D. Strubbe\n\n This program is free software; you can redistribute it and/or modify\n it under the terms of the GNU General Public License as published by\n the Free Software Foundation; either version 2, or (at your option)\n any later version.\n\n This program is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n GNU General Public License for more details.\n\n You should have received a copy of the GNU General Public License\n along with this program; if not, write to the Free Software\n Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA\n 02110-1301, USA.\n\n*/\n\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <strings.h>\n#include <ctype.h>\n#include <math.h>\n#include <gsl/gsl_complex_math.h>\n\n#include \"symbols.h\"\n#include \"gsl_userdef.h\"\n\n/* The symbol table: a chain of `struct symrec'.  */\nsymrec *sym_table = (symrec *)0;\n\nvoid str_tolower(char *in)\n{\n  for(; *in; in++)\n    *in = (char)tolower(*in);\n}\n\nvoid sym_mark_table_used ()\n{\n  symrec *ptr;\n\n  for (ptr = sym_table; ptr != (symrec *) 0;\n       ptr = (symrec *)ptr->next)\n  {\n    ptr->used = 1;\n  }\n}\n\nsymrec *putsym (const char *sym_name, symrec_type sym_type)  \n{\n  symrec *ptr;\n  ptr = (symrec *)malloc(sizeof(symrec));\n\n  /* names are always lowercase */\n  ptr->name = strdup(sym_name);\n  str_tolower(ptr->name);\n  \n  ptr->def  = 0;\n  ptr->used = 0;\n  ptr->type = sym_type;\n  GSL_SET_COMPLEX(&ptr->value.c, 0, 0); /* set value to 0 even if fctn.  */\n  ptr->next = (struct symrec *)sym_table;\n  sym_table = ptr;\n  return ptr;\n}\n\nsymrec *getsym (const char *sym_name)\n{\n  symrec *ptr;\n  for (ptr = sym_table; ptr != (symrec *) 0;\n       ptr = (symrec *)ptr->next)\n    if (strcasecmp(ptr->name,sym_name) == 0){\n      ptr->used = 1;\n      return ptr;\n    }\n  return (symrec *) 0;\n}\n\nint rmsym (const char *sym_name)\n{\n  symrec *ptr, *prev;\n  for (prev = (symrec *) 0, ptr = sym_table; ptr != (symrec *) 0;\n       prev = ptr, ptr = ptr->next)\n    if (strcasecmp(ptr->name,sym_name) == 0){\n      if(prev == (symrec *) 0)\n\tsym_table = ptr->next;\n      else\n\tprev->next = ptr->next;\n      free(ptr->name);\n      free(ptr);\n      \n      return 1;\n    }\n  \n  return 0;\n}\n\nstruct init_fntc{\n  char *fname;\n  int  nargs;\n  gsl_complex (*fnctptr)();\n};\n\nvoid sym_notdef (symrec *sym)\n{\n  fprintf(stderr, \"Parser error: symbol '%s' used before being defined.\\n\", sym->name);\n  exit(1);\n}\n\nvoid sym_redef (symrec *sym)\n{\n  fprintf(stderr, \"Parser warning: redefining symbol, previous value \");\n  sym_print(stderr, sym);\n  fprintf(stderr, \"\\n\");\n}\n\nvoid sym_wrong_arg (symrec *sym)\n{\n  if(sym->type == S_BLOCK) {\n    fprintf(stderr, \"Parser error: block name '%s' used in variable context.\\n\", sym->name);\n  } else if(sym->type == S_STR) {\n    fprintf(stderr, \"Parser error: string variable '%s' used in expression context.\\n\", sym->name);\n  } else {\n    fprintf(stderr, \"Parser error: function '%s' requires %d argument(s).\\n\", sym->name, sym->nargs);\n  }\n  exit(1);\n}\n\nstatic struct init_fntc arith_fncts[] = {\n  {\"sqrt\",   1, (gsl_complex (*)()) &gsl_complex_sqrt},\n  {\"exp\",    1, (gsl_complex (*)()) &gsl_complex_exp},\n  {\"ln\",     1, (gsl_complex (*)()) &gsl_complex_log},\n  {\"log\",    1, (gsl_complex (*)()) &gsl_complex_log},\n  {\"log10\",  1, (gsl_complex (*)()) &gsl_complex_log10},\n  {\"logb\",   2, (gsl_complex (*)()) &gsl_complex_log_b}, /* takes two arguments logb(z, b) = log_b(z) */\n\n  {\"arg\",    1, (gsl_complex (*)()) &gsl_complex_carg},\n  {\"abs\",    1, (gsl_complex (*)()) &gsl_complex_cabs},\n  {\"abs2\",   1, (gsl_complex (*)()) &gsl_complex_cabs2},\n  {\"logabs\", 1, (gsl_complex (*)()) &gsl_complex_clogabs},\n\n  {\"conjg\",  1, (gsl_complex (*)()) &gsl_complex_conjugate},\n  {\"inv\",    1, (gsl_complex (*)()) &gsl_complex_inverse},\n\n  {\"sin\",    1, (gsl_complex (*)()) &gsl_complex_sin},\n  {\"cos\",    1, (gsl_complex (*)()) &gsl_complex_cos},\n  {\"tan\",    1, (gsl_complex (*)()) &gsl_complex_tan},\n  {\"sec\",    1, (gsl_complex (*)()) &gsl_complex_sec},\n  {\"csc\",    1, (gsl_complex (*)()) &gsl_complex_csc},\n  {\"cot\",    1, (gsl_complex (*)()) &gsl_complex_cot},\n\n  {\"asin\",   1, (gsl_complex (*)()) &gsl_complex_arcsin},\n  {\"acos\",   1, (gsl_complex (*)()) &gsl_complex_arccos},\n  {\"atan\",   1, (gsl_complex (*)()) &gsl_complex_arctan},\n  {\"atan2\",  2, (gsl_complex (*)()) &gsl_complex_arctan2}, /* takes two arguments atan2(y,x) = atan(y/x) */\n  {\"asec\",   1, (gsl_complex (*)()) &gsl_complex_arcsec},\n  {\"acsc\",   1, (gsl_complex (*)()) &gsl_complex_arccsc},\n  {\"acot\",   1, (gsl_complex (*)()) &gsl_complex_arccot},\n\n  {\"sinh\",   1, (gsl_complex (*)()) &gsl_complex_sinh},\n  {\"cosh\",   1, (gsl_complex (*)()) &gsl_complex_cosh},\n  {\"tanh\",   1, (gsl_complex (*)()) &gsl_complex_tanh},\n  {\"sech\",   1, (gsl_complex (*)()) &gsl_complex_sech},\n  {\"csch\",   1, (gsl_complex (*)()) &gsl_complex_csch},\n  {\"coth\",   1, (gsl_complex (*)()) &gsl_complex_coth},\n\n  {\"asinh\",  1, (gsl_complex (*)()) &gsl_complex_arcsinh},\n  {\"acosh\",  1, (gsl_complex (*)()) &gsl_complex_arccosh},\n  {\"atanh\",  1, (gsl_complex (*)()) &gsl_complex_arctanh},\n  {\"asech\",  1, (gsl_complex (*)()) &gsl_complex_arcsech},\n  {\"acsch\",  1, (gsl_complex (*)()) &gsl_complex_arccsch},\n  {\"acoth\",  1, (gsl_complex (*)()) &gsl_complex_arccoth},\t\n \n/* user-defined step function. this is not available in GSL, \n   but we use GSL namespacing and macros here. */\n  {\"step\",   1, (gsl_complex (*)()) &gsl_complex_step_real},\n\n/* Minimum and maximum of two arguments (comparing real parts) */  \n  {\"min\",    2, (gsl_complex (*)()) &gsl_complex_min_real},\n  {\"max\",    2, (gsl_complex (*)()) &gsl_complex_max_real},\n\n  {\"erf\",    1, (gsl_complex (*)()) &gsl_complex_erf},\n\n  {\"realpart\", 1, (gsl_complex (*)()) &gsl_complex_realpart},\n  {\"imagpart\", 1, (gsl_complex (*)()) &gsl_complex_imagpart},\n  {\"round\",   1, (gsl_complex (*)()) &gsl_complex_round},\n  {\"floor\",   1, (gsl_complex (*)()) &gsl_complex_floor},\n  {\"ceiling\", 1, (gsl_complex (*)()) &gsl_complex_ceiling},\n\n  {\"rand\",    0, (gsl_complex (*)()) &gsl_complex_rand},\n\n  {0, 0, 0}\n};\n\nstruct init_cnst{\n\tchar *fname;\n\tdouble re;\n\tdouble im;\n};\n\nstatic struct init_cnst arith_cnts[] = {\n\t{\"pi\",    M_PI, 0}, \n\t{\"e\",      M_E, 0},\n\t{\"i\",        0, 1},\n\t{\"true\",     1, 0}, \n\t{\"yes\",      1, 0},\n\t{\"false\",    0, 0}, \n\t{\"no\",       0, 0},\n\t{0,          0, 0}\n};\n\nchar *reserved_symbols[] = {\n  \"x\", \"y\", \"z\", \"r\", \"w\", \"t\", 0\n};\n\nvoid sym_init_table ()  /* puts arithmetic functions in table. */\n{\n  int i;\n  symrec *ptr;\n  for (i = 0; arith_fncts[i].fname != 0; i++){\n    ptr = putsym (arith_fncts[i].fname, S_FNCT);\n    ptr->def = 1;\n    ptr->used = 1;\n    ptr->nargs = arith_fncts[i].nargs;\n    ptr->value.fnctptr = arith_fncts[i].fnctptr;\n  }\n\n  /* now the constants */\n  for (i = 0; arith_cnts[i].fname != 0; i++){\n    ptr = putsym(arith_cnts[i].fname, S_CMPLX);\n    ptr->def = 1;\n    ptr->used = 1;\n    GSL_SET_COMPLEX(&ptr->value.c, arith_cnts[i].re, arith_cnts[i].im);\n  }\n}\n\nvoid sym_end_table()\n{\n  symrec *ptr, *ptr2;\n\n  for (ptr = sym_table; ptr != NULL;){\n    free(ptr->name);\n    switch(ptr->type){\n    case S_STR:\n      free(ptr->value.str);\n      break;\n    case S_BLOCK:\n      if(ptr->value.block->n > 0){\n\tfree(ptr->value.block->lines);\n      }\n      free(ptr->value.block);\n      break;\n    case S_CMPLX:\n    case S_FNCT:\n      break;\n    }\n    ptr2 = ptr->next;\n    free(ptr);\n    ptr = ptr2;\n  }\n  \n  sym_table = NULL;\n}\n\n/* this function is defined in src/basic/varinfo_low.c */\nint varinfo_variable_exists(const char * var_name);\n\nvoid sym_output_table(int only_unused, int mpiv_node)\n{\n  FILE *f;\n  symrec *ptr;\n  int any_unused = 0;\n\n  if(mpiv_node != 0) {\n    return;\n  }\n  \n  if(only_unused) {\n    f = stderr;\n  } else {\n    f = stdout;\n  }\n  \n  for(ptr = sym_table; ptr != NULL; ptr = ptr->next){\n    if(only_unused && ptr->used == 1) continue;\n    if(only_unused && varinfo_variable_exists(ptr->name)) continue;\n    if(any_unused == 0) {\n      fprintf(f, \"\\nParser warning: possible mistakes in input file.\\n\");\n      fprintf(f, \"List of variable assignments not used by parser:\\n\");\n      any_unused = 1;\n    }\n\n    sym_print(f, ptr);\n  }\n  if(any_unused == 1) {\n    fprintf(f, \"\\n\");\n  }\n}\n\nvoid sym_print(FILE *f, const symrec *ptr)\n{\n  fprintf(f, \"%s\", ptr->name);\n  switch(ptr->type){\n  case S_CMPLX:\n    if(fabs(GSL_IMAG(ptr->value.c)) < 1.0e-14){\n      fprintf(f, \" = %f\\n\", GSL_REAL(ptr->value.c));\n    } else {\n      fprintf(f, \" = (%f,%f)\\n\", GSL_REAL(ptr->value.c), GSL_IMAG(ptr->value.c));\n    }\n    break;\n  case S_STR:\n    fprintf(f, \" = \\\"%s\\\"\\n\", ptr->value.str);\n    break;\n  case S_BLOCK:\n    fprintf(f, \"%s\\n\", \" <= BLOCK\");\n    break;\n  case S_FNCT:\n    fprintf(f, \"%s\\n\", \" <= FUNCTION\");\n    break;\n  }\n}\n", "meta": {"hexsha": "12d95987f26290c4f1860e03cd305fc8c96eea31", "size": 8862, "ext": "c", "lang": "C", "max_stars_repo_path": "liboct_parser/symbols.c", "max_stars_repo_name": "shunsuke-sato/octopus", "max_stars_repo_head_hexsha": "dcf68a185cdb13708395546b1557ca46aed969f6", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2016-11-17T09:03:11.000Z", "max_stars_repo_stars_event_max_datetime": "2019-10-17T06:31:08.000Z", "max_issues_repo_path": "liboct_parser/symbols.c", "max_issues_repo_name": "shunsuke-sato/octopus", "max_issues_repo_head_hexsha": "dcf68a185cdb13708395546b1557ca46aed969f6", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2020-08-11T19:14:06.000Z", "max_issues_repo_issues_event_max_datetime": "2020-08-11T19:14:06.000Z", "max_forks_repo_path": "liboct_parser/symbols.c", "max_forks_repo_name": "shunsuke-sato/octopus", "max_forks_repo_head_hexsha": "dcf68a185cdb13708395546b1557ca46aed969f6", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 5.0, "max_forks_repo_forks_event_min_datetime": "2016-11-22T20:30:46.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-29T23:24:51.000Z", "avg_line_length": 27.2676923077, "max_line_length": 107, "alphanum_fraction": 0.5971563981, "num_tokens": 2937, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.5, "lm_q2_score": 0.06853749065376102, "lm_q1q2_score": 0.03426874532688051}}
{"text": "\\documentclass{report}\n\\usepackage[T1]{fontenc}\n\\usepackage{bera}\n\n\\usepackage[pdftex,usenames,dvipsnames]{color}\n\\usepackage{listings}\n\\definecolor{mycode}{rgb}{0.9,0.9,1}\n\\lstset{language=c++,tabsize=1,basicstyle=\\scriptsize,backgroundcolor=\\color{mycode}}\n\n\\usepackage{hyperref}\n\\usepackage{fancyhdr}\n\\pagestyle{fancy}\n\\usepackage{verbatim}\n\\begin{document}\n\n%\\title{The Powell Class for Minimization of Functions}\n%\\author{G.A.}\n%\\maketitle\n\n\\begin{comment}\n@o Minimizer.h -t\n@{\n/*\n@i license.txt\n*/\n@}\n\\end{comment}\n\n\\section{A class to minimize a function without using Derivatives}\nThis requires the GNU Scientific Library, libraries and devel. headers.\n\nExplain usage here. FIXME.\n\nThis is the structure of this file:\n\n@o Minimizer.h -t\n@{\n#ifndef MINIMIZER_H\n#define MINIMIZER_H\n\n#include <iostream>\n#include <vector>\n#include <stdexcept>\nextern \"C\" {\n#include <gsl/gsl_multimin.h>\n}\n\nnamespace PsimagLite {\n\t@<MockVector@>\n\t@<MyFunction@>\n\t@<theClassHere@>\n} // namespace PsimagLite\n#endif // MINIMIZER_H\n\n@}\n\nAnd this is the class here:\n\n@d theClassHere\n@{\ntemplate<typename RealType,typename FunctionType>\nclass Minimizer {\n\t@<privateTypedefsAndConstants@>\npublic:\n\t@<constructor@>\n\t@<destructor@>\n\t@<publicFunctions@>\nprivate:\n\t@<privateFunctions@>\n\t@<privateData@>\n}; // class Minimizer\n@}\n\n\n@d privateTypedefsAndConstants\n@{\ntypedef typename FunctionType::FieldType FieldType;\ntypedef typename Vector<FieldType>::Type VectorType;\ntypedef Minimizer<RealType,FunctionType> ThisType;\n\n@}\n\n@d privateData\n@{\nFunctionType& function_;\nSizeType maxIter_;\nconst gsl_multimin_fminimizer_type *gslT_;\ngsl_multimin_fminimizer *gslS_;\n@}\n\n@d constructor\n@{\nMinimizer(FunctionType& function,SizeType maxIter)\n\t\t: function_(function),\n\t\t  maxIter_(maxIter),\n\t\t  gslT_(gsl_multimin_fminimizer_nmsimplex2),\n\t\t  gslS_(gsl_multimin_fminimizer_alloc(gslT_,function_.size()))\n{\n}\n@}\n\n@d publicFunctions\n@{\n@<simplex@>\n@}\n\n@d destructor\n@{\n~Minimizer()\n{\n\tgsl_multimin_fminimizer_free (gslS_);\n}\n@}\n\n\n@d simplex\n@{\nint simplex(VectorType& minVector,RealType delta=1e-3,RealType tolerance=1e-3)\n{\n\tgsl_vector *x;\n\t/* Starting point,  */\n\tx = gsl_vector_alloc (function_.size());\n\tfor (SizeType i=0;i<minVector.size();i++)\n\t\tgsl_vector_set (x, i, minVector[i]);\n\n\tgsl_vector *xs;\n\txs = gsl_vector_alloc (function_.size());\n\tfor (SizeType i=0;i<minVector.size();i++)\n\t\tgsl_vector_set (xs, i, delta);\n\n\tgsl_multimin_function func;\n\tfunc.f= myFunction<FunctionType>;\n\tfunc.n = function_.size();\n\tfunc.params = &function_;\n\tgsl_multimin_fminimizer_set (gslS_, &func, x, xs);\n\n\tfor (SizeType iter=0;iter<maxIter_;iter++) {\n\t\tint status = gsl_multimin_fminimizer_iterate (gslS_);\n\n\t\tif (status) throw RuntimeError(\"Minimizer::simplex(...): Error encountered\\n\");\n\n\t\tRealType size = gsl_multimin_fminimizer_size(gslS_);\n\t\tstatus = gsl_multimin_test_size(size, tolerance);\n\n\t\tif (status == GSL_SUCCESS) {\n\t\t\tfound(minVector,gslS_->x,iter);\n\t\t\tgsl_vector_free (x);\n\t\t\tgsl_vector_free (xs);\n\t\t\treturn iter;\n\t\t}\n\t}\n\tgsl_vector_free (x);\n\tgsl_vector_free (xs);\n\treturn -1;\n}\n@}\n\n@d privateFunctions\n@{\n@<found@>\n@}\n\n@d found\n@{\nvoid found(VectorType& minVector,gsl_vector* x,SizeType iter)\n{\n\tfor (SizeType i=0;i<minVector.size();i++)\n\t\tminVector[i] = gsl_vector_get(x,i);\n}\n@}\n\n@d MockVector\n@{\ntemplate<typename FieldType>\nclass MockVector {\npublic:\n\tMockVector(const gsl_vector *v) : v_(v)\n\t{\n\t}\n\tconst FieldType& operator[](SizeType i) const\n\t{\n\t\treturn v_->data[i];\n\t}\n\tSizeType size() const { return v_->size; }\nprivate:\n\tconst gsl_vector *v_;\n}; // class MockVector\n@}\n\n@d MyFunction\n@{\ntemplate<typename FunctionType>\ntypename FunctionType::FieldType myFunction(const gsl_vector *v, void *params)\n{\n\tMockVector<typename FunctionType::FieldType> mv(v);\n\tFunctionType* ft = (FunctionType *)params;\n\treturn ft->operator()(mv);\n}\n@}\n\n\\end{document}\n\n", "meta": {"hexsha": "0a18f2b0f305ccb7346011801c4693be7b9f96ab", "size": 3834, "ext": "w", "lang": "C", "max_stars_repo_path": "src/Minimizer.w", "max_stars_repo_name": "g1257/PsimagLite", "max_stars_repo_head_hexsha": "1cdeb4530c66cd41bd0c59af9ad2ecb1069ca010", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 8.0, "max_stars_repo_stars_event_min_datetime": "2015-08-19T16:06:52.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-05T02:37:47.000Z", "max_issues_repo_path": "src/Minimizer.w", "max_issues_repo_name": "npatel37/PsimagLiteORNL", "max_issues_repo_head_hexsha": "ffa0ffad75c5db218a9edea1a9581fed98c2648f", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": 5.0, "max_issues_repo_issues_event_min_datetime": "2016-02-02T20:28:21.000Z", "max_issues_repo_issues_event_max_datetime": "2019-07-08T22:56:12.000Z", "max_forks_repo_path": "src/Minimizer.w", "max_forks_repo_name": "npatel37/PsimagLiteORNL", "max_forks_repo_head_hexsha": "ffa0ffad75c5db218a9edea1a9581fed98c2648f", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": 5.0, "max_forks_repo_forks_event_min_datetime": "2016-04-29T17:28:00.000Z", "max_forks_repo_forks_event_max_datetime": "2019-11-22T03:33:19.000Z", "avg_line_length": 18.8866995074, "max_line_length": 85, "alphanum_fraction": 0.7282211789, "num_tokens": 1136, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4532618480153861, "lm_q2_score": 0.07477005115479887, "lm_q1q2_score": 0.03389041156262909}}
{"text": "/* $Id$ */\n/*--------------------------------------------------------------------*/\n/*;  Copyright (C) 2008                                               */\n/*;  Associated Universities, Inc. Washington DC, USA.                */\n/*;                                                                   */\n/*;  This program is free software; you can redistribute it and/or    */\n/*;  modify it under the terms of the GNU General Public License as   */\n/*;  published by the Free Software Foundation; either version 2 of   */\n/*;  the License, or (at your option) any later version.              */\n/*;                                                                   */\n/*;  This program is distributed in the hope that it will be useful,  */\n/*;  but WITHOUT ANY WARRANTY; without even the implied warranty of   */\n/*;  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    */\n/*;  GNU General Public License for more details.                     */\n/*;                                                                   */\n/*;  You should have received a copy of the GNU General Public        */\n/*;  License along with this program; if not, write to the Free       */\n/*;  Software Foundation, Inc., 675 Massachusetts Ave, Cambridge,     */\n/*;  MA 02139, USA.                                                   */\n/*;                                                                   */\n/*; Correspondence about this software should be addressed as follows:*/\n/*;         Internet email: bcotton@nrao.edu.                         */\n/*;         Postal address: William Cotton                            */\n/*;                         National Radio Astronomy Observatory      */\n/*;                         520 Edgemont Road                         */\n/*;                         Charlottesville, VA 22903-2475 USA        */\n/*--------------------------------------------------------------------*/\n\n#include \"ObitUtil.h\"\n#include <gsl/gsl_multifit.h>\n\n/*----------------Obit: Merx mollis mortibus nuper ------------------*/\n/**\n * \\file ObitUtil.c\n * ObitUtil utility function definitions.\n *\n */\n\n\n/*----------------------Private functions---------------------------*/\n/** Private: qsort ofloat comparison */\nstatic int compare_gfloat  (const void* arg1,  const void* arg2);\n\n\n/*----------------------Public functions---------------------------*/\n/**\n * Get mean values of an array.\n * \\param array array of values may be magic value blanked\n * \\param n     dimension of array\n * \\return      Mean value, possibly blanked\n */\nofloat meanValue (ofloat *array, olong incs, olong n)\n{\n  olong i, count;\n  ofloat sum, fblank =ObitMagicF() ;\n\n  if (n<=0) return fblank;\n  sum = 0.0;\n  count = 0;\n    for (i=0; i<n; i++) {\n      if (array[i*incs]!=fblank) { \n\tsum += array[i*incs];\n\tcount++;\n      }\n    }\n    if (count>0) sum /= count;\n    else sum = fblank;\n\n  return sum;\n} /* end meanValue */\n\n/**\n * Get median value of an array.\n * Does sort then returns value array[ngood/2]\n * \\param array   array of values, on return will be in ascending order\n * \\param n       dimension of array\n * \\param inc     stride in array\n * \\return        Median value, possibly blanked\n */\nofloat medianValue (ofloat *array, olong incs, olong n)\n{\n  olong i, ngood;\n  ofloat out, fblank = ObitMagicF();\n  gboolean blanked;\n\n  if (n<=0) return fblank;\n\n  /* Count good (non blank) points */\n  ngood = 0;\n  for (i=0; i<n; i++) if (array[i*incs]!=fblank) ngood++;\n  if (ngood<1) return fblank;  /* Any good data? */\n  blanked = ngood<n;   /* Anything blanked? */\n\n  /* set blanked values to 2.0e20 for sort */\n  for (i=0; i<n; i++) if (array[i*incs]==fblank) array[i*incs] = 2.0e20;\n\n  /* Sort to ascending order */\n  qsort ((void*)array, n, MAX(1,incs)*sizeof(ofloat), compare_gfloat);\n\n  /* Set median */\n  out = array[(ngood/2)*incs];\n\n  /* reset blanked values */\n  if (blanked) {\n    for (i=0; i<n; i++) if (array[i*incs]>1.0e20) array[i*incs] = fblank;\n  }\n\n  return out;\n} /* end medianValue */\n\n/**\n * Return average of navg values around median (with magic value blanking)\n * Does sort then returns average of center of array\n * If there are fewer than navg valid data then the median is returned.\n * \\param array array of values, on return will be in ascending order\n * \\param incs  increment in data array, >1 => weights\n * \\param navg  width of averaging about median\n * \\param doWt  If True value after data is a weight\n * \\param n     dimension of array\n * \\return      Median/average, possibly blanked\n */\nofloat medianAvg (ofloat *array, olong incs, olong navg, gboolean doWt, olong n)\n{\n  olong i, cnt, wid, ngood, ind, hi, lo;\n  ofloat temp, wt, out=0.0, fblank = ObitMagicF();\n  ofloat center;\n  gboolean blanked;\n\n  if (n<=0) return fblank;\n\n  /* Count good (non blank) points */\n  ngood = 0;\n  for (i=0; i<n; i++) if (array[i*incs]!=fblank) ngood++;\n  if (ngood<1) return fblank;  /* Any good data? */\n  blanked = ngood<n;   /* Anything blanked? */\n\n  /* set blanked values to 2.0e20 for sort */\n  for (i=0; i<n; i++) if (array[i*incs]==fblank) array[i*incs] = 2.0e20;\n\n  /* Sort to ascending order */\n  qsort ((void*)array, n, MAX(1,incs)*sizeof(ofloat), compare_gfloat);\n\n  /* How many good values? */\n  cnt = 0;\n  for (i=0; i<n; i++) if (array[i*incs]<1.0e20) cnt++;\n  wid = MIN (MAX (1, navg/2), ngood/2);  /* width of averaging */\n  ngood = cnt;\n\n  ind = (ngood-1)/2;  /* center good value */\n  out = array[ind*incs];\n\n  /* average central values */\n  if (ngood>navg) {\n    center = (ngood-1)/2.0;\n    lo = MAX (1, (olong)(center - wid + 0.6));\n    hi = MIN (ngood, (olong)(center + wid));\n    /* Weighted? */\n    if (doWt) {\n      temp = 0.0; wt = 0.0;\n      for (i=lo; i<=hi; i++) {\n\tif (array[i*incs]<1.0e20) {\n\t  wt += array[i*incs+1];\n\t  temp += array[i*incs]*array[i*incs+1];\n\t}\n      }\n      if (wt>0.0) out = temp/wt;\n    } else { /* unweighted */\n      temp = 0.0; cnt = 0;\n      for (i=lo; i<=hi; i++) {\n\tif (array[i]<1.0e20) {\n\t  cnt++;\n\t  temp += array[i];\n\t}\n\tif (cnt>0) out = temp/cnt;\n      }\n    } /* end if weighting */\n  }\n\n  /* reset blanked values */\n  if (blanked) {\n    for (i=0; i<n; i++) if (array[i*incs]>1.0e20) array[i*incs] = fblank;\n  }\n\n  return out;\n} /* end medianAvg */\n\n/**\n * Return the running median of an array\n * \\param n       Number of points\n * \\param wind    Width of median window in cells\n * \\param array   Array of values, fblank blanking supported\n * \\param alpha   0 -> 1 = pure boxcar -> pure MWF (Alpha of the \n *                data samples in a window are discarded and \n *                the rest averaged). \n * \\param rms     RMS of array, median average sigma from each wind of data\n * \\param out     array of size of array to be with median values\n * \\param work    work array of size of array\n */\nvoid RunningMedian (olong n, olong wind, ofloat *array, ofloat alpha, \n\t\t    ofloat *RMS, ofloat *out, ofloat *work)\n{\n  ofloat *lwork=NULL;\n  ofloat level, sigma, sigmaSum, sigmaCnt;\n  ofloat fblank = ObitMagicF();\n  olong i, j, k, op, ind, half, RMScnt=0;\n\n  /* Create array */\n  lwork = g_malloc0(wind*sizeof(ofloat));\n\n  half = wind/2;\n  ind  = 0;\n  op   = 0;\n  k    = 0;\n  sigmaSum = 0.0;\n  sigmaCnt = 1;\n\n  /* First half wind filled with median of first wind points */\n  for (j=ind; j<ind+wind; j++) lwork[k++] = array[j];\n  ind++;\n  level = MedianLevel (wind, lwork, alpha);\n  sigma = MedianSigma (wind, lwork, level);\n  if (sigma!=fblank) {\n    sigmaSum = sigma;\n    sigmaSum += sigma;\n    work[RMScnt++] = sigma;\n  }\n  for (k=0; k<half; k++) out[op++] = level;\n\n  /* Loop over middle of array */\n  for (i=half; i<n-half; i++) {\n    k = 0;\n    for (j=ind; j<ind+wind; j++) lwork[k++] = array[j];\n    ind++;\n    level = MedianLevel (wind, lwork, alpha);\n    sigma = MedianSigma (wind, lwork, level);\n    if (sigma!=fblank) {\n      sigmaSum += sigma;\n      sigmaCnt++;\n      work[RMScnt++] = sigma;\n    }\n    out[op++] = level;\n  } /* end loop over array */\n\n  /* Fill in bit at end */\n  while (op<n) {\n    out[op++] = level;\n  }\n\n  /* median Average sigmas */\n  *RMS = MedianLevel (RMScnt, work, alpha);\n\n  /* Cleanup */\n  if (lwork) g_free(lwork);\n\n} /* end RunningMedian */\n\n/**\n * Determine alpha median value of a ofloat array\n * \\param n       Number of points\n * \\param value   Array of values\n * \\param alpha   0 -> 1 = pure boxcar -> pure MWF (ALPHA of the \n *                data samples are discarded and the rest averaged). \n * \\return alpha median value\n */\nofloat MedianLevel (olong n, ofloat *value, ofloat alpha)\n{\n  ofloat out=0.0;\n  ofloat fblank = ObitMagicF();\n  ofloat beta, sum;\n  olong i, i1, i2, count;\n\n  if (n<=0) return out;\n\n  /* Sort to ascending order */\n  qsort ((void*)value, n, sizeof(ofloat), compare_gfloat);\n\n  out = value[n/2];\n\n  beta = MAX (0.05, MIN (0.95, alpha)) / 2.0; /*  Average around median factor */\n\n  /* Average around the center */\n  i1 = MAX (0, (n/2)-(olong)(beta*n+0.5));\n  i2 = MIN (n, (n/2)+(olong)(beta*n+0.5));\n\n  if (i2>i1) {\n    sum = 0.0;\n    count = 0;\n    for (i=i1; i<i2; i++) {\n      if (value[i]!=fblank) {\n\tsum += value[i];\n\tcount++;\n      }\n    }\n    if (count>0) out = sum / count;\n  }\n   \n  return out;\n} /* end MedianLevel */\n\n/**\n * Determine robust RMS value of a ofloat array about mean\n * Use center 90% of points, excluding at least one point from each end\n * \\param n       Number of points, needs at least 4\n * \\param value   Array of values assumed sorted\n * \\param mean    Mean value of value\n * \\return RMS value, fblank if cannot determine\n */\nofloat MedianSigma (olong n, ofloat *value, ofloat mean)\n{\n  ofloat fblank = ObitMagicF();\n  ofloat out;\n  ofloat sum;\n  olong i, i1, i2, count;\n\n  out = fblank;\n  if (n<=4) return out;\n  if (mean==fblank) return out;\n\n  /* Get RMS around the center 90% */\n  i1 = MAX (1,   (n/2)-(olong)(0.45*n+0.5));\n  i2 = MIN (n-1, (n/2)+(olong)(0.45*n+0.5));\n\n  if (i2>i1) {\n    sum = 0.0;\n    count = 0;\n    for (i=i1; i<i2; i++) {\n      if (value[i]!=fblank) {\n\tsum += (value[i]-mean)*(value[i]-mean);\n\tcount++;\n      }\n    }\n    if (count>1) out = sqrt(sum / (count-1));\n  }\n   \n  return out;\n} /* end MedianSigma */\n\n/**\n * Fit polynomial y = f(poly, x) with magic value blanking\n * Use gsl package.\n * \\param poly   [out] polynomial coef in order of increasing power of x\n * \\param order  order of the polynomial\n * \\param x      values at which y is sampled\n * \\param y      values to be fitted\n * \\param wt     weights for values\n * \\param n      number of (x,y) value pairs\n */\nvoid  FitPoly (ofloat *poly, olong order, ofloat *x, ofloat *y, ofloat *wt, \n\t       olong n)\n{\n  olong i, j, k, good, p=order+1;\n  ofloat fgood=0.0;\n  double xi, chisq;\n  gsl_matrix *X, *cov;\n  gsl_vector *yy, *w, *c;\n  gsl_multifit_linear_workspace *work;\n  ofloat fblank = ObitMagicF();\n\n  /* Only use good data */\n  good = 0;\n  for (i=0; i<n; i++) if (y[i]!=fblank) {good++; fgood = y[i];}\n\n  /* If only one good datum - use it */\n  if (good==1) {\n    poly[0] = fgood;\n    poly[1] = 0.0;\n  }\n\n  if (good<(order+1)) {  /* Not enough good data */\n    poly[0] = fblank;\n    return;\n  }\n\n  /* If only one and order=0 use it */\n  if ((good==1) && (order==0)) {\n    poly[0] = y[0];\n    return;\n  }\n\n  /* allocate arrays */\n  X    = gsl_matrix_alloc(good, p);\n  yy   = gsl_vector_alloc(good);\n  w    = gsl_vector_alloc(good);\n  c    = gsl_vector_alloc(p);\n  cov  = gsl_matrix_alloc(p, p);\n  work = gsl_multifit_linear_alloc (good, p);\n\n  /* set data */\n  k = 0;\n  for (i=0; i<n; i++) {\n    if (y[i]!=fblank) {\n      gsl_vector_set(yy, k, (double)y[i]);\n      gsl_vector_set(w, k, (double)wt[i]);\n      xi = 1.0;\n      for (j=0; j<p; j++) {\n\tgsl_matrix_set(X, k, j, xi);\n\txi *= x[i];\n      }\n      k++;  /* good ones */\n    }\n  }\n\n  /* Fit */\n  gsl_multifit_wlinear (X, w, yy, c, cov, &chisq, work);\n\n  /* get results */\n  for (j=0; j<p; j++) poly[j] = (ofloat)gsl_vector_get(c, j);\n\n  /* Deallocate arrays */\n  gsl_matrix_free(X);\n  gsl_vector_free(yy);\n  gsl_vector_free(w);\n  gsl_vector_free(c);\n  gsl_matrix_free(cov);\n  gsl_multifit_linear_free (work);\n} /* end FitPoly */\n\n/**\n * Evaluate polynomial y = f(poly, x)\n * \\param order  order of the polynomial\n * \\param poly   polynomial coef in order of increasing power of x\n * \\param x      value at which polynomial is to be evaluated\n * \\return evaluated polynomial\n */\nofloat  EvalPoly (olong order, ofloat *poly, ofloat x)\n{\n  olong i;\n  ofloat sum = 0.0, aarg = 1.0;\n\n  for (i=0; i<=order; i++) {\n    sum  += poly[i]*aarg;\n    aarg *= x;\n  }\n  return sum;\n} /* end EvalPoly  */\n\n\n\n/*----------------------Private functions---------------------------*/\n/**\n * ofloat comparison of two arguments\n * \\param arg1 first value to compare\n * \\param arg2 second value to compare\n * \\return negative if arg1 is less than arg2, zero if equal\n *  and positive if arg1 is greater than arg2.\n */\nstatic int compare_gfloat  (const void* arg1,  const void* arg2)\n{\n  int out = 0;\n  ofloat larg1, larg2;\n\n  larg1 = *(ofloat*)arg1;\n  larg2 = *(ofloat*)arg2;\n  if (larg1<larg2) out = -1;\n  else if (larg1>larg2) out = 1;\n  return out;\n} /* end compare_gfloat */\n", "meta": {"hexsha": "acdd3182ad1a7a5d6e06944296e4766319b03a1b", "size": 13077, "ext": "c", "lang": "C", "max_stars_repo_path": "ObitSystem/Obit/src/ObitUtil.c", "max_stars_repo_name": "sarrvesh/Obit", "max_stars_repo_head_hexsha": "e4ce6029e9beb2a8c0316ee81ea710b66b2b7986", "max_stars_repo_licenses": ["Linux-OpenIB"], "max_stars_count": 5.0, "max_stars_repo_stars_event_min_datetime": "2019-08-26T06:53:08.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-20T01:08:59.000Z", "max_issues_repo_path": "ObitSystem/Obit/src/ObitUtil.c", "max_issues_repo_name": "sarrvesh/Obit", "max_issues_repo_head_hexsha": "e4ce6029e9beb2a8c0316ee81ea710b66b2b7986", "max_issues_repo_licenses": ["Linux-OpenIB"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ObitSystem/Obit/src/ObitUtil.c", "max_forks_repo_name": "sarrvesh/Obit", "max_forks_repo_head_hexsha": "e4ce6029e9beb2a8c0316ee81ea710b66b2b7986", "max_forks_repo_licenses": ["Linux-OpenIB"], "max_forks_count": 8.0, "max_forks_repo_forks_event_min_datetime": "2017-08-29T15:12:32.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T12:16:08.000Z", "avg_line_length": 28.5524017467, "max_line_length": 81, "alphanum_fraction": 0.5589967118, "num_tokens": 3994, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4687906266262437, "lm_q2_score": 0.06954174450582809, "lm_q1q2_score": 0.03260051798356929}}
{"text": "/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\r\n * Copyright 2018 - Matteo Ragni, Matteo Cocetti - University of Trento\r\n *\r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n *\r\n * The above copyright notice and this permission notice shall be included in\r\n * all copies or substantial portions of the Software.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */\r\n\r\n#ifndef LIBNEWTON_H_\r\n#define LIBNEWTON_H_\r\n\r\n#include <lapacke.h>\r\n#include <cblas.h>\r\n\r\n/**\r\n * @brief Jacobian Callback for the Newton algorithm\r\n * \r\n * The callback receivs the current input, the current control, and the list of\r\n * parameter vectors. It should store the first argument the Jacobian matrix (stored as an array).\r\n * To select the ordering in the matrix, you must select the correct ordering in newton_options \r\n * structure, at the ordering input.\r\n * @param df output vector (vectorized Jacobian matrix)\r\n * @param t current time for evaluation\r\n * @param x current point for evaluation\r\n * @param u current control for evaluation\r\n * @param p array of parameter vectors\r\n * @param data user space input (simply use it as a pointer casted to void)\r\n */\r\ntypedef void (*newton_jacobian)(\r\n    double *df,\r\n    const double t,\r\n    const double *x,\r\n    const double *u,\r\n    const double **p,\r\n    void *data);\r\n\r\n/**\r\n * @brief Vector Field Callback for the Newton algorithm\r\n * \r\n * The callback receivs the current input, the current control, and the list of\r\n * parameter vectors. It should store the first argument the function output vector.\r\n * @param df output vector (vectorized Jacobian matrix)\r\n * @param t current time for evaluation\r\n * @param x current point for evaluation\r\n * @param u current control for evaluation\r\n * @param p array of parameter vectors\r\n * @param data user space input (simply use it as a pointer casted to void)\r\n */\r\ntypedef void (*newton_function)(\r\n    double *f,\r\n    const double t,\r\n    const double *x,\r\n    const double *u,\r\n    const double **p,\r\n    void *data);\r\n\r\n/**\r\n * @brief Options for the Newton Algorithm\r\n * \r\n * This structure contains all the options for the Newton algorithm, alongside the callbacks.\r\n * The structure will be modified by the algorithm with some debug information, such as number\r\n * of iterations, tolerances and ordering for the jacobian matrix.\r\n */\r\ntypedef struct newton_options {\r\n  lapack_int ordering; /**< Should be LAPACK_ROW_MAJOR or LAPACK_COL_MAJOR */\r\n  lapack_int f_size;   /**< Vector field size */\r\n  lapack_int x_size;   /**< Variable vector size */\r\n  double f_tol;        /**< Stopping tolerance for the zero. \r\n                              At the end will contain the 2 norm of the \r\n                              vector field in the solution */\r\n  double x_tol;        /**< Stopping tolerance for the x vector step.\r\n                              At the end will contain the 2 norm of the last update step */\r\n  lapack_int max_iter; /**< Maximum number of iteration,\r\n                              At the end will contain the number of step executed  */\r\n  newton_function f;   /**< Pointer to vector field callback */\r\n  newton_jacobian df;  /**<  Pointer to Jacobian callback */\r\n} newton_options;\r\n\r\n/**\r\n * @brief Error code returned by the algorithm\r\n */\r\ntypedef enum newton_ret {\r\n  NEWTON_F_TOL = 0,         /**< (0) The solver reached the required tolerance limit for the vector field */\r\n  NEWTON_X_TOL,             /**< (1) The last step for solution update was less than the minimum */\r\n  NEWTON_MAX_ITER,          /**< (2) Maximum number of iterations reached */\r\n  NEWTON_SINGULAR_JACOBIAN, /**< (3 LAPACKE) The jacobian is singular */\r\n  NEWTON_ILLEGAL_JACOBIAN,  /**< (4 LAPACKE) Illegal jacobian */\r\n  NEWTON_MALLOC_ERROR,      /**< (5) Cannot allocate memory */\r\n  NEWTON_GENERIC_ERROR      /**< (6) Generic error in the execution of the algorithm */\r\n} newton_ret;\r\n\r\n/**\r\n * @brief Boolean implementation\r\n */\r\ntypedef enum newton_bool {\r\n  NEWTON_FALSE = 0, /**< False */\r\n  NEWTON_TRUE       /**< True */\r\n} newton_bool;\r\n\r\n/**\r\n * @brief Executes the Newton algorithm for root finding\r\n * \r\n * Executes the Newton algorithm for root finding. The step Performed is:\r\n * \\f{\r\n *   x_{k+1} - x_{k} = -\\nabla F^{-1}(x_k, u, p) F(x_k, u, p)\r\n * \\f}\r\n * and the solution is found by using DGELS defined in LAPACK library.\r\n * The stopping conditions are:\r\n *  * Number of iterations bigger than maximum allowed (specified in newton_options)\r\n *  * \\f$ |x_{k+1} - x_k| \\leq x_{tol}\\f$\r\n *  * \\f$ |f(x_k, u, p)| \\leq y_{tol}\\f$\r\n * and the function and jacobian are evaluated through callbacks. On exit, the values \r\n * inside the option structure are update for debuggin purposes (this is why Newton \r\n * options is not a const pointer). It returns a status enum.\r\n * @param opt option structure\r\n * @param x root position and initial condition. Will be modified\r\n * @param u control action input. It can be NULL.\r\n * @param p parameter array of vectors. It can be NULL.\r\n * @param data space for user data. Will be passed to callbacks. It can be NULL\r\n * @return a status exit code as described in newton_ret enum.\r\n */\r\nnewton_ret newton_solve(\r\n    newton_options *opt,\r\n    const double t,\r\n    double *x,\r\n    const double *u,\r\n    const double **p,\r\n    void *data);\r\n\r\n#endif\r\n", "meta": {"hexsha": "a098d32ea181b719f94091ce4350af5e06308d8e", "size": 6251, "ext": "h", "lang": "C", "max_stars_repo_path": "libnewton.h", "max_stars_repo_name": "MatteoRagni/libeuler", "max_stars_repo_head_hexsha": "7dd73c1b383b6c32086da4880a82326ebf47b71b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2019-03-05T07:42:42.000Z", "max_stars_repo_stars_event_max_datetime": "2020-01-22T02:16:51.000Z", "max_issues_repo_path": "libnewton.h", "max_issues_repo_name": "MatteoRagni/libeuler", "max_issues_repo_head_hexsha": "7dd73c1b383b6c32086da4880a82326ebf47b71b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "libnewton.h", "max_forks_repo_name": "MatteoRagni/libeuler", "max_forks_repo_head_hexsha": "7dd73c1b383b6c32086da4880a82326ebf47b71b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.1103448276, "max_line_length": 109, "alphanum_fraction": 0.6667733163, "num_tokens": 1488, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4416730056646256, "lm_q2_score": 0.06656918804457732, "lm_q1q2_score": 0.029401813368302124}}
{"text": "/*******************************************************************************\n*\n*       This file is part of the General Hidden Markov Model Library,\n*       GHMM version __VERSION__, see http://ghmm.org\n*\n*       Filename: ghmm/ghmm/randvar.c\n*       Authors:  Bernhard Knab, Benjamin Rich, Janne Grunau\n*\n*       Copyright (C) 1998-2004 Alexander Schliep\n*       Copyright (C) 1998-2001 ZAIK/ZPR, Universitaet zu Koeln\n*       Copyright (C) 2002-2004 Max-Planck-Institut fuer Molekulare Genetik,\n*                               Berlin\n*\n*       Contact: schliep@ghmm.org\n*\n*       This library is free software; you can redistribute it and/or\n*       modify it under the terms of the GNU Library General Public\n*       License as published by the Free Software Foundation; either\n*       version 2 of the License, or (at your option) any later version.\n*\n*       This library is distributed in the hope that it will be useful,\n*       but WITHOUT ANY WARRANTY; without even the implied warranty of\n*       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n*       Library General Public License for more details.\n*\n*       You should have received a copy of the GNU Library General Public\n*       License along with this library; if not, write to the Free\n*       Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n*\n*\n*       This file is version $Revision: 2310 $\n*                       from $Date: 2013-06-14 10:36:57 -0400 (Fri, 14 Jun 2013) $\n*             last change by $Author: ejb177 $.\n*\n*******************************************************************************/\n\n#ifdef HAVE_CONFIG_H\n#  include \"../config.h\"\n#endif\n\n#include <math.h>\n#include <float.h>\n#include <string.h>\n#ifdef HAVE_LIBPTHREAD\n# include <pthread.h>\n#endif /* HAVE_LIBPTHREAD */\n\n#include \"ghmm.h\"\n#include \"mes.h\"\n#include \"mprintf.h\"\n#include \"randvar.h\"\n#include \"rng.h\"\n\n#ifdef DO_WITH_GSL\n\n# include <gsl/gsl_math.h>\n# include <gsl/gsl_sf_erf.h>\n# include <gsl/gsl_randist.h>\n\n#include <gsl/gsl_vector.h>\n#include <gsl/gsl_matrix.h>\n#include <gsl/gsl_blas.h>\n\n#endif /* DO_WITH_GSL */\n\n\n#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)\n#else\nstatic double ighmm_erf (double x);\nstatic double ighmm_erfc (double x);\n#endif /* check for ISO C99 */\n\n/* A list of already calculated values of the density function of a \n   N(0,1)-distribution, with x in [0.00, 19.99] */\n#define PDFLEN 2000\n#define X_STEP_PDF 0.01         /* step size */\n#define X_FAKT_PDF 100          /* equivalent to step size */\nstatic double pdf_stdnormal[PDFLEN];\nstatic int pdf_stdnormal_exists = 0;\n\n/* A list of already calulated values PHI of the Gauss distribution is\n   read in, x in [-9.999, 0] */\n#define X_STEP_PHI 0.001        /* step size */\n#define X_FAKT_PHI 1000         /* equivalent to step size */\nstatic double x_PHI_1 = -1.0;\n\n#ifndef M_SQRT1_2\n#define M_SQRT1_2  0.70710678118654752440084436210\n#endif\n\n\n/*============================================================================*/\n/* needed by ighmm_gtail_pmue_interpol */\n\ndouble ighmm_rand_get_xfaktphi ()\n{\n  return X_FAKT_PHI;\n}\n\ndouble ighmm_rand_get_xstepphi ()\n{\n  return X_STEP_PHI;\n}\n\ndouble ighmm_rand_get_philen ()\n{\n#ifdef DO_WITH_GSL\n  return 0 /*PHI_len*/;\n#else\n  return ighmm_rand_get_xPHIless1 () / X_STEP_PHI;\n#endif\n}\n\n\n/*============================================================================*/\ndouble ighmm_rand_get_PHI (double x)\n{\n#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)\n  return (erf (x * M_SQRT1_2) + 1.0) / 2.0;\n#else\n  return (ighmm_erf (x * M_SQRT1_2) + 1.0) / 2.0;\n#endif\n}                               /* randvar_get_PHI */\n\n\n/*============================================================================*/\n/* When is PHI[x,0,1] == 1? */\ndouble ighmm_rand_get_xPHIless1 ()\n{\n# define CUR_PROC \"ighmm_rand_get_xPHIless1\"\n\n  if (x_PHI_1 == -1) {\n    double low, up, half;\n    low = 0;\n    up = 100;\n    while (up - low > 0.001) {\n      half = (low + up) / 2.0;\n      if (ighmm_rand_get_PHI (half) < 1.0)\n        low = half;\n      else\n        up = half;\n    }\n    x_PHI_1 = low;\n  }\n  return (x_PHI_1);\n\n# undef CUR_PROC\n}\n\n/*============================================================================*/\ndouble ighmm_rand_get_1overa (double x, double mean, double u)\n{\n  /* Calulates 1/a(x, mean, u), with a = the integral from x til \\infty over\n     the Gauss density function */\n# define CUR_PROC \"ighmm_rand_get_1overa\"\n\n  double erfc_value;\n\n  if (u <= 0.0) {\n    GHMM_LOG(LCONVERTED, \"u <= 0.0 not allowed\\n\");\n    goto STOP;\n  }\n\n#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)\n  erfc_value = erfc ((x - mean) / sqrt (u * 2));\n#else\n  erfc_value = ighmm_erfc ((x - mean) / sqrt (u * 2));\n#endif\n\n  if (erfc_value <= DBL_MIN) {\n    ighmm_mes (MES_WIN, \"a ~= 0.0 critical! (mue = %.2f, u =%.2f)\\n\", mean, u);\n    return (erfc_value);\n  }\n  else\n    return (2.0 / erfc_value);\n\nSTOP:\n  return (-1.0);\n# undef CUR_PROC\n}                               /* ighmm_rand_get_1overa */\n\n\n/*============================================================================*/\n/* REMARK:\n   The calulation of this density function was testet, by calculating the \n   following integral sum for arbitrary mue and u:\n     for (x = 0, x < ..., x += step(=0.01/0.001/0.0001)) \n       isum += step * ighmm_rand_normal_density_pos(x, mue, u);\n   In each case, the sum \"converged\" evidently towards 1!\n   (BK, 14.6.99)\n   CHANGE:\n   Truncate at -EPS_NDT (const.h), so that x = 0 doesn't lead to a problem.\n   (BK, 15.3.2000)\n*/\ndouble ighmm_rand_normal_density_pos (double x, double mean, double u)\n{\n# define CUR_PROC \"ighmm_rand_normal_density_pos\"\n  return ighmm_rand_normal_density_trunc (x, mean, u, -GHMM_EPS_NDT);\n# undef CUR_PROC\n}                               /* double ighmm_rand_normal_density_pos */\n\n\n/*============================================================================*/\ndouble ighmm_rand_normal_density_trunc(double x, double mean, double u,\n                                       double a)\n{\n# define CUR_PROC \"ighmm_rand_normal_density_trunc\"\n#ifndef DO_WITH_GSL\n  double c;\n#endif /* DO_WITH_GSL */\n\n  if (u <= 0.0) {\n    GHMM_LOG(LERROR, \"u <= 0.0 not allowed\");\n    goto STOP;\n  }\n  if (x < a)\n    return 0.0;\n\n#ifdef DO_WITH_GSL\n  /* move mean to the right position */\n  return gsl_ran_gaussian_tail_pdf(x - mean, a - mean, sqrt(u));\n#else\n  if ((c = ighmm_rand_get_1overa(a, mean, u)) == -1) {\n    GHMM_LOG_QUEUED(LERROR);\n    goto STOP;\n  };\n  return c * ighmm_rand_normal_density(x, mean, u);\n#endif /* DO_WITH_GSL */\n\nSTOP:\n  return -1.0;\n# undef CUR_PROC\n}                               /* double ighmm_rand_normal_density_trunc */\n\n\n/*============================================================================*/\ndouble ighmm_rand_normal_density (double x, double mean, double u)\n{\n# define CUR_PROC \"ighmm_rand_normal_density\"\n#ifndef DO_WITH_GSL\n  double expo;\n#endif\n  if (u <= 0.0) {\n    GHMM_LOG(LCONVERTED, \"u <= 0.0 not allowed\\n\");\n    goto STOP;\n  }\n  /* The denominator is possibly < EPS??? Check that ? */\n#ifdef DO_WITH_GSL\n  /* double gsl_ran_gaussian_pdf (double x, double sigma) */\n  return gsl_ran_gaussian_pdf (x - mean, sqrt (u));\n#else\n  expo = exp (-1 * m_sqr (mean - x) / (2 * u));\n  return (1 / (sqrt (2 * PI * u)) * expo);\n#endif\n\nSTOP:\n  return (-1.0);\n# undef CUR_PROC\n}                               /* double ighmm_rand_normal_density */\n\n\n/*============================================================================*/\n/* covariance matrix is linearized */\ndouble ighmm_rand_binormal_density(const double *x, double *mean, double *cov)\n{\n# define CUR_PROC \"ighmm_rand_binormal_density\"\n  double rho;\n#ifndef DO_WITH_GSL\n  double numerator,part1,part2,part3;\n#endif\n  if (cov[0] <= 0.0 || cov[2 + 1] <= 0.0) {\n    GHMM_LOG(LCONVERTED, \"variance <= 0.0 not allowed\\n\");\n    goto STOP;\n  }\n  rho = cov[1] / ( sqrt (cov[0]) * sqrt (cov[2 + 1]) );\n  /* The denominator is possibly < EPS??? Check that ? */\n#ifdef DO_WITH_GSL\n  /* double gsl_ran_bivariate_gaussian_pdf (double x, double y, double sigma_x,\n                                            double sigma_y, double rho) */\n  return gsl_ran_bivariate_gaussian_pdf (x[0], x[1], sqrt (cov[0]),\n                                         sqrt (cov[2 + 1]), rho);\n#else\n  part1 = (x[0] - mean[0]) / sqrt (cov[0]);\n  part2 = (x[1] - mean[1]) / sqrt (cov[2 + 1]);\n  part3 = m_sqr (part1) - 2 * part1 * part2 + m_sqr (part2);\n  numerator = exp ( -1 * (part3) / ( 2 * (1 - m_sqr(rho)) ) );\n  return (numerator / ( 2 * PI * sqrt(1 - m_sqr(rho)) ));\n#endif\n\nSTOP:\n  return (-1.0);\n# undef CUR_PROC\n}                               /* double ighmm_rand_binormal_density */\n\n/*============================================================================*/\n/* matrices are linearized */\ndouble ighmm_rand_multivariate_normal_density(int length, const double *x, double *mean, double *sigmainv, double det)\n{\n# define CUR_PROC \"ighmm_rand_multivariate_normal_density\"\n  /* multivariate normal density function    */\n  /*\n   *       length     dimension of the random vetor\n   *       x          point at which to evaluate the pdf\n   *       mean       vector of means of size n\n   *       sigmainv   inverse variance matrix of dimension n x n\n   *       det        determinant of covariance matrix\n   */\n\n#ifdef DO_WITH_GSL\n  int i, j;\n  double ax,ay;\n  gsl_vector *ym, *xm, *gmean;\n  gsl_matrix *inv = gsl_matrix_alloc(length, length);\n\n\n  for (i=0; i<length; ++i) {\n    for (j=0; j<length; ++j) {\n      gsl_matrix_set(inv, i, j, sigmainv[i*length+j]);\n    }\n  }\n\n  xm = gsl_vector_alloc(length);\n  gmean = gsl_vector_alloc(length);\n  /*gsl_vector_memcpy(xm, x);*/\n  for (i=0; i<length; ++i) {\n    gsl_vector_set(xm, i, x[i]);\n    gsl_vector_set(gmean, i, mean[i]);\n  }\n\n  gsl_vector_sub(xm, gmean);\n  ym = gsl_vector_alloc(length);\n  gsl_blas_dsymv(CblasUpper, 1.0, inv, xm, 0.0, ym);\n  gsl_matrix_free(inv);\n  gsl_blas_ddot(xm, ym, &ay);\n  gsl_vector_free(xm);\n  gsl_vector_free(ym);\n  ay = exp(-0.5*ay) / sqrt(pow((2*M_PI), length) * det);\n\n  return ay;\n#else\n  /* do without GSL */\n  int i, j;\n  double ay, tempv;\n\n  ay = 0;\n  for (i=0; i<length; ++i) {\n    tempv = 0;\n    for (j=0; j<length; ++j) {\n      tempv += (x[j]-mean[j])*sigmainv[j*length+i];\n    }\n    ay += tempv*(x[i]-mean[i]);\n  }\n  ay = exp(-0.5*ay) / sqrt(pow((2*PI), length) * det);\n\n  return ay;\n#endif\n# undef CUR_PROC\n}                               /* double ighmm_rand_multivariate_normal_density */\n\n/*============================================================================*/\ndouble ighmm_rand_uniform_density (double x, double max, double min)\n{\n# define CUR_PROC \"ighmm_rand_uniform_density\"\n  double prob;\n  if (max <= min) {\n    GHMM_LOG(LCONVERTED, \"max <= min not allowed \\n\");\n    goto STOP;\n  }\n  prob = 1.0/(max-min);\n\n  if ( (x <= max) && (x>=min) ){\n    return prob;\n  }else{\n    return 0.0;\n  }\nSTOP:\n  return (-1.0);\n# undef CUR_PROC\n}                               /* double ighmm_rand_uniform_density */\n\n\n/*============================================================================*/\n/* special ghmm_cmodel pdf need it: smo->density==normal_approx: */\n/* generates a table of of aequidistant samples of gaussian pdf */\n\nstatic int randvar_init_pdf_stdnormal ()\n{\n# define CUR_PROC \"randvar_init_pdf_stdnormal\"\n  int i;\n  double x = 0.00;\n  for (i = 0; i < PDFLEN; i++) {\n    pdf_stdnormal[i] = 1 / (sqrt (2 * PI)) * exp (-1 * x * x / 2);\n    x += (double) X_STEP_PDF;\n  }\n  pdf_stdnormal_exists = 1;\n  /* printf(\"pdf_stdnormal_exists = %d\\n\", pdf_stdnormal_exists); */\n  return (0);\n# undef CUR_PROC\n}                               /* randvar_init_pdf_stdnormal */\n\n\ndouble ighmm_rand_normal_density_approx (double x, double mean, double u)\n{\n# define CUR_PROC \"ighmm_rand_normal_density_approx\"\n#ifdef HAVE_LIBPTHREAD\n  static pthread_mutex_t lock;\n#endif /* HAVE_LIBPTHREAD */\n  int i;\n  double y, z, pdf_x;\n  if (u <= 0.0) {\n    GHMM_LOG(LCONVERTED, \"u <= 0.0 not allowed\\n\");\n    goto STOP;\n  }\n  if (!pdf_stdnormal_exists) {\n#ifdef HAVE_LIBPTHREAD\n    pthread_mutex_lock (&lock); /* Put on a lock, because the clustering is parallel   */\n#endif /* HAVE_LIBPTHREAD */\n    randvar_init_pdf_stdnormal ();\n#ifdef HAVE_LIBPTHREAD\n    pthread_mutex_unlock (&lock);       /* Take the lock off */\n#endif /* HAVE_LIBPTHREAD */\n  }\n  y = 1 / sqrt (u);\n  z = fabs ((x - mean) * y);\n  i = (int) (z * X_FAKT_PDF);\n  /* linear interpolation: */\n  if (i >= PDFLEN - 1) {\n    i = PDFLEN - 1;\n    pdf_x = y * pdf_stdnormal[i];\n  }\n  else\n    pdf_x = y * (pdf_stdnormal[i] +\n                 (z - i * X_STEP_PDF) *\n                 (pdf_stdnormal[i + 1] - pdf_stdnormal[i]) / X_STEP_PDF);\n  return (pdf_x);\nSTOP:\n  return (-1.0);\n# undef CUR_PROC\n}                               /* double ighmm_rand_normal_density_approx */\ndouble ighmm_rand_dirichlet(int seed, int len, double *alpha, double *theta){\n  if (seed != 0) {\n    GHMM_RNG_SET(RNG, seed);\n  }\n#ifdef DO_WITH_GSL\n   gsl_ran_dirichlet(RNG, len, alpha, theta);\n#else\n  printf(\"not implemted without gsl. Compile with gsl to use dirichlet\");\n#endif\n}\n\n/*============================================================================*/\ndouble ighmm_rand_std_normal (int seed)\n{\n# define CUR_PROC \"ighmm_rand_std_normal\"\n  if (seed != 0) {\n    GHMM_RNG_SET (RNG, seed);\n  }\n\n#ifdef DO_WITH_GSL\n    return (gsl_ran_gaussian (RNG, 1.0));\n#else\n    /* Use the polar Box-Mueller transform */\n    /*\n       double x, y, r2;\n\n       do {\n       x = 2.0 * GHMM_RNG_UNIFORM(RNG) - 1.0;\n       y = 2.0 * GHMM_RNG_UNIFORM(RNG) - 1.0;\n       r2 = (x * x) + (y * y);\n       } while (r2 >= 1.0);\n\n       return x * sqrt((-2.0 * log(r2)) / r2);\n     */\n\n    double r2, theta;\n\n    r2 = -2.0 * log (GHMM_RNG_UNIFORM (RNG));   /* r2 ~ chi-square(2) */\n    theta = 2.0 * PI * GHMM_RNG_UNIFORM (RNG);  /* theta ~ uniform(0, 2 \\pi) */\n    return sqrt (r2) * cos (theta);\n#endif\n\n# undef CUR_PROC\n}                               /* ighmm_rand_std_normal */\n\n\n/*============================================================================*/\ndouble ighmm_rand_normal(double mue, double u, int seed)\n{\n# define CUR_PROC \"ighmm_rand_normal\"\n  if (seed != 0) {\n    GHMM_RNG_SET(RNG, seed);\n  }\n\n#ifdef DO_WITH_GSL\n    return gsl_ran_gaussian(RNG, sqrt (u)) + mue;\n#else\n    double x;\n    x = sqrt(u) * ighmm_rand_std_normal(seed) + mue;\n    return x;\n#endif\n\n# undef CUR_PROC\n}                               /* ighmm_rand_normal */\n\n/*============================================================================*/\nint ighmm_rand_multivariate_normal (int dim, double *x, double *mue, double *sigmacd, int seed)\n{\n# define CUR_PROC \"ighmm_rand_multivariate_normal\"\n  /* generate random vector of multivariate normal\n   *\n   *     dim     number of dimensions\n   *     x       space to store resulting vector in\n   *     mue     vector of means\n   *     sigmacd linearized cholesky decomposition of cov matrix\n   *     seed    RNG seed\n   *\n   *     see Barr & Slezak, A Comparison of Multivariate Normal Generators */\n  int i, j;\n#ifdef DO_WITH_GSL\n  gsl_vector *y = gsl_vector_alloc(dim);\n  gsl_vector *xgsl = gsl_vector_alloc(dim);\n  gsl_matrix *cd = gsl_matrix_alloc(dim, dim);\n#endif\n  if (seed != 0) {\n    GHMM_RNG_SET (RNG, seed);\n    /* do something here */\n    return 0;\n  }\n  else {\n#ifdef DO_WITH_GSL\n    /* cholesky decomposition matrix */\n    for (i=0;i<dim;i++) {\n      for (j=0;j<dim;j++) {\n        gsl_matrix_set(cd, i, j, sigmacd[i*dim+j]);\n      }\n    }\n    /* generate a random vector N(O,I) */\n    for (i=0;i<dim;i++) {\n      gsl_vector_set(y, i, ighmm_rand_std_normal(seed));\n    }\n    /* multiply cd with y */\n    gsl_blas_dgemv(CblasNoTrans, 1.0, cd, y, 0.0, xgsl);\n    for (i=0;i<dim;i++) {\n      x[i] = gsl_vector_get(xgsl, i) + mue[i];\n    }\n    gsl_vector_free(y);\n    gsl_vector_free(xgsl);\n    gsl_matrix_free(cd);\n#else\n    /* multivariate random numbers without gsl */\n    double randuni;\n    for (i=0;i<dim;i++) {\n      randuni = ighmm_rand_std_normal(seed);\n      for (j=0;j<dim;j++) {\n        if (i==0)\n          x[j] = mue[j];\n        x[j] += randuni * sigmacd[j*dim+i];\n      }\n    }\n#endif\n    return 0;\n  }\n# undef CUR_PROC\n}                               /* ighmm_rand_multivariate_normal */\n\n\n/*============================================================================*/\n#ifndef DO_WITH_GSL\n# define C0 2.515517\n# define C1 0.802853\n# define C2 0.010328\n# define D1 1.432788\n# define D2 0.189269\n# define D3 0.001308\n#endif\n\ndouble ighmm_rand_normal_right (double a, double mue, double u, int seed)\n{\n# define CUR_PROC \"ighmm_rand_normal_right\"\n  double x = -1;\n  double sigma;\n#ifdef DO_WITH_GSL\n  double s;\n#else\n  double U, Us, Us1, Feps, t, T;\n#endif\n\n  if (u <= 0.0) {\n    GHMM_LOG(LCONVERTED, \"u <= 0.0 not allowed\\n\");\n    goto STOP;\n  }\n  sigma = sqrt(u);\n\n  if (seed != 0) {\n    GHMM_RNG_SET (RNG, seed);\n  }\n\n#ifdef DO_WITH_GSL\n  /* move boundary to lower values in order to achieve maximum at mue\n     gsl_ran_gaussian_tail(generator, lower_boundary, sigma)\n   */\n  return mue + gsl_ran_gaussian_tail(RNG, a - mue, sqrt (u));\n\n#else /* DO_WITH_GSL */\n\n  /* Inverse transformation with restricted sampling by Fishman */\n  U = GHMM_RNG_UNIFORM(RNG);\n  Feps = ighmm_rand_get_PHI((a-mue) / sigma);\n\n  Us = Feps + (1-Feps) * U;\n  Us1 = 1-Us;\n  t = m_min (Us, Us1);\n\n  t = sqrt (-log (t * t));\n\n  T =\n    sigma * (t - (C0 + t * (C1 + t * C2))\n                 / (1 + t * (D1 + t * (D2 + t * D3))));\n\n  if (Us < Us1)\n    x = mue - T;\n  else\n    x = mue + T;\n#endif /* DO_WITH_GSL */\n\nSTOP:\n  return x;\n# undef CUR_PROC\n}                               /* randvar_normal_pos */\n\n\n\n/*============================================================================*/\ndouble ighmm_rand_uniform_int (int seed, int K)\n{\n# define CUR_PROC \"ighmm_rand_uniform_int\"\n  if (seed != 0) {\n    GHMM_RNG_SET (RNG, seed);\n  }\n\n#ifdef DO_WITH_GSL\n    /* more direct solution than old version ! */\n    return (double) gsl_rng_uniform_int (RNG, K);\n#else\n    return (double) ((int) (((double) K) * GHMM_RNG_UNIFORM (RNG)));\n#endif\n\n# undef CUR_PROC\n}                               /* ighmm_rand_uniform_int */\n\n/*===========================================================================*/\ndouble ighmm_rand_uniform_cont (int seed, double max, double min)\n{\n# define CUR_PROC \"ighmm_rand_uniform_cont\"\n  if (max <= min) {\n    GHMM_LOG(LCONVERTED, \"max <= min not allowed\\n\");\n    goto STOP;\n  }\n  if (seed != 0) {\n    GHMM_RNG_SET (RNG, seed);\n  }\n\n#ifdef DO_WITH_GSL\n    return (double)(((double)gsl_rng_uniform (RNG)*(max-min)) + min);\n#else\n    return (double)((GHMM_RNG_UNIFORM (RNG))*(max-min) + min );\n#endif\n\nSTOP:\n  return (-1.0);\n# undef CUR_PROC\n}                               /* ighmm_rand_uniform_cont */\n\n/*============================================================================*/\n/* cumalative distribution function of N(mean, u) */\ndouble ighmm_rand_normal_cdf (double x, double mean, double u)\n{\n# define CUR_PROC \"ighmm_rand_normal_cdf\"\n  if (u <= 0.0) {\n    GHMM_LOG(LCONVERTED, \"u <= 0.0 not allowed\\n\");\n    goto STOP;\n  }\n#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)\n  /* PHI(x)=erf(x/sqrt(2))/2+0.5 */\n  return (erf ((x - mean) / sqrt (u * 2.0)) + 1.0) / 2.0;\n#else\n  return (ighmm_erf ((x - mean) / sqrt (u * 2.0)) + 1.0) / 2.0;\n#endif /* Check for ISO C99 */\nSTOP:\n  return (-1.0);\n# undef CUR_PROC\n}                               /* double ighmm_rand_normal_cdf */\n\n/*============================================================================*/\n/* cumalative distribution function of a-truncated N(mean, u) */\ndouble ighmm_rand_normal_right_cdf (double x, double mean, double u, double a)\n{\n# define CUR_PROC \"ighmm_rand_normal_right_cdf\"\n\n  if (x <= a)\n    return (0.0);\n  if (u <= a) {\n    GHMM_LOG(LCONVERTED, \"u <= a not allowed\\n\");\n    goto STOP;\n  }\n#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)\n  /*\n     Function: int erfc (double x, gsl_sf_result * result) \n     These routines compute the complementary error function\n     erfc(x) = 1 - erf(x) = 2/\\sqrt(\\pi) \\int_x^\\infty \\exp(-t^2). \n   */\n  return 1.0 + (erf ((x - mean) / sqrt (u * 2)) -\n                1.0) / erfc ((a - mean) / sqrt (u * 2));\n#else\n  return 1.0 + (ighmm_erf ((x - mean) / sqrt (u * 2)) -\n                1.0) / ighmm_erfc ((a - mean) / sqrt (u * 2));\n#endif /* Check for ISO C99 */\nSTOP:\n  return (-1.0);\n# undef CUR_PROC\n}                               /* double ighmm_rand_normal_cdf */\n\n/*============================================================================*/\n/* cumalative distribution function of a uniform distribution in the range [min,max] */\ndouble ighmm_rand_uniform_cdf (double x, double max, double min)\n{\n# define CUR_PROC \"ighmm_rand_uniform_cdf\"\n  if (max <= min) {\n    GHMM_LOG(LCONVERTED, \"max <= min not allowed\\n\");\n    goto STOP;\n  }  \n  if (x < min) {\n    return 0.0;\n  }\n  if (x >= max) {\n    return 1.0;\n  }\n  return (x-min)/(max-min);\nSTOP:\n  return (-1.0);\n# undef CUR_PROC\n}                               /* ighmm_rand_uniform_cdf */\n\n\n\n#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)\n#else\n\n/* THIS WILL BE OBSOLETE WHEN WE USE ISO C99 */ \n\n/*===========================================================================\n *\n * The following functions for the error function and the complementory\n * error function are taken from\n * http://www.mathematik.uni-bielefeld.de/~sillke/ALGORITHMS/special-functions/erf.c\n * and have following different copyright.\n\n * ====================================================\n * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n *\n * Developed at SunPro, a Sun Microsystems, Inc. business.\n * Permission to use, copy, modify, and distribute this\n * software is freely granted, provided that this notice\n * is preserved.\n * ====================================================\n */\n\n/*\n * ====================================================\n * \n * Reference:\n *\n * W. J. Cody,\n *   Rational Chebychev approximations for the\n *   error function.\n *   Mathematics of Computations 23 (1969) 631-637\n *\n * W. J. Cody,\n *   Performance evaluations of programs for the \n *   error and complementary error function.\n *   Transactions of the ACM on Mathematical Software, \n *   16:1 (March 1990) 38-46\n *   \n * W. J. Cody,\n *   SPECFUN - A portable special function package,\n *   In: New Computing environments; \n *   Microcomputers in Large-Scale Scientific Computing,\n *   A. Wouk, SIAM, 1987, 1-12\n *\n * W. J. Cody,\n *   http://www.netlib.org/specfun/erf.\n *\n * For calculations with complex arguments see:   \n * \n * Walter Gautschi\n *   \"Efficient computation of the complex error function\"\n *   SIAM J. Numer. Anal.\n *   7:1 (1970), 187-198\n * \n * J.A.C. Weideman\n *   \"Computation of the complex error function\"\n *   SIAM J. Numer. Anal.\n *   31:5 (1994), 1497-1518 \n *\n * ====================================================\n */\n\n\n/* double erf(double x)\n * double erfc(double x)\n *\t\t\t     x\n *\t\t      2      |\\\n *     erf(x)  =  ---------  | exp(-t*t)dt\n *\t \t   sqrt(pi) \\|\n *\t\t\t     0\n *\n *     erfc(x) =  1-erf(x)\n *  Note that\n *\t\terf(-x) = -erf(x)\n *\t\terfc(-x) = 2 - erfc(x)\n *\n * Method:\n *\t1. For |x| in [0, 0.84375]\n *\t    erf(x)  = x + x*R(x^2)\n *          erfc(x) = 1 - erf(x)           if x in [-.84375,0.25]\n *                  = 0.5 + ((0.5-x)-x*R)  if x in [0.25,0.84375]\n *\t   where R = P/Q where P is an odd poly of degree 8 and\n *\t   Q is an odd poly of degree 10.\n *\t\t\t\t\t\t -57.90\n *\t\t\t| R - (erf(x)-x)/x | <= 2\n *\n *\n *\t   Remark. The formula is derived by noting\n *          erf(x) = (2/sqrt(pi))*(x - x^3/3 + x^5/10 - x^7/42 + ....)\n *\t   and that\n *          2/sqrt(pi) = 1.128379167095512573896158903121545171688\n *\t   is close to one. The interval is chosen because the fix\n *\t   point of erf(x) is near 0.6174 (i.e., erf(x)=x when x is\n *\t   near 0.6174), and by some experiment, 0.84375 is chosen to\n * \t   guarantee the error is less than one ulp for erf.\n *\n *      2. For |x| in [0.84375,1.25], let s = |x| - 1, and\n *         c = 0.84506291151 rounded to single (24 bits)\n *         \terf(x)  = sign(x) * (c  + P1(s)/Q1(s))\n *         \terfc(x) = (1-c)  - P1(s)/Q1(s) if x > 0\n *\t\t\t  1+(c+P1(s)/Q1(s))    if x < 0\n *         \t|P1/Q1 - (erf(|x|)-c)| <= 2**-59.06\n *\t   Remark: here we use the taylor series expansion at x=1.\n *\t\terf(1+s) = erf(1) + s*Poly(s)\n *\t\t\t = 0.845.. + P1(s)/Q1(s)\n *\t   That is, we use rational approximation to approximate\n *\t\t\terf(1+s) - (c = (single)0.84506291151)\n *\t   Note that |P1/Q1|< 0.078 for x in [0.84375,1.25]\n *\t   where\n *\t\tP1(s) = degree 6 poly in s\n *\t\tQ1(s) = degree 6 poly in s\n *\n *      3. For x in [1.25,1/0.35(~2.857143)],\n *         \terfc(x) = (1/x)*exp(-x*x-0.5625+R1/S1)\n *         \terf(x)  = 1 - erfc(x)\n *\t   where\n *\t\tR1(z) = degree 7 poly in z, (z=1/x^2)\n *\t\tS1(z) = degree 8 poly in z\n *\n *      4. For x in [1/0.35,28]\n *         \terfc(x) = (1/x)*exp(-x*x-0.5625+R2/S2) if x > 0\n *\t\t\t= 2.0 - (1/x)*exp(-x*x-0.5625+R2/S2) if -6<x<0\n *\t\t\t= 2.0 - tiny\t\t(if x <= -6)\n *         \terf(x)  = sign(x)*(1.0 - erfc(x)) if x < 6, else\n *         \terf(x)  = sign(x)*(1.0 - tiny)\n *\t   where\n *\t\tR2(z) = degree 6 poly in z, (z=1/x^2)\n *\t\tS2(z) = degree 7 poly in z\n *\n *      Note1:\n *\t   To compute exp(-x*x-0.5625+R/S), let s be a single\n *\t   precision number and s := x; then\n *\t\t-x*x = -s*s + (s-x)*(s+x)\n *\t        exp(-x*x-0.5626+R/S) =\n *\t\t\texp(-s*s-0.5625)*exp((s-x)*(s+x)+R/S);\n *      Note2:\n *\t   Here 4 and 5 make use of the asymptotic series\n *\t\t\t  exp(-x*x)\n *\t\terfc(x) ~ ---------- * ( 1 + Poly(1/x^2) )\n *\t\t\t  x*sqrt(pi)\n *\t   We use rational approximation to approximate\n *      \tg(s)=f(1/x^2) = log(erfc(x)*x) - x*x + 0.5625\n *\t   Here is the error bound for R1/S1 and R2/S2\n *      \t|R1/S1 - f(x)|  < 2**(-62.57)\n *      \t|R2/S2 - f(x)|  < 2**(-61.52)\n *\n *      5. For inf > x >= 28\n *         \terf(x)  = sign(x) *(1 - tiny)  (raise inexact)\n *         \terfc(x) = tiny*tiny (raise underflow) if x > 0\n *\t\t\t= 2 - tiny if x<0\n *\n *      7. Special case:\n *         \terf(0)  = 0, erf(inf)  = 1, erf(-inf) = -1,\n *         \terfc(0) = 1, erfc(inf) = 0, erfc(-inf) = 2,\n *\t   \terfc/erf(NaN) is NaN\n */\n\n\nstatic const double\n\ntiny =  1e-300,\nhalf =  5.00000000000000000000e-01, /* 0x3FE00000, 0x00000000 */\none  =  1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */\ntwo  =  2.00000000000000000000e+00, /* 0x40000000, 0x00000000 */\n\nerx  =  8.45062911510467529297e-01, /* 0x3FEB0AC1, 0x60000000 */\n/*\n * Coefficients for approximation to  erf on [0,0.84375]\n */\nefx  =  1.28379167095512586316e-01, /* 0x3FC06EBA, 0x8214DB69 */\nefx8 =  1.02703333676410069053e+00, /* 0x3FF06EBA, 0x8214DB69 */\npp0  =  1.28379167095512558561e-01, /* 0x3FC06EBA, 0x8214DB68 */\npp1  = -3.25042107247001499370e-01, /* 0xBFD4CD7D, 0x691CB913 */\npp2  = -2.84817495755985104766e-02, /* 0xBF9D2A51, 0xDBD7194F */\npp3  = -5.77027029648944159157e-03, /* 0xBF77A291, 0x236668E4 */\npp4  = -2.37630166566501626084e-05, /* 0xBEF8EAD6, 0x120016AC */\nqq1  =  3.97917223959155352819e-01, /* 0x3FD97779, 0xCDDADC09 */\nqq2  =  6.50222499887672944485e-02, /* 0x3FB0A54C, 0x5536CEBA */\nqq3  =  5.08130628187576562776e-03, /* 0x3F74D022, 0xC4D36B0F */\nqq4  =  1.32494738004321644526e-04, /* 0x3F215DC9, 0x221C1A10 */\nqq5  = -3.96022827877536812320e-06, /* 0xBED09C43, 0x42A26120 */\n/*\n * Coefficients for approximation to  erf  in [0.84375,1.25]\n */\npa0  = -2.36211856075265944077e-03, /* 0xBF6359B8, 0xBEF77538 */\npa1  =  4.14856118683748331666e-01, /* 0x3FDA8D00, 0xAD92B34D */\npa2  = -3.72207876035701323847e-01, /* 0xBFD7D240, 0xFBB8C3F1 */\npa3  =  3.18346619901161753674e-01, /* 0x3FD45FCA, 0x805120E4 */\npa4  = -1.10894694282396677476e-01, /* 0xBFBC6398, 0x3D3E28EC */\npa5  =  3.54783043256182359371e-02, /* 0x3FA22A36, 0x599795EB */\npa6  = -2.16637559486879084300e-03, /* 0xBF61BF38, 0x0A96073F */\nqa1  =  1.06420880400844228286e-01, /* 0x3FBB3E66, 0x18EEE323 */\nqa2  =  5.40397917702171048937e-01, /* 0x3FE14AF0, 0x92EB6F33 */\nqa3  =  7.18286544141962662868e-02, /* 0x3FB2635C, 0xD99FE9A7 */\nqa4  =  1.26171219808761642112e-01, /* 0x3FC02660, 0xE763351F */\nqa5  =  1.36370839120290507362e-02, /* 0x3F8BEDC2, 0x6B51DD1C */\nqa6  =  1.19844998467991074170e-02, /* 0x3F888B54, 0x5735151D */\n/*\n * Coefficients for approximation to  erfc in [1.25,1/0.35]\n */\nra0  = -9.86494403484714822705e-03, /* 0xBF843412, 0x600D6435 */\nra1  = -6.93858572707181764372e-01, /* 0xBFE63416, 0xE4BA7360 */\nra2  = -1.05586262253232909814e+01, /* 0xC0251E04, 0x41B0E726 */\nra3  = -6.23753324503260060396e+01, /* 0xC04F300A, 0xE4CBA38D */\nra4  = -1.62396669462573470355e+02, /* 0xC0644CB1, 0x84282266 */\nra5  = -1.84605092906711035994e+02, /* 0xC067135C, 0xEBCCABB2 */\nra6  = -8.12874355063065934246e+01, /* 0xC0545265, 0x57E4D2F2 */\nra7  = -9.81432934416914548592e+00, /* 0xC023A0EF, 0xC69AC25C */\nsa1  =  1.96512716674392571292e+01, /* 0x4033A6B9, 0xBD707687 */\nsa2  =  1.37657754143519042600e+02, /* 0x4061350C, 0x526AE721 */\nsa3  =  4.34565877475229228821e+02, /* 0x407B290D, 0xD58A1A71 */\nsa4  =  6.45387271733267880336e+02, /* 0x40842B19, 0x21EC2868 */\nsa5  =  4.29008140027567833386e+02, /* 0x407AD021, 0x57700314 */\nsa6  =  1.08635005541779435134e+02, /* 0x405B28A3, 0xEE48AE2C */\nsa7  =  6.57024977031928170135e+00, /* 0x401A47EF, 0x8E484A93 */\nsa8  = -6.04244152148580987438e-02, /* 0xBFAEEFF2, 0xEE749A62 */\n/*\n * Coefficients for approximation to  erfc in [1/.35,28]\n */\nrb0  = -9.86494292470009928597e-03, /* 0xBF843412, 0x39E86F4A */\nrb1  = -7.99283237680523006574e-01, /* 0xBFE993BA, 0x70C285DE */\nrb2  = -1.77579549177547519889e+01, /* 0xC031C209, 0x555F995A */\nrb3  = -1.60636384855821916062e+02, /* 0xC064145D, 0x43C5ED98 */\nrb4  = -6.37566443368389627722e+02, /* 0xC083EC88, 0x1375F228 */\nrb5  = -1.02509513161107724954e+03, /* 0xC0900461, 0x6A2E5992 */\nrb6  = -4.83519191608651397019e+02, /* 0xC07E384E, 0x9BDC383F */\nsb1  =  3.03380607434824582924e+01, /* 0x403E568B, 0x261D5190 */\nsb2  =  3.25792512996573918826e+02, /* 0x40745CAE, 0x221B9F0A */\nsb3  =  1.53672958608443695994e+03, /* 0x409802EB, 0x189D5118 */\nsb4  =  3.19985821950859553908e+03, /* 0x40A8FFB7, 0x688C246A */\nsb5  =  2.55305040643316442583e+03, /* 0x40A3F219, 0xCEDF3BE6 */\nsb6  =  4.74528541206955367215e+02, /* 0x407DA874, 0xE79FE763 */\nsb7  = -2.24409524465858183362e+01; /* 0xC03670E2, 0x42712D62 */\n\nstatic double ighmm_erf (double x) {\n  double R,S,P,Q,s,y,z,r;\n  double ax = fabs(x);\n#ifdef HAVE_IEEE754\n  if (!isfinite(x)) {\n    if (isnan(x)) return x;     /* erf(nan)=nan */\n    return (x==ax) ? 1 : -1;\t/* erf(+-inf)=+-1 */\n  }\n#endif\n  if (ax < 0.84375) {\t\t/* |x|<0.84375 */\n    if (ax < 3.7252903e-9) { \t/* |x|<2**-28 */\n      if (ax < tiny)\n\treturn 0.125*(8.0*x+efx8*x);  /*avoid underflow */\n      return x + efx*x;\n    }\n    z = x*x;\n    r = pp0+z*(pp1+z*(pp2+z*(pp3+z*pp4)));\n    s = one+z*(qq1+z*(qq2+z*(qq3+z*(qq4+z*qq5))));\n    y = r/s;\n    return x + x*y;\n  }\n  if (ax < 1.25) {\t\t\t/* 0.84375 <= |x| < 1.25 */\n    s = ax-one;\n    P = pa0+s*(pa1+s*(pa2+s*(pa3+s*(pa4+s*(pa5+s*pa6)))));\n    Q = one+s*(qa1+s*(qa2+s*(qa3+s*(qa4+s*(qa5+s*qa6)))));\n    if (x>=0) return erx + P/Q;\n    else return -erx - P/Q;\n  }\n  if (ax >= 6.0) {\t\t/* inf>|x|>=6 */\n    if (x>=0) return one-tiny;\n    else return tiny-one;\n  }\n  s = one/(x*x);\n  if (ax < 2.857142857) {\t/* |x| < 1/0.35 */\n    R=ra0+s*(ra1+s*(ra2+s*(ra3+s*(ra4+s*(ra5+s*(ra6+s*ra7))))));\n    S=one+s*(sa1+s*(sa2+s*(sa3+s*(sa4+s*(sa5+s*(sa6+s*(sa7+s*sa8)))))));\n  }\n  else {\t\t/* |x| >= 1/0.35 */\n    R=rb0+s*(rb1+s*(rb2+s*(rb3+s*(rb4+s*(rb5+s*rb6)))));\n    S=one+s*(sb1+s*(sb2+s*(sb3+s*(sb4+s*(sb5+s*(sb6+s*sb7))))));\n  }\n  z  = (double)(float) ax;\n  r  = exp(-z*z-0.5625)*exp((z-ax)*(z+ax)+R/S);\n  if (x>=0) return one-r/ax;\n  else return  r/ax-one;\n}\n\nstatic double ighmm_erfc (double x) {\n  double R,S,P,Q,s,y,z,r;\n  double ax = fabs(x);\n#ifdef HAVE_IEEE754\n  if (!isfinite(x)) {\n    if (isnan(x)) return x;     /* erfc(nan)=nan */\n    return (x==ax) ? 0 : 2;\t/* erfc(+-inf)=0,2 */\n  }\n#endif\n  if (ax < 0.84375) {\t\t/* |x|<0.84375 */\n    if (ax < 13.8777878e-18)  \t/* |x|<2**-56 */\n      return one-x;\n    z = x*x;\n    r = pp0+z*(pp1+z*(pp2+z*(pp3+z*pp4)));\n    s = one+z*(qq1+z*(qq2+z*(qq3+z*(qq4+z*qq5))));\n    y = r/s;\n    if (ax < 0.25) {  \t\t/* x<1/4 */\n      return one-(x+x*y);\n    }\n    else {\n      r = x*y;\n      r += (x-half);\n      return half - r ;\n    }\n  }\n  if (ax < 1.25) {\t\t\t/* 0.84375 <= |x| < 1.25 */\n    s = fabs(x)-one;\n    P = pa0+s*(pa1+s*(pa2+s*(pa3+s*(pa4+s*(pa5+s*pa6)))));\n    Q = one+s*(qa1+s*(qa2+s*(qa3+s*(qa4+s*(qa5+s*qa6)))));\n    if (x>=0) {\n      z  = one-erx; return z - P/Q;\n    }\n    else {\n      z = erx+P/Q; return one+z;\n    }\n  }\n  if (ax < 28.0) {\t\t/* |x|<28 */\n    s = one/(x*x);\n    if (ax < 2.857142857) {\t/* |x| < 1/.35 ~ 2.857143*/\n      R=ra0+s*(ra1+s*(ra2+s*(ra3+s*(ra4+s*(ra5+s*(ra6+s*ra7))))));\n      S=one+s*(sa1+s*(sa2+s*(sa3+s*(sa4+s*(sa5+s*(sa6+s*(sa7+s*sa8)))))));\n    }\n    else {\t\t\t/* |x| >= 1/.35 ~ 2.857143 */\n      if (x < -6.0) return two-tiny;/* x < -6 */\n      R=rb0+s*(rb1+s*(rb2+s*(rb3+s*(rb4+s*(rb5+s*rb6)))));\n      S=one+s*(sb1+s*(sb2+s*(sb3+s*(sb4+s*(sb5+s*(sb6+s*sb7))))));\n    }\n    z  = (double)(float) ax;\n    r  = exp(-z*z-0.5625)*exp((z-ax)*(z+ax)+R/S);\n    if (x>0) return r/ax;\n    else return two-r/ax;\n  }\n  else {\n    if(x>0) return tiny*tiny;\n    else return two-tiny;\n  }\n}\n#endif /* check for ISO C99 */\n", "meta": {"hexsha": "e56b71e01e7135d101c35b16089a28c183c38051", "size": 33412, "ext": "c", "lang": "C", "max_stars_repo_path": "Trash/sandbox/hmm/ghmm-0.9-rc3/ghmm/randvar.c", "max_stars_repo_name": "ruslankuzmin/julia", "max_stars_repo_head_hexsha": "2ad5bfb9c9684b1c800e96732a9e2f1e844b856f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 7.0, "max_stars_repo_stars_event_min_datetime": "2017-03-13T17:32:26.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-27T16:51:22.000Z", "max_issues_repo_path": "Trash/sandbox/hmm/ghmm-0.9-rc3/ghmm/randvar.c", "max_issues_repo_name": "ruslankuzmin/julia", "max_issues_repo_head_hexsha": "2ad5bfb9c9684b1c800e96732a9e2f1e844b856f", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-05-29T19:54:02.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-29T19:54:52.000Z", "max_forks_repo_path": "Trash/sandbox/hmm/ghmm-0.9-rc3/ghmm/randvar.c", "max_forks_repo_name": "ruslankuzmin/julia", "max_forks_repo_head_hexsha": "2ad5bfb9c9684b1c800e96732a9e2f1e844b856f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 25.0, "max_forks_repo_forks_event_min_datetime": "2016-10-18T03:31:44.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-29T13:23:10.000Z", "avg_line_length": 30.7944700461, "max_line_length": 118, "alphanum_fraction": 0.5614150605, "num_tokens": 11645, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48047869292635403, "lm_q2_score": 0.06097517531917227, "lm_q1q2_score": 0.029297272538311176}}
{"text": "/*\r\n * Copyright (c) 2016-2021 lymastee, All rights reserved.\r\n * Contact: lymastee@hotmail.com\r\n *\r\n * This file is part of the gslib project.\r\n * \r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n * \r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n * \r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\n\r\n#pragma once\r\n\r\n#ifndef type_3f1a28e2_0da6_44b6_84db_29542f5a65c0_h\r\n#define type_3f1a28e2_0da6_44b6_84db_29542f5a65c0_h\r\n\r\n#include <utility>\r\n#include <gslib/basetype.h>\r\n#include <gslib/math.h>\r\n\r\n__gslib_begin__\r\n\r\ntemplate<class _ty, class _protopt>\r\nstruct point_t:\r\n    public _protopt\r\n{\r\n    typedef _ty type;\r\n    typedef _protopt proto;\r\n    typedef point_t<_ty, _protopt> myref;\r\n\r\npublic:\r\n    point_t() { this->x = 0; this->y = 0; }\r\n    point_t(const proto& p): proto(p) {}\r\n    point_t(type a, type b) { this->x = a; this->y = b; }\r\n    void offset(type u, type v) { this->x += u; this->y += v; }\r\n    void offset(const proto& p) { this->x += p.x; this->y += p.y; }\r\n    void set_point(type a, type b) { this->x = a; this->y = b; }\r\n    bool operator == (const myref& that) const { return this->x == that.x && this->y == that.y; }\r\n    bool operator != (const myref& that) const { return this->x != that.x || this->y != that.y; }\r\n};\r\n\r\nstruct vec2i { int x, y; };\r\ntypedef point_t<int, vec2i> point;\r\ntypedef point_t<float, vec2> pointf;\r\n\r\ntemplate<class _ty, class _ptcls>\r\nstruct rect_t\r\n{\r\n    typedef _ty type;\r\n    typedef rect_t<_ty, _ptcls> myref;\r\n    typedef _ptcls point;\r\n\r\npublic:\r\n    type    left, top, right, bottom;\r\n\r\npublic:\r\n    rect_t()\r\n    {\r\n        left = 0;\r\n        top = 0;\r\n        right = 0;\r\n        bottom = 0;\r\n    }\r\n    rect_t(type l, type t, type w, type h) { set_rect(l, t, w, h); }\r\n    type width() const { return right - left; }\r\n    type height() const { return bottom - top; }\r\n    void set_rect(type l, type t, type w, type h)\r\n    {\r\n        left = l;\r\n        top = t;\r\n        right = l + w;\r\n        bottom = t + h;\r\n    }\r\n    void set_ltrb(type l, type t, type r, type b)\r\n    {\r\n        left = l;\r\n        top = t;\r\n        right = r;\r\n        bottom = b;\r\n    }\r\n    void set_by_pts(const point& p1, const point& p2)\r\n    {\r\n        left = gs_min(p1.x, p2.x);\r\n        top = gs_min(p1.y, p2.y);\r\n        right = gs_max(p1.x, p2.x);\r\n        bottom = gs_max(p1.y, p2.y);\r\n    }\r\n    bool in_rect(const point& pt) const { return pt.x >= left && pt.x < right && pt.y >= top && pt.y < bottom; }\r\n    void offset(type x, type y) { left += x; right += x; top += y; bottom += y; }\r\n    void deflate(type u, type v);\r\n    void move_to(const point& pt) { move_to(pt.x, pt.y); }\r\n    void move_to(type x, type y);\r\n    bool operator == (const myref& that) const { return left == that.left && right == that.right && top == that.top && bottom == that.bottom; }\r\n    bool operator != (const myref& that) const { return left != that.left || right != that.right || top != that.top || bottom != that.bottom; }\r\n    type area() const { return width() * height(); }\r\n    point center() const\r\n    {\r\n        point c;\r\n        c.x = (left + right) / 2;\r\n        c.y = (top + bottom) / 2;\r\n        return c;\r\n    }\r\n    point top_left() const { return point(left, top); }\r\n    point top_right() const { return point(right, top); }\r\n    point bottom_left() const { return point(left, bottom); }\r\n    point bottom_right() const { return point(right, bottom); }\r\n};\r\n\r\ntypedef rect_t<int, point> rect;\r\ntypedef rect_t<float, pointf> rectf;\r\n\r\ninline rectf to_rectf(const rect& rc)\r\n{\r\n    return std::move(rectf((float)rc.left, (float)rc.top, (float)rc.width(), (float)rc.height()));\r\n}\r\n\r\ninline rect to_aligned_rect(const rectf& rc)\r\n{\r\n    return std::move(rect(round(rc.left), round(rc.top), round(rc.width()), round(rc.height())));\r\n}\r\n\r\ngs_export extern bool intersect_rect(rect& rc, const rect& rc1, const rect& rc2);\r\ngs_export extern bool is_rect_intersected(const rect& rc1, const rect& rc2);\r\ngs_export extern void union_rect(rect& rc, const rect& rc1, const rect& rc2);\r\ngs_export extern bool substract_rect(rect& rc, const rect& rc1, const rect& rc2);\r\ngs_export extern bool intersect_rect(rectf& rc, const rectf& rc1, const rectf& rc2);\r\ngs_export extern bool is_rect_intersected(const rectf& rc1, const rectf& rc2);\r\ngs_export extern bool is_rect_contained(const rect& rc1, const rect& rc2);\r\ngs_export extern bool is_rect_contained(const rectf& rc1, const rectf& rc2);\r\ngs_export extern void union_rect(rectf& rc, const rectf& rc1, const rectf& rc2);\r\ngs_export extern bool substract_rect(rectf& rc, const rectf& rc1, const rectf& rc2);\r\ngs_export extern bool is_line_rect_overlapped(const point& p1, const point& p2, const rect& rc);\r\ngs_export extern bool is_line_rect_overlapped(const pointf& p1, const pointf& p2, const rectf& rc);\r\n\r\n__gslib_end__\r\n\r\n#endif\r\n", "meta": {"hexsha": "46174f5fa068275d52a85c8ffc77be91f6045a3c", "size": 5773, "ext": "h", "lang": "C", "max_stars_repo_path": "include/gslib/type.h", "max_stars_repo_name": "lymastee/gslib", "max_stars_repo_head_hexsha": "1b165b7a812526c4b2a3179588df9a7c2ff602a6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 9.0, "max_stars_repo_stars_event_min_datetime": "2016-10-18T09:40:09.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-11T09:44:51.000Z", "max_issues_repo_path": "include/gslib/type.h", "max_issues_repo_name": "lymastee/gslib", "max_issues_repo_head_hexsha": "1b165b7a812526c4b2a3179588df9a7c2ff602a6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/gslib/type.h", "max_forks_repo_name": "lymastee/gslib", "max_forks_repo_head_hexsha": "1b165b7a812526c4b2a3179588df9a7c2ff602a6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2016-10-19T15:20:58.000Z", "max_forks_repo_forks_event_max_datetime": "2016-10-19T15:20:58.000Z", "avg_line_length": 37.9802631579, "max_line_length": 144, "alphanum_fraction": 0.6429932444, "num_tokens": 1601, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4416729909662417, "lm_q2_score": 0.06465348520228963, "lm_q1q2_score": 0.028555698185686908}}
{"text": "/*\r\nThis file is a part of NNTL project (https://github.com/Arech/nntl)\r\n\r\nCopyright (c) 2015-2021, Arech (aradvert@gmail.com; https://github.com/Arech)\r\nAll rights reserved.\r\n\r\nRedistribution and use in source and binary forms, with or without\r\nmodification, are permitted provided that the following conditions are met:\r\n\r\n* Redistributions of source code must retain the above copyright notice, this\r\n  list of conditions and the following disclaimer.\r\n\r\n* Redistributions in binary form must reproduce the above copyright notice,\r\n  this list of conditions and the following disclaimer in the documentation\r\n  and/or other materials provided with the distribution.\r\n\r\n* Neither the name of NNTL nor the names of its\r\n  contributors may be used to endorse or promote products derived from\r\n  this software without specific prior written permission.\r\n\r\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\r\nAND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r\nIMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r\nDISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\r\nFOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r\nDAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\r\nSERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\r\nCAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\r\nOR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r\nOF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r\n*/\r\n#pragma once\r\n\r\n#include <cblas.h>\r\n//TODO: function definitions (like dgemm()) conflicts with similar function definitions in ACML. It builds successfully, but\r\n//links to wrong library and access violation happens in run-time.\r\n\r\n#include <complex>\r\n#define lapack_complex_float ::std::complex<float>\r\n#define lapack_complex_double ::std::complex<double>\r\n#include <lapacke.h>\r\n\r\n//#include \"../../../utils/denormal_floats.h\"\r\n\r\n#pragma comment(lib,\"libopenblas.dll.a\")\r\n\r\n//what else to do to use OpenBLAS:\r\n// -in the Solution's VC++ Directories property page set parameter Library Directories to point to a folder with the libopenblas.dll.a file\r\n// -copy correct libopenblas.dll and another dlls that the libopenblas.dll require to the debug/release solution's folder\r\n// -if you're going to use any calling convetion except for __cdecl, then most likely, you'll have to update function declarations\r\n//\t\twithin the cblas.h and other blas's .h files included to contain the __cdecl keyword (it's absent for some reason).\r\n//\t\tCheck the b_OpenBLAS:: methods to find out which function definitions should be changed.\r\n\r\n\r\n//http://www.christophlassner.de/using-blas-from-c-with-row-major-data.html\r\n\r\n// BTW: lda,ldb,ldc is a \"major stride\". The stride represents the distance in memory between elements in adjacent rows\r\n// (if row-major) or in adjacent columns (if column-major). This means that the stride is usually equal to the number\r\n// of rows/columns in the matrix.\r\n// Matrix A = [1 2 3]\r\n//            [4 5 6]\r\n// Row-major stores values as {1,2,3,4,5,6} Stride here is 3\r\n// Col-major stores values as {1,4,2,5,3,6} Stride here is 2\r\n// (https://www.physicsforums.com/threads/understanding-blas-dgemm-in-c.543110/)\r\n\r\n\r\n\r\nnamespace nntl {\r\nnamespace math {\r\n\r\n\t// wrapper around BLAS API. Should at least isolate from double/float differences\r\n\t// Also, we are going to use ColMajor ordering in all math libraries (most of them use it by default)\r\n\t// EXPECTING data to be in COL-MAJOR mode!\r\n\t// \r\n\t// NB: Leading dimension is the number of elements in major dimension. We're using Col-Major ordering,\r\n\t// therefore it is the number of ROWs of a matrix\r\n\tstruct b_OpenBLAS {\r\n\tprivate:\r\n\t\ttypedef utils::_scoped_restore_FPU _restoreFPU;\r\n\tpublic:\r\n\t\t//TODO: beware that sz_t type used as substitution of blasint can overflow blasint and silencing conversion warnings here can make it difficult to debug!\r\n\t\t//TODO: May be there should be some preliminary check for this condition.\r\n\r\n\t\t//////////////////////////////////////////////////////////////////////////\r\n\t\t//////////////////////////////////////////////////////////////////////////\r\n\t\t// LEVEL 1\r\n\t\t// AXPY y=a*x+y\r\n\t\ttemplate<typename sz_t, typename fl_t>\r\n\t\tstatic typename ::std::enable_if_t< ::std::is_same< ::std::remove_pointer_t<fl_t>, double>::value > axpy(\r\n\t\t\tconst sz_t n, const fl_t alpha, const fl_t *x, const sz_t incx, fl_t *y, const sz_t incy)\r\n\t\t{\r\n\t\t\t_restoreFPU r;\r\n\t\t\tcblas_daxpy(static_cast<blasint>(n), alpha, x, static_cast<blasint>(incx), y, static_cast<blasint>(incy));\r\n\t\t}\r\n\t\ttemplate<typename sz_t, typename fl_t>\r\n\t\tstatic typename ::std::enable_if_t< ::std::is_same< ::std::remove_pointer_t<fl_t>, float>::value > axpy(\r\n\t\t\tconst sz_t n, const fl_t alpha, const fl_t *x, const sz_t incx, fl_t *y, const sz_t incy)\r\n\t\t{\r\n\t\t\t_restoreFPU r;\r\n\t\t\tcblas_saxpy(static_cast<blasint>(n), alpha, x, static_cast<blasint>(incx), y, static_cast<blasint>(incy));\r\n\t\t}\r\n\r\n\t\t//////////////////////////////////////////////////////////////////////////\r\n\t\t// cblas_?dot\r\n\t\t// Computes a vector - vector dot product.\r\n\t\t//\tInput Parameters\r\n\t\t// n - Specifies the number of elements in vectors x and y.\r\n\t\t// x - Array, size at least(1 + (n - 1)*abs(incx)).\r\n\t\t// incx - Specifies the increment for the elements of x.\r\n\t\t// y - Array, size at least(1 + (n - 1)*abs(incy)).\r\n\t\t// incy - Specifies the increment for the elements of y.\r\n\t\t// Return Values - The result of the dot product of x and y, if n is positive.Otherwise, returns 0.\r\n\t\t//https://software.intel.com/en-us/mkl-developer-reference-c-cblas-dot\r\n\t\ttemplate<typename sz_t, typename fl_t>\r\n\t\tstatic typename ::std::enable_if_t< ::std::is_same< ::std::remove_pointer_t<fl_t>, double>::value, double >\r\n\t\t\tdot(const sz_t n, const fl_t *x, const sz_t incx, const fl_t *y, const sz_t incy)\r\n\t\t{\r\n\t\t\t_restoreFPU r;\r\n\t\t\treturn cblas_ddot(static_cast<blasint>(n), x, static_cast<blasint>(incx), y, static_cast<blasint>(incy));\r\n\t\t}\r\n\t\ttemplate<typename sz_t, typename fl_t>\r\n\t\tstatic typename ::std::enable_if_t< ::std::is_same< ::std::remove_pointer_t<fl_t>, float>::value, float >\r\n\t\t\tdot(const sz_t n, const fl_t *x, const sz_t incx, const fl_t *y, const sz_t incy)\r\n\t\t{\r\n\t\t\t_restoreFPU r;\r\n\t\t\treturn cblas_sdot(static_cast<blasint>(n), x, static_cast<blasint>(incx), y, static_cast<blasint>(incy));\r\n\t\t}\r\n\r\n\r\n\t\t//////////////////////////////////////////////////////////////////////////\r\n\t\t//////////////////////////////////////////////////////////////////////////\r\n\t\t// LEVEL 2\r\n\r\n\t\t\r\n\t\t//////////////////////////////////////////////////////////////////////////\r\n\t\t//////////////////////////////////////////////////////////////////////////\r\n\t\t// LEVEL 3\r\n\t\t// \r\n\t\t//////////////////////////////////////////////////////////////////////////\r\n\t\t// General matrix multiplication\r\n\t\t// GEMM C := alpha*op(A)*op(B) + beta*C\r\n\t\t// https://software.intel.com/en-us/node/520775\r\n\t\t// where:\r\n\t\t// op(X) is one of op(X) = X, or op(X) = XT, or op(X) = XH,\r\n\t\t// alpha and beta are scalars,\r\n\t\t// A, B and C are matrices :\r\n\t\t// op(A) is an m - by - k matrix,\r\n\t\t// op(B) is a k - by - n matrix,\r\n\t\t// C is an m - by - n matrix.\r\n\t\t// \r\n\t\t// M - Specifies the number of rows of the matrix op(A) and of the matrix C. The value of m must be at least zero.\r\n\t\t// N - Specifies the number of columns of the matrix op(B) and the number of columns of the matrix C. The value of n must be at least zero.\r\n\t\t// K - Specifies the number of columns of the matrix op(A) and the number of rows of the matrix op(B). The value of k must be at least zero.\r\n\t\t// A - {transa=CblasNoTrans : Array, size lda*k. Before entry, the leading m-by-k part of the array a must contain the matrix A.\r\n\t\t//\t\ttransa=CblasTrans : Array, size lda*m. Before entry, the leading k-by-m part of the array a must contain the matrix A.}\r\n\t\t// lda - Specifies the leading dimension of A as declared in the calling (sub)program.\r\n\t\t//\t\t{transa=CblasNoTrans, lda must be at least max(1, m).\r\n\t\t//\t\ttransa=CblasTrans, lda must be at least max(1, k)}\r\n\t\t// B - {transb=CblasNoTrans : Array, size ldb by n. Before entry, the leading k-by-n part of the array b must contain the matrix B.\r\n\t\t//\t\ttransb=CblasTrans : Array, size ldb by k. Before entry the leading n-by-k part of the array b must contain the matrix B.}\r\n\t\t// ldb - Specifies the leading dimension of B as declared in the calling (sub)program.\r\n\t\t//\t\t{transb = CblasNoTrans : ldb must be at least max(1, k).\r\n\t\t//\t\ttransb=CblasTrans : ldb must be at least max(1, n).}\r\n\t\t// C - Array, size ldc by n. Before entry, the leading m-by-n part of the array c must contain the matrix C, except when beta is\r\n\t\t//\t\tequal to zero, in which case c need not be set on entry.\r\n\t\t// ldc - Specifies the leading dimension of c as declared in the calling (sub)program. ldc must be at least max(1, m).\r\n\t\ttemplate<typename sz_t, typename fl_t>\r\n\t\tstatic typename ::std::enable_if_t< ::std::is_same< ::std::remove_pointer_t<fl_t>, double>::value >\r\n\t\t\tgemm( //const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB,\r\n\t\t\tconst bool bTransposeA, const bool bTransposeB,\r\n\t\t\tconst sz_t M, const sz_t N, const sz_t K, const fl_t alpha, const fl_t *A, const sz_t lda,\r\n\t\t\tconst fl_t *B, const sz_t ldb, const fl_t beta, fl_t *C, const sz_t ldc)\r\n\t\t{\r\n\t\t\t_restoreFPU r;\r\n\t\t\tcblas_dgemm(CblasColMajor, bTransposeA ? CblasTrans : CblasNoTrans, bTransposeB ? CblasTrans : CblasNoTrans,\r\n\t\t\t\tstatic_cast<blasint>(M), static_cast<blasint>(N), static_cast<blasint>(K),\r\n\t\t\t\talpha, A, static_cast<blasint>(lda), B, static_cast<blasint>(ldb), beta, C, static_cast<blasint>(ldc));\r\n\t\t\t//global_denormalized_floats_mode();\r\n\t\t}\r\n\t\ttemplate<typename sz_t, typename fl_t>\r\n\t\tstatic typename ::std::enable_if_t< ::std::is_same< ::std::remove_pointer_t<fl_t>, float>::value >\r\n\t\t\tgemm( //const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB,\r\n\t\t\tconst bool bTransposeA, const bool bTransposeB,\r\n\t\t\tconst sz_t M, const sz_t N, const sz_t K, const fl_t alpha, const fl_t *A, const sz_t lda,\r\n\t\t\tconst fl_t *B, const sz_t ldb, const fl_t beta, fl_t *C, const sz_t ldc)\r\n\t\t{\r\n\t\t\t_restoreFPU r;\r\n\t\t\tcblas_sgemm(CblasColMajor, bTransposeA ? CblasTrans: CblasNoTrans, bTransposeB ? CblasTrans : CblasNoTrans,\r\n\t\t\t\tstatic_cast<blasint>(M), static_cast<blasint>(N), static_cast<blasint>(K),\r\n\t\t\t\talpha, A, static_cast<blasint>(lda), B, static_cast<blasint>(ldb), beta, C, static_cast<blasint>(ldc));\r\n\t\t\t//global_denormalized_floats_mode();\r\n\t\t}\r\n\r\n\t\t//////////////////////////////////////////////////////////////////////////\r\n\t\t// cblas_?syrk, https://software.intel.com/en-us/node/520780\r\n\t\t// Performs a symmetric rank-k update.\r\n\t\t// The ?syrk routines perform a rank-k matrix-matrix operation for a symmetric matrix C using a general matrix A.\r\n\t\t// The operation is defined as:\r\n\t\t// C := alpha*A*A' + beta*C,\r\n\t\t//\t\tor\r\n\t\t// C : = alpha*A'*A + beta*C,\r\n\t\t// where :\r\n\t\t//\t\talpha and beta are scalars,\r\n\t\t//\t\tC is an n-by-n symmetric matrix,\r\n\t\t//\t\tA is an n-by-k matrix in the first case and a k-by-n matrix in the second case.\r\n\t\ttemplate<typename sz_t, typename fl_t>\r\n\t\tstatic typename ::std::enable_if_t< ::std::is_same< ::std::remove_pointer_t<fl_t>, double>::value >\r\n\t\t\tsyrk( const bool bCLowerTriangl, const bool bFirstATransposed, const sz_t N, const sz_t K, const fl_t alpha\r\n\t\t\t\t, const fl_t *A, const sz_t lda, const fl_t beta, fl_t *C, const sz_t ldc)\r\n\t\t{\r\n\t\t\t_restoreFPU r;\r\n\t\t\tcblas_dsyrk(CblasColMajor, bCLowerTriangl ? CblasLower : CblasUpper, bFirstATransposed ? CblasTrans : CblasNoTrans\r\n\t\t\t\t, static_cast<blasint>(N), static_cast<blasint>(K), alpha, A, static_cast<blasint>(lda), beta, C, static_cast<blasint>(ldc));\r\n\t\t\t//global_denormalized_floats_mode();\r\n\t\t}\r\n\t\ttemplate<typename sz_t, typename fl_t>\r\n\t\tstatic typename ::std::enable_if_t< ::std::is_same< ::std::remove_pointer_t<fl_t>, float>::value >\r\n\t\t\tsyrk(const bool bCLowerTriangl, const bool bFirstATransposed, const sz_t N, const sz_t K, const fl_t alpha\r\n\t\t\t\t, const fl_t *A, const sz_t lda, const fl_t beta, fl_t *C, const sz_t ldc)\r\n\t\t{\r\n\t\t\t_restoreFPU r;\r\n\t\t\tcblas_ssyrk(CblasColMajor, bCLowerTriangl ? CblasLower : CblasUpper, bFirstATransposed ? CblasTrans : CblasNoTrans\r\n\t\t\t\t, static_cast<blasint>(N), static_cast<blasint>(K), alpha, A, static_cast<blasint>(lda), beta, C, static_cast<blasint>(ldc));\r\n\t\t\t//global_denormalized_floats_mode();\r\n\t\t}\r\n\r\n\t\t//////////////////////////////////////////////////////////////////////////\r\n\t\t// cblas_?symm, https://software.intel.com/en-us/node/520779\r\n\t\t// Computes a matrix - matrix product where one input matrix is symmetric.\r\n\t\t// The ?symm routines compute a scalar-matrix-matrix product with one symmetric matrix and add the\r\n\t\t// result to a scalar-matrix product. The operation is defined as\r\n\t\t// C: = alpha*A*B + beta*C,\r\n\t\t//\t\tor\r\n\t\t// C : = alpha*B*A + beta*C,\r\n\t\t// where :\r\n\t\t//\t\talpha and beta are scalars,\r\n\t\t//\t\tA is a symmetric matrix,\r\n\t\t//\t\tB and C are m - by - n matrices.\r\n\t\ttemplate<typename sz_t, typename fl_t>\r\n\t\tstatic typename ::std::enable_if_t< ::std::is_same< ::std::remove_pointer_t<fl_t>, double>::value >\r\n\t\t\tsymm(const bool bSymmAatLeft, const bool bALowerTriangl, const sz_t M, const sz_t N, const fl_t alpha\r\n\t\t\t\t, const fl_t *A, const sz_t lda, const fl_t *B, const sz_t ldb, const fl_t beta, fl_t *C, const sz_t ldc)\r\n\t\t{\r\n\t\t\t_restoreFPU r;\r\n\t\t\tcblas_dsymm(CblasColMajor, bSymmAatLeft ? CblasLeft : CblasRight, bALowerTriangl ? CblasLower : CblasUpper\r\n\t\t\t\t, static_cast<blasint>(M), static_cast<blasint>(N), alpha, A, static_cast<blasint>(lda)\r\n\t\t\t\t, B, static_cast<blasint>(ldb), beta, C, static_cast<blasint>(ldc));\r\n\t\t\t//global_denormalized_floats_mode();\r\n\t\t}\r\n\t\ttemplate<typename sz_t, typename fl_t>\r\n\t\tstatic typename ::std::enable_if_t< ::std::is_same< ::std::remove_pointer_t<fl_t>, float>::value >\r\n\t\t\tsymm(const bool bSymmAatLeft, const bool bALowerTriangl, const sz_t M, const sz_t N, const fl_t alpha\r\n\t\t\t\t, const fl_t *A, const sz_t lda, const fl_t *B, const sz_t ldb, const fl_t beta, fl_t *C, const sz_t ldc)\r\n\t\t{\r\n\t\t\t_restoreFPU r;\r\n\t\t\tcblas_ssymm(CblasColMajor, bSymmAatLeft ? CblasLeft : CblasRight, bALowerTriangl ? CblasLower : CblasUpper\r\n\t\t\t\t, static_cast<blasint>(M), static_cast<blasint>(N), alpha, A, static_cast<blasint>(lda)\r\n\t\t\t\t, B, static_cast<blasint>(ldb), beta, C, static_cast<blasint>(ldc));\r\n\t\t\t//global_denormalized_floats_mode();\r\n\t\t}\r\n\r\n\r\n\t\t//////////////////////////////////////////////////////////////////////////\r\n\t\t//////////////////////////////////////////////////////////////////////////\r\n\t\t// LAPACKE\r\n\r\n\t\t// ?gesvd\r\n\t\t// https://software.intel.com/en-us/node/521150\r\n\t\ttemplate<typename sz_t, typename fl_t>\r\n\t\tstatic typename ::std::enable_if_t< ::std::is_same< ::std::remove_pointer_t<fl_t>, double>::value, int>\r\n\t\t\tgesvd(/*int matrix_layout,*/ const char jobu, const char jobvt,\r\n\t\t\t\tconst sz_t m, const sz_t n, fl_t* A,\r\n\t\t\t\tconst sz_t lda, fl_t* S, fl_t* U, const sz_t ldu,\r\n\t\t\t\tfl_t* Vt, const sz_t ldvt, fl_t* superb)\r\n\t\t{\r\n\t\t\t_restoreFPU r;\r\n\t\t\treturn static_cast<int>(LAPACKE_dgesvd(LAPACK_COL_MAJOR, jobu, jobvt, static_cast<lapack_int>(m), static_cast<lapack_int>(n)\r\n\t\t\t\t, A, static_cast<lapack_int>(lda), S, U, static_cast<lapack_int>(ldu), Vt, static_cast<lapack_int>(ldvt), superb));\r\n\t\t}\r\n\t\ttemplate<typename sz_t, typename fl_t>\r\n\t\tstatic typename ::std::enable_if_t< ::std::is_same< ::std::remove_pointer_t<fl_t>, float>::value, int>\r\n\t\t\tgesvd(/*int matrix_layout,*/ const char jobu, const char jobvt,\r\n\t\t\t\tconst sz_t m, const sz_t n, fl_t* A,\r\n\t\t\t\tconst sz_t lda, fl_t* S, fl_t* U, const sz_t ldu,\r\n\t\t\t\tfl_t* Vt, const sz_t ldvt, fl_t* superb)\r\n\t\t{\r\n\t\t\t_restoreFPU r;\r\n\t\t\treturn static_cast<int>(LAPACKE_sgesvd(LAPACK_COL_MAJOR, jobu, jobvt, static_cast<lapack_int>(m), static_cast<lapack_int>(n)\r\n\t\t\t\t, A, static_cast<lapack_int>(lda), S, U, static_cast<lapack_int>(ldu), Vt, static_cast<lapack_int>(ldvt), superb));\r\n\t\t}\r\n\r\n\r\n\t\t//////////////////////////////////////////////////////////////////////////\r\n\t\t//////////////////////////////////////////////////////////////////////////\r\n\t\t// Extensions\r\n\r\n\t\t// The omatcopy routine performs scaling and out-of-place transposition/copying of matrices. A transposition \r\n\t\t// operation can be a normal matrix copy, a transposition, a conjugate transposition, or just a conjugation.\r\n\t\t// The operation is defined as follows:\r\n\t\t// B : = alpha*op(A)\r\n\t\t// \r\n\t\t// Parameters\r\n\t\t// rows - The number of rows in the source matrix.\r\n\t\t// cols - The number of columns in the source matrix.\r\n\t\t// alpha - This parameter scales the input matrix by alpha.\r\n\t\t// pA - Array.\r\n\t\t// lda - Distance between the first elements in adjacent columns(in the case of the column - major order)\r\n\t\t//\t\tor rows(in the case of the row - major order) in the source matrix; measured in the number of elements.\r\n\t\t//\t\tThis parameter must be at least max(1, rows) if ordering = 'C' or 'c', and max(1, cols) otherwise.\r\n\t\t// b - Array.\r\n\t\t// ldb - Distance between the first elements in adjacent columns(in the case of the column - major order)\r\n\t\t//\t\tor rows(in the case of the row - major order) in the destination matrix; measured in the number of elements.\r\n\t\t//\t\tTo determine the minimum value of ldb on output, consider the following guideline :\r\n\t\t//\t\tIf ordering = 'C' or 'c', then\r\n\t\t//\t\t\tIf trans = 'T' or 't' or 'C' or 'c', this parameter must be at least max(1, cols)\r\n\t\t//\t\t\tIf trans = 'N' or 'n' or 'R' or 'r', this parameter must be at least max(1, rows)\r\n\t\t//\t\tIf ordering = 'R' or 'r', then\r\n\t\t//\t\t\tIf trans = 'T' or 't' or 'C' or 'c', this parameter must be at least max(1, rows)\r\n\t\t//\t\t\tIf trans = 'N' or 'n' or 'R' or 'r', this parameter must be at least max(1, cols)\r\n\t\t//\r\n\t\t// #warning current OpenBLAS implementation is slower, than it can be. See TEST(TestPerfDecisions, mTranspose) in test_perf_decisions.cpp\r\n\t\t//and https://github.com/xianyi/OpenBLAS/issues/1243\r\n\t\t// https://github.com/xianyi/OpenBLAS/issues/2532\r\n\t\t// https://stackoverflow.com/questions/16737298/what-is-the-fastest-way-to-transpose-a-matrix-in-c/16743203#16743203\r\n\t\ttemplate<typename sz_t, typename fl_t>\r\n\t\tstatic typename ::std::enable_if_t< ::std::is_same< ::std::remove_pointer_t<fl_t>, double>::value >\r\n\t\t\tomatcopy(const bool bTranspose, const sz_t rows, const sz_t cols, const fl_t alpha,\r\n\t\t\t\tconst fl_t* pA, const sz_t lda, fl_t* pB, const sz_t ldb)\r\n\t\t{\r\n\t\t\t_restoreFPU r;\r\n\t\t\tcblas_domatcopy(CblasColMajor, bTranspose ? CblasTrans : CblasNoTrans,\r\n\t\t\t\tstatic_cast<blasint>(rows), static_cast<blasint>(cols), alpha,\r\n\t\t\t\tpA, static_cast<blasint>(lda), pB, static_cast<blasint>(ldb));\r\n\t\t}\r\n\t\ttemplate<typename sz_t, typename fl_t>\r\n\t\tstatic typename ::std::enable_if_t< ::std::is_same< ::std::remove_pointer_t<fl_t>, float>::value >\r\n\t\t\tomatcopy(const bool bTranspose, const sz_t rows, const sz_t cols, const fl_t alpha,\r\n\t\t\t\tconst fl_t* pA, const sz_t lda, fl_t* pB, const sz_t ldb)\r\n\t\t{\r\n\t\t\t_restoreFPU r;\r\n\t\t\tcblas_somatcopy(CblasColMajor, bTranspose ? CblasTrans : CblasNoTrans,\r\n\t\t\t\tstatic_cast<blasint>(rows), static_cast<blasint>(cols), alpha,\r\n\t\t\t\tpA, static_cast<blasint>(lda), pB, static_cast<blasint>(ldb));\r\n\t\t}\r\n\r\n\t\ttemplate<typename sz_t, typename fl_t>\r\n\t\tstatic typename ::std::enable_if_t< ::std::is_same< ::std::remove_pointer_t<fl_t>, double>::value >\r\n\t\t\timatcopy(const bool bTranspose, const sz_t rows, const sz_t cols, const fl_t alpha,\r\n\t\t\t\tfl_t* pA, const sz_t lda, const sz_t ldb)\r\n\t\t{\r\n\t\t\t_restoreFPU r;\r\n\t\t\tcblas_dimatcopy(CblasColMajor, bTranspose ? CblasTrans : CblasNoTrans,\r\n\t\t\t\tstatic_cast<blasint>(rows), static_cast<blasint>(cols), alpha,\r\n\t\t\t\tpA, static_cast<blasint>(lda), static_cast<blasint>(ldb));\r\n\t\t}\r\n\t\ttemplate<typename sz_t, typename fl_t>\r\n\t\tstatic typename ::std::enable_if_t< ::std::is_same< ::std::remove_pointer_t<fl_t>, float>::value >\r\n\t\t\timatcopy(const bool bTranspose, const sz_t rows, const sz_t cols, const fl_t alpha,\r\n\t\t\t\tfl_t* pA, const sz_t lda, const sz_t ldb)\r\n\t\t{\r\n\t\t\t_restoreFPU r;\r\n\t\t\tcblas_simatcopy(CblasColMajor, bTranspose ? CblasTrans : CblasNoTrans,\r\n\t\t\t\tstatic_cast<blasint>(rows), static_cast<blasint>(cols), alpha,\r\n\t\t\t\tpA, static_cast<blasint>(lda), static_cast<blasint>(ldb));\r\n\t\t}\r\n\t};\r\n\r\n}\r\n}\r\n\r\n", "meta": {"hexsha": "7ee5d5aaa1f71f31b636368f557dda80c62f1e4a", "size": 20309, "ext": "h", "lang": "C", "max_stars_repo_path": "nntl/interface/math/bindings/b_open_blas.h", "max_stars_repo_name": "Arech/nntl", "max_stars_repo_head_hexsha": "fdcd7f33216c6414547acea3c4c172734ef9412a", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 12.0, "max_stars_repo_stars_event_min_datetime": "2015-12-22T19:55:56.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-28T13:10:19.000Z", "max_issues_repo_path": "nntl/interface/math/bindings/b_open_blas.h", "max_issues_repo_name": "Arech/nntl", "max_issues_repo_head_hexsha": "fdcd7f33216c6414547acea3c4c172734ef9412a", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "nntl/interface/math/bindings/b_open_blas.h", "max_forks_repo_name": "Arech/nntl", "max_forks_repo_head_hexsha": "fdcd7f33216c6414547acea3c4c172734ef9412a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2017-10-15T11:12:33.000Z", "max_forks_repo_forks_event_max_datetime": "2017-10-15T11:12:33.000Z", "avg_line_length": 54.7412398922, "max_line_length": 156, "alphanum_fraction": 0.6642867694, "num_tokens": 5755, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.40733341443526055, "lm_q2_score": 0.06954175077306284, "lm_q1q2_score": 0.028326678788197605}}
{"text": "/* ieee-utils/make_rep.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Brian Gough\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include <config.h>\n#include <gsl/gsl_ieee_utils.h>\n\n#include \"endian.c\"\n#include \"standardize.c\"\n\nstatic void sprint_nybble(int i, char *s) ;\nstatic void sprint_byte(int i, char *s) ;\nstatic int determine_ieee_type (int non_zero, int exponent, int max_exponent);\n\n\n/* For the IEEE float format the bits are found from the following\n   masks,\n   \n   sign      = 0x80000000  \n   exponent  = 0x7f800000 \n   mantisssa = 0x007fffff  \n\n   For the IEEE double format the masks are,\n\n   sign      = 0x8000000000000000  \n   exponent  = 0x7ff0000000000000 \n   mantissa  = 0x000fffffffffffff\n\n   */\n\nvoid \ngsl_ieee_float_to_rep (const float * x, gsl_ieee_float_rep * r)\n{\n  int e, non_zero;\n\n  union { \n    float f;\n    struct  { \n      unsigned char byte[4] ;\n    } ieee ;\n  } u;\n  \n  u.f = *x ; \n\n  if (little_endian_p())\n    make_float_bigendian(&(u.f)) ;\n  \n  /* note that r->sign is signed, u.ieee.byte is unsigned */\n\n  if (u.ieee.byte[3]>>7)\n    {\n      r->sign = 1 ;\n    }\n  else\n    {\n      r->sign = 0 ;\n    }\n\n  e = (u.ieee.byte[3] & 0x7f) << 1 | (u.ieee.byte[2] & 0x80)>>7 ; \n  \n  r->exponent = e - 127 ;\n\n  sprint_byte((u.ieee.byte[2] & 0x7f) << 1,r->mantissa) ;\n  sprint_byte(u.ieee.byte[1],r->mantissa + 7) ;\n  sprint_byte(u.ieee.byte[0],r->mantissa + 15) ;\n\n  r->mantissa[23] = '\\0' ;\n\n  non_zero = u.ieee.byte[0] || u.ieee.byte[1] || (u.ieee.byte[2] & 0x7f);\n\n  r->type = determine_ieee_type (non_zero, e, 255) ;\n}\n\nvoid \ngsl_ieee_double_to_rep (const double * x, gsl_ieee_double_rep * r)\n{\n\n  int e, non_zero;\n\n  union \n  { \n    double d;\n    struct  { \n      unsigned char byte[8];\n    } ieee ;\n  } u;\n\n  u.d= *x ; \n  \n  if (little_endian_p())\n    make_double_bigendian(&(u.d)) ;\n  \n  /* note that r->sign is signed, u.ieee.byte is unsigned */\n\n  if (u.ieee.byte[7]>>7)\n    {\n      r->sign = 1 ;\n    }\n  else\n    {\n      r->sign = 0 ;\n    }\n\n\n  e =(u.ieee.byte[7] & 0x7f)<<4 ^ (u.ieee.byte[6] & 0xf0)>>4 ;\n  \n  r->exponent = e - 1023 ;\n\n  sprint_nybble(u.ieee.byte[6],r->mantissa) ;\n  sprint_byte(u.ieee.byte[5],r->mantissa + 4) ;\n  sprint_byte(u.ieee.byte[4],r->mantissa + 12) ;\n  sprint_byte(u.ieee.byte[3],r->mantissa + 20) ; \n  sprint_byte(u.ieee.byte[2],r->mantissa + 28) ;\n  sprint_byte(u.ieee.byte[1],r->mantissa + 36) ;\n  sprint_byte(u.ieee.byte[0],r->mantissa + 44) ;\n\n  r->mantissa[52] = '\\0' ;\n\n  non_zero = (u.ieee.byte[0] || u.ieee.byte[1] || u.ieee.byte[2]\n              || u.ieee.byte[3] || u.ieee.byte[4] || u.ieee.byte[5] \n              || (u.ieee.byte[6] & 0x0f)) ;\n\n  r->type = determine_ieee_type (non_zero, e, 2047) ;\n}\n\n/* A table of character representations of nybbles */\n\nstatic char nybble[16][5]={ /* include space for the \\0 */\n  \"0000\", \"0001\", \"0010\", \"0011\",\n  \"0100\", \"0101\", \"0110\", \"0111\",\n  \"1000\", \"1001\", \"1010\", \"1011\",\n  \"1100\", \"1101\", \"1110\", \"1111\"\n}  ;\n          \nstatic void\nsprint_nybble(int i, char *s)\n{\n  char *c ;\n  c=nybble[i & 0x0f ];\n  *s=c[0] ;  *(s+1)=c[1] ;  *(s+2)=c[2] ;  *(s+3)=c[3] ;\n} \n\nstatic void\nsprint_byte(int i, char *s)\n{\n  char *c ;\n  c=nybble[(i & 0xf0)>>4];\n  *s=c[0] ;  *(s+1)=c[1] ;  *(s+2)=c[2] ;  *(s+3)=c[3] ;\n  c=nybble[i & 0x0f];\n  *(s+4)=c[0] ;  *(s+5)=c[1] ;  *(s+6)=c[2] ;  *(s+7)=c[3] ;\n} \n\nstatic int \ndetermine_ieee_type (int non_zero, int exponent, int max_exponent)\n{\n  if (exponent == max_exponent)\n    {\n      if (non_zero)\n        {\n          return GSL_IEEE_TYPE_NAN ;\n        }\n      else\n        {\n          return GSL_IEEE_TYPE_INF ;\n        }\n    }\n  else if (exponent == 0)\n    {\n      if (non_zero)\n        {\n          return GSL_IEEE_TYPE_DENORMAL ;\n        }\n      else\n        {\n          return GSL_IEEE_TYPE_ZERO ;\n        }\n    }\n  else\n    {\n      return GSL_IEEE_TYPE_NORMAL ;\n    }\n}\n", "meta": {"hexsha": "59bf861243bec0fb5f8608cc489f9910ebfe60ca", "size": 4513, "ext": "c", "lang": "C", "max_stars_repo_path": "pkgs/libs/gsl/src/ieee-utils/make_rep.c", "max_stars_repo_name": "manggoguy/parsec-modified", "max_stars_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 64.0, "max_stars_repo_stars_event_min_datetime": "2015-03-06T00:30:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T13:26:53.000Z", "max_issues_repo_path": "pkgs/libs/gsl/src/ieee-utils/make_rep.c", "max_issues_repo_name": "manggoguy/parsec-modified", "max_issues_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2020-12-15T08:30:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-13T03:54:24.000Z", "max_forks_repo_path": "pkgs/libs/gsl/src/ieee-utils/make_rep.c", "max_forks_repo_name": "manggoguy/parsec-modified", "max_forks_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 40.0, "max_forks_repo_forks_event_min_datetime": "2015-02-26T15:31:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T23:23:37.000Z", "avg_line_length": 22.7929292929, "max_line_length": 81, "alphanum_fraction": 0.585198316, "num_tokens": 1590, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48828339529583464, "lm_q2_score": 0.05749328001157759, "lm_q1q2_score": 0.028073013970747247}}
{"text": "/* Copyright (C) 2010-2021 Barcelona Supercomputing Center and University of\n * Illinois at Urbana-Champaign\n * SPDX-License-Identifier: MIT\n */\n\n/** \\file\n * \\brief Wrapper routines for GSL random number functions.\n */\n\n/* clang-format off */\n\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_randist.h>\n#include <gsl/gsl_rng.h>\n#include <stdio.h>\n#include <time.h>\n\n/** \\brief Private internal-use variable to store the random number\n * generator.\n */\nstatic gsl_rng *camp_rand_gsl_rng = NULL;\n\n/** \\brief Result code indicating successful completion.\n */\n#define CAMP_RAND_GSL_SUCCESS      0\n/** \\brief Result code indicating initialization failure.\n */\n#define CAMP_RAND_GSL_INIT_FAIL    1\n/** \\brief Result code indicating the generator was not initialized\n * when it should have been.\n */\n#define CAMP_RAND_GSL_NOT_INIT     2\n/** \\brief Result code indicating the generator was already\n * initialized when an initialization was attempted.\n */\n#define CAMP_RAND_GSL_ALREADY_INIT 3\n\n/** \\brief Initialize the random number generator with the given seed.\n *\n * This must be called before any other GSL random number functions\n * are called.\n *\n * \\param seed The random seed to use.\n * \\return CAMP_RAND_GSL_SUCCESS on success, otherwise an error code.\n * \\sa camp_rand_finalize_gsl() to cleanup the generator.\n */\nint camp_srand_gsl(int seed)\n{\n        if (camp_rand_gsl_rng) {\n                return CAMP_RAND_GSL_ALREADY_INIT;\n        }\n        gsl_set_error_handler_off(); // turn off automatic error handling\n        camp_rand_gsl_rng = gsl_rng_alloc(gsl_rng_mt19937);\n        if (camp_rand_gsl_rng == NULL) {\n                return CAMP_RAND_GSL_INIT_FAIL;\n        }\n        gsl_rng_set(camp_rand_gsl_rng, seed);\n        return CAMP_RAND_GSL_SUCCESS;\n}\n\n/** \\brief Cleanup and deallocate the random number generator.\n *\n * This must be called after camp_srand_gsl().\n *\n * \\return CAMP_RAND_GSL_SUCCESS on success, otherwise an error code.\n */\nint camp_rand_finalize_gsl()\n{\n        if (!camp_rand_gsl_rng) {\n                return CAMP_RAND_GSL_NOT_INIT;\n        }\n        gsl_rng_free(camp_rand_gsl_rng);\n        camp_rand_gsl_rng = NULL;\n        return CAMP_RAND_GSL_SUCCESS;\n}\n\n/** \\brief Generate a uniform random number in \\f$[0,1)\\f$.\n *\n * \\param harvest A pointer to the generated random number.\n * \\return CAMP_RAND_GSL_SUCCESS on success, otherwise an error code.\n */\nint camp_rand_gsl(double *harvest)\n{\n        if (!camp_rand_gsl_rng) {\n                return CAMP_RAND_GSL_NOT_INIT;\n        }\n        *harvest = gsl_rng_uniform(camp_rand_gsl_rng);\n        return CAMP_RAND_GSL_SUCCESS;\n}\n\n/** \\brief Generate a uniform random integer in \\f$[1,n]\\f$.\n *\n * \\param n The upper limit of the random integer.\n * \\param harvest A pointer to the generated random number.\n * \\return CAMP_RAND_GSL_SUCCESS on success, otherwise an error code.\n */\nint camp_rand_int_gsl(int n, int *harvest)\n{\n        if (!camp_rand_gsl_rng) {\n                return CAMP_RAND_GSL_NOT_INIT;\n        }\n        *harvest = gsl_rng_uniform_int(camp_rand_gsl_rng, n) + 1;\n        return CAMP_RAND_GSL_SUCCESS;\n}\n\n/** \\brief Generate a normally-distributed random number.\n *\n * \\param mean The mean of the distribution.\n * \\param stddev The standard deviation of the distribution.\n * \\param harvest A pointer to the generated random number.\n * \\return CAMP_RAND_GSL_SUCCESS on success, otherwise an error code.\n */\nint camp_rand_normal_gsl(double mean, double stddev, double *harvest)\n{\n        if (!camp_rand_gsl_rng) {\n                return CAMP_RAND_GSL_NOT_INIT;\n        }\n        *harvest = gsl_ran_gaussian(camp_rand_gsl_rng, stddev) + mean;\n        return CAMP_RAND_GSL_SUCCESS;\n}\n\n/** \\brief Generate a Poisson-distributed random integer.\n *\n * \\param mean The mean of the distribution.\n * \\param harvest A pointer to the generated random number.\n * \\return CAMP_RAND_GSL_SUCCESS on success, otherwise an error code.\n */\nint camp_rand_poisson_gsl(double mean, int *harvest)\n{\n        if (!camp_rand_gsl_rng) {\n                return CAMP_RAND_GSL_NOT_INIT;\n        }\n        *harvest = gsl_ran_poisson(camp_rand_gsl_rng, mean);\n        return CAMP_RAND_GSL_SUCCESS;\n}\n\n/** \\brief Generate a Binomial-distributed random integer.\n *\n * \\param n The sample size for the distribution.\n * \\param p The sample probability for the distribution.\n * \\param harvest A pointer to the generated random number.\n * \\return CAMP_RAND_GSL_SUCCESS on success, otherwise an error code.\n */\nint camp_rand_binomial_gsl(int n, double p, int *harvest)\n{\n        unsigned int u;\n\n        if (!camp_rand_gsl_rng) {\n                return CAMP_RAND_GSL_NOT_INIT;\n        }\n        u = n;\n        *harvest = gsl_ran_binomial(camp_rand_gsl_rng, p, u);\n        return CAMP_RAND_GSL_SUCCESS;\n}\n\n/* clang-format on */\n", "meta": {"hexsha": "72fbff71413533f863891d19914b6865dbd13edd", "size": 4783, "ext": "c", "lang": "C", "max_stars_repo_path": "src/rand_gsl.c", "max_stars_repo_name": "open-atmos/camp", "max_stars_repo_head_hexsha": "4c77145ac43ae3dcfce71f49a9709bb62f80b8c3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2021-08-05T21:35:20.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T05:32:29.000Z", "max_issues_repo_path": "src/rand_gsl.c", "max_issues_repo_name": "open-atmos/camp", "max_issues_repo_head_hexsha": "4c77145ac43ae3dcfce71f49a9709bb62f80b8c3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5.0, "max_issues_repo_issues_event_min_datetime": "2021-10-06T18:14:24.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-22T11:42:07.000Z", "max_forks_repo_path": "src/rand_gsl.c", "max_forks_repo_name": "open-atmos/camp", "max_forks_repo_head_hexsha": "4c77145ac43ae3dcfce71f49a9709bb62f80b8c3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.4649681529, "max_line_length": 76, "alphanum_fraction": 0.697470207, "num_tokens": 1193, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4493926344647597, "lm_q2_score": 0.06008665269869255, "lm_q1q2_score": 0.02700249915243451}}
{"text": "/* Useful general-purpose functions.\n *\n * Krzysztof Chalupka, 2017.\n */\n\n#include <stdio.h>\n#include <gsl/gsl_blas.h>\n#include \"utils.h\"\n\nvoid crit_err(char *msg){\n  fprintf(stderr, \"%s, exiting.\\n\", msg);\n  exit(1);\n}\n\nint get_nlines(char *fname){\n  /* Check how many lines there are in a file. */\n  int nlines = 0;\n  FILE *f = fopen(fname, \"r\");\n  while(!feof(f))\n    if (fgetc(f) == '\\n')\n      nlines++;\n  fclose(f);\n  printf(\"%d lines read from %s.\\n\\n\", nlines, fname);\n  return nlines;\n}\n\nvoid print_intarray(int *arr, int n){\n  int i;\n  printf(\"[\");\n  for(i = 0; i < n; i++)\n    printf(\"%d \", arr[i]);\n  printf(\"]\");\n}\n\nvoid print_gsl_vector(gsl_vector *vec){\n  int i;\n  for (i = 0; i < vec->size; i++)\n    printf(\"%.4f \", vec->data[i]);\n}\n\ngsl_vector *vector_sub(gsl_vector *v1, gsl_vector *v2){\n  /* Create a new vector equal to v1 - v2. */\n  gsl_vector *res = gsl_vector_calloc(v1->size);\n  gsl_vector_add(res, v1);\n  gsl_vector_sub(res, v2);\n  return res;\n}\n\ndouble vector_dist(gsl_vector *v1, gsl_vector *v2){\n  /* Compute the Euclidean distance between vectors. */\n  double dist;\n  gsl_vector *tmp =  vector_sub(v1, v2);\n  dist = gsl_blas_dnrm2(tmp);\n  free(tmp);\n  return dist;\n}\n\ngsl_vector **load_vectors_from_file(char *fname, int nvecs)\n{\n  int vec_id;\n  FILE *f;\n  gsl_vector **vecs;\n  double vals[2] = {0., 0.};\n  \n  /* Allocate the vector array. */\n  vecs = (gsl_vector **) calloc(nvecs, sizeof(gsl_vector *));\n      \n  /* Load the vectors from a file into an array. */\n  f = fopen(fname, \"r\");\n  vec_id = 0;\n  while(fscanf(f,\"%lf %lf\", &vals[0], &vals[1]) != EOF){\n    vecs[vec_id] = gsl_vector_alloc(2);\n    gsl_vector_set(vecs[vec_id], 0, vals[0]);\n    gsl_vector_set(vecs[vec_id], 1, vals[1]);\n    vec_id++;\n  }\n\n  /* Clean up. */\n  fclose(f);\n  printf(\"Data: \\n\");\n  for (vec_id = 0; vec_id < nvecs; vec_id++)\n    printf(\"[%f, %f]\\n\", \n\t   vecs[vec_id]->data[0], \n\t   vecs[vec_id]->data[1]);\n  printf(\"\\n\");\n  return vecs;\n}\n", "meta": {"hexsha": "bb945d4f6eb92ecf4f1551ee80e85031105b5479", "size": 1953, "ext": "c", "lang": "C", "max_stars_repo_path": "skiena/utils/utils.c", "max_stars_repo_name": "kjchalup/algorithm_design", "max_stars_repo_head_hexsha": "99176322b83d120f0ceb83dbba254a6e15f95264", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "skiena/utils/utils.c", "max_issues_repo_name": "kjchalup/algorithm_design", "max_issues_repo_head_hexsha": "99176322b83d120f0ceb83dbba254a6e15f95264", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "skiena/utils/utils.c", "max_forks_repo_name": "kjchalup/algorithm_design", "max_forks_repo_head_hexsha": "99176322b83d120f0ceb83dbba254a6e15f95264", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 22.1931818182, "max_line_length": 61, "alphanum_fraction": 0.6036866359, "num_tokens": 646, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47657965106367595, "lm_q2_score": 0.05665242132616554, "lm_q1q2_score": 0.026999391187536328}}
{"text": "/* ode-initval2/driver.c\n * \n * Copyright (C) 2009, 2010 Tuomo Keskitalo\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Driver routine for odeiv2. This is a wrapper for low level GSL\n   functions that allows a simple interface to step, control and\n   evolve layers.\n */\n\n#include <config.h>\n#include <math.h>\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_odeiv2.h>\n#include <gsl/gsl_machine.h>\n\nstatic gsl_odeiv2_driver *\ndriver_alloc (const gsl_odeiv2_system * sys, const double hstart,\n              const gsl_odeiv2_step_type * T)\n{\n  /* Allocates and initializes an ODE driver system. Step and evolve\n     objects are allocated here, but control object is allocated in\n     another function.\n   */\n\n  gsl_odeiv2_driver *state =\n    (gsl_odeiv2_driver *) malloc (sizeof (gsl_odeiv2_driver));\n\n  if (state == NULL)\n    {\n      GSL_ERROR_NULL (\"failed to allocate space for driver state\",\n                      GSL_ENOMEM);\n    }\n\n  if (sys == NULL)\n    {\n      GSL_ERROR_NULL (\"gsl_odeiv2_system must be defined\", GSL_EINVAL);\n    }\n\n  {\n    const size_t dim = sys->dimension;\n\n    if (dim == 0)\n      {\n        GSL_ERROR_NULL\n          (\"gsl_odeiv2_system dimension must be a positive integer\",\n           GSL_EINVAL);\n      }\n\n    state->sys = sys;\n\n    state->s = gsl_odeiv2_step_alloc (T, dim);\n\n    if (state->s == NULL)\n      {\n        free (state);\n        GSL_ERROR_NULL (\"failed to allocate step object\", GSL_ENOMEM);\n      }\n\n    state->e = gsl_odeiv2_evolve_alloc (dim);\n  }\n\n  if (state->e == NULL)\n    {\n      gsl_odeiv2_step_free (state->s);\n      free (state);\n      GSL_ERROR_NULL (\"failed to allocate evolve object\", GSL_ENOMEM);\n    }\n\n  if (hstart > 0.0 || hstart < 0.0)\n    {\n      state->h = hstart;\n    }\n  else\n    {\n      GSL_ERROR_NULL (\"invalid hstart\", GSL_EINVAL);\n    }\n\n  state->h = hstart;\n  state->hmin = 0.0;\n  state->hmax = GSL_DBL_MAX;\n  state->nmax = 0;\n  state->n = 0;\n  state->c = NULL;\n\n  return state;\n}\n\nint\ngsl_odeiv2_driver_set_hmin (gsl_odeiv2_driver * d, const double hmin)\n{\n  /* Sets minimum allowed step size fabs(hmin) for driver. It is\n     required that hmin <= fabs(h) <= hmax. */\n\n  if ((fabs (hmin) > fabs (d->h)) || (fabs (hmin) > d->hmax))\n    {\n      GSL_ERROR_NULL (\"hmin <= fabs(h) <= hmax required\", GSL_EINVAL);\n    }\n\n  d->hmin = fabs (hmin);\n\n  return GSL_SUCCESS;\n}\n\nint\ngsl_odeiv2_driver_set_hmax (gsl_odeiv2_driver * d, const double hmax)\n{\n  /* Sets maximum allowed step size fabs(hmax) for driver. It is\n     required that hmin <= fabs(h) <= hmax. */\n\n  if ((fabs (hmax) < fabs (d->h)) || (fabs (hmax) < d->hmin))\n    {\n      GSL_ERROR_NULL (\"hmin <= fabs(h) <= hmax required\", GSL_EINVAL);\n    }\n\n  if (hmax > 0.0 || hmax < 0.0)\n    {\n      d->hmax = fabs (hmax);\n    }\n  else\n    {\n      GSL_ERROR_NULL (\"invalid hmax\", GSL_EINVAL);\n    }\n\n  return GSL_SUCCESS;\n}\n\nint\ngsl_odeiv2_driver_set_nmax (gsl_odeiv2_driver * d,\n                            const unsigned long int nmax)\n{\n  /* Sets maximum number of allowed steps (nmax) for driver */\n\n  d->nmax = nmax;\n\n  return GSL_SUCCESS;\n}\n\ngsl_odeiv2_driver *\ngsl_odeiv2_driver_alloc_y_new (const gsl_odeiv2_system * sys,\n                               const gsl_odeiv2_step_type * T,\n                               const double hstart,\n                               const double epsabs, const double epsrel)\n{\n  /* Initializes an ODE driver system with control object of type y_new. */\n\n  gsl_odeiv2_driver *state = driver_alloc (sys, hstart, T);\n\n  if (state == NULL)\n    {\n      GSL_ERROR_NULL (\"failed to allocate driver object\", GSL_ENOMEM);\n    }\n\n  if (epsabs >= 0.0 && epsrel >= 0.0)\n    {\n      state->c = gsl_odeiv2_control_y_new (epsabs, epsrel);\n\n      if (state->c == NULL)\n        {\n          gsl_odeiv2_driver_free (state);\n          GSL_ERROR_NULL (\"failed to allocate control object\", GSL_ENOMEM);\n        }\n    }\n  else\n    {\n      gsl_odeiv2_driver_free (state);\n      GSL_ERROR_NULL (\"epsabs and epsrel must be positive\", GSL_EINVAL);\n    }\n\n  /* Distribute pointer to driver object */\n\n  gsl_odeiv2_step_set_driver (state->s, state);\n  gsl_odeiv2_evolve_set_driver (state->e, state);\n  gsl_odeiv2_control_set_driver (state->c, state);\n\n  return state;\n}\n\ngsl_odeiv2_driver *\ngsl_odeiv2_driver_alloc_yp_new (const gsl_odeiv2_system * sys,\n                                const gsl_odeiv2_step_type * T,\n                                const double hstart,\n                                const double epsabs, const double epsrel)\n{\n  /* Initializes an ODE driver system with control object of type yp_new. */\n\n  gsl_odeiv2_driver *state = driver_alloc (sys, hstart, T);\n\n  if (state == NULL)\n    {\n      GSL_ERROR_NULL (\"failed to allocate driver object\", GSL_ENOMEM);\n    }\n\n  if (epsabs >= 0.0 && epsrel >= 0.0)\n    {\n      state->c = gsl_odeiv2_control_yp_new (epsabs, epsrel);\n\n      if (state->c == NULL)\n        {\n          gsl_odeiv2_driver_free (state);\n          GSL_ERROR_NULL (\"failed to allocate control object\", GSL_ENOMEM);\n        }\n    }\n  else\n    {\n      gsl_odeiv2_driver_free (state);\n      GSL_ERROR_NULL (\"epsabs and epsrel must be positive\", GSL_EINVAL);\n    }\n\n  /* Distribute pointer to driver object */\n\n  gsl_odeiv2_step_set_driver (state->s, state);\n  gsl_odeiv2_evolve_set_driver (state->e, state);\n  gsl_odeiv2_control_set_driver (state->c, state);\n\n  return state;\n}\n\ngsl_odeiv2_driver *\ngsl_odeiv2_driver_alloc_standard_new (const gsl_odeiv2_system * sys,\n                                      const gsl_odeiv2_step_type * T,\n                                      const double hstart,\n                                      const double epsabs,\n                                      const double epsrel, const double a_y,\n                                      const double a_dydt)\n{\n  /* Initializes an ODE driver system with control object of type\n     standard_new. \n   */\n\n  gsl_odeiv2_driver *state = driver_alloc (sys, hstart, T);\n\n  if (state == NULL)\n    {\n      GSL_ERROR_NULL (\"failed to allocate driver object\", GSL_ENOMEM);\n    }\n\n  if (epsabs >= 0.0 && epsrel >= 0.0)\n    {\n      state->c =\n        gsl_odeiv2_control_standard_new (epsabs, epsrel, a_y, a_dydt);\n\n      if (state->c == NULL)\n        {\n          gsl_odeiv2_driver_free (state);\n          GSL_ERROR_NULL (\"failed to allocate control object\", GSL_ENOMEM);\n        }\n    }\n  else\n    {\n      gsl_odeiv2_driver_free (state);\n      GSL_ERROR_NULL (\"epsabs and epsrel must be positive\", GSL_EINVAL);\n    }\n\n  /* Distribute pointer to driver object */\n\n  gsl_odeiv2_step_set_driver (state->s, state);\n  gsl_odeiv2_evolve_set_driver (state->e, state);\n  gsl_odeiv2_control_set_driver (state->c, state);\n\n  return state;\n}\n\ngsl_odeiv2_driver *\ngsl_odeiv2_driver_alloc_scaled_new (const gsl_odeiv2_system * sys,\n                                    const gsl_odeiv2_step_type * T,\n                                    const double hstart,\n                                    const double epsabs, const double epsrel,\n                                    const double a_y, const double a_dydt,\n                                    const double scale_abs[])\n{\n  /* Initializes an ODE driver system with control object of type\n     scaled_new. \n   */\n\n  gsl_odeiv2_driver *state = driver_alloc (sys, hstart, T);\n\n  if (state == NULL)\n    {\n      GSL_ERROR_NULL (\"failed to allocate driver object\", GSL_ENOMEM);\n    }\n\n  if (epsabs >= 0.0 && epsrel >= 0.0)\n    {\n      state->c = gsl_odeiv2_control_scaled_new (epsabs, epsrel, a_y, a_dydt,\n                                                scale_abs, sys->dimension);\n\n      if (state->c == NULL)\n        {\n          gsl_odeiv2_driver_free (state);\n          GSL_ERROR_NULL (\"failed to allocate control object\", GSL_ENOMEM);\n        }\n    }\n  else\n    {\n      gsl_odeiv2_driver_free (state);\n      GSL_ERROR_NULL (\"epsabs and epsrel must be positive\", GSL_EINVAL);\n    }\n\n  /* Distribute pointer to driver object */\n\n  gsl_odeiv2_step_set_driver (state->s, state);\n  gsl_odeiv2_evolve_set_driver (state->e, state);\n  gsl_odeiv2_control_set_driver (state->c, state);\n\n  return state;\n}\n\nint\ngsl_odeiv2_driver_apply (gsl_odeiv2_driver * d, double *t,\n                         const double t1, double y[])\n{\n  /* Main driver function that evolves the system from t to t1. In\n     beginning vector y contains the values of dependent variables at\n     t. This function returns values at t=t1 in y. In case of\n     unrecoverable error, y and t contains the values after the last\n     successful step.\n   */\n\n  int sign = 0;\n  d->n = 0;\n\n  /* Determine integration direction sign */\n\n  if (d->h > 0.0)\n    {\n      sign = 1;\n    }\n  else\n    {\n      sign = -1;\n    }\n\n  /* Check that t, t1 and step direction are sensible */\n\n  if (sign * (t1 - *t) < 0.0)\n    {\n      GSL_ERROR_NULL\n        (\"integration limits and/or step direction not consistent\",\n         GSL_EINVAL);\n    }\n\n  /* Evolution loop */\n\n  while (sign * (t1 - *t) > 0.0)\n    {\n      int s = gsl_odeiv2_evolve_apply (d->e, d->c, d->s, d->sys,\n                                       t, t1, &(d->h), y);\n\n      if (s != GSL_SUCCESS)\n        {\n          return s;\n        }\n\n      /* Check for maximum allowed steps */\n\n      if ((d->nmax > 0) && (d->n > d->nmax))\n        {\n          return GSL_EMAXITER;\n        }\n\n      /* Set step size if maximum size is exceeded */\n\n      if (fabs (d->h) > d->hmax)\n        {\n          d->h = sign * d->hmax;\n        }\n\n      /* Check for too small step size */\n\n      if (fabs (d->h) < d->hmin)\n        {\n          return GSL_ENOPROG;\n        }\n\n      d->n++;\n    }\n\n  return GSL_SUCCESS;\n}\n\nint\ngsl_odeiv2_driver_apply_fixed_step (gsl_odeiv2_driver * d, double *t,\n                                    const double h, const unsigned long int n,\n                                    double y[])\n{\n  /* Alternative driver function that evolves the system from t using\n   * n steps of size h. In the beginning vector y contains the values\n   * of dependent variables at t. This function returns values at t =\n   * t + n * h in y. In case of an unrecoverable error, y and t\n   * contains the values after the last successful step.\n   */\n\n  unsigned long int i;\n  d->n = 0;\n\n  /* Evolution loop */\n\n  for (i = 0; i < n; i++)\n    {\n      int s = gsl_odeiv2_evolve_apply_fixed_step (d->e, d->c, d->s, d->sys,\n                                                  t, h, y);\n\n      if (s != GSL_SUCCESS)\n        {\n          return s;\n        }\n\n      d->n++;\n    }\n\n  return GSL_SUCCESS;\n}\n\nint\ngsl_odeiv2_driver_reset (gsl_odeiv2_driver * d)\n{\n  /* Reset the driver. Resets evolve and step objects. */\n\n  {\n    int s = gsl_odeiv2_evolve_reset (d->e);\n\n    if (s != GSL_SUCCESS)\n      {\n        return s;\n      }\n  }\n\n  {\n    int s = gsl_odeiv2_step_reset (d->s);\n\n    if (s != GSL_SUCCESS)\n      {\n        return s;\n      }\n  }\n\n  return GSL_SUCCESS;\n}\n\nint\ngsl_odeiv2_driver_reset_hstart (gsl_odeiv2_driver * d, const double hstart)\n{\n  /* Resets current driver and sets initial step size to hstart */\n\n  gsl_odeiv2_driver_reset (d);\n\n  if ((d->hmin > fabs (hstart)) || (fabs (hstart) > d->hmax))\n    {\n      GSL_ERROR_NULL (\"hmin <= fabs(h) <= hmax required\", GSL_EINVAL);\n    }\n\n  if (hstart > 0.0 || hstart < 0.0)\n    {\n      d->h = hstart;\n    }\n  else\n    {\n      GSL_ERROR_NULL (\"invalid hstart\", GSL_EINVAL);\n    }\n\n  return GSL_SUCCESS;\n}\n\nvoid\ngsl_odeiv2_driver_free (gsl_odeiv2_driver * state)\n{\n  if (state->c != NULL)\n    {\n      gsl_odeiv2_control_free (state->c);\n    }\n\n  gsl_odeiv2_evolve_free (state->e);\n  gsl_odeiv2_step_free (state->s);\n  free (state);\n}\n", "meta": {"hexsha": "d0db988a592d6b17cff7dc141bb4e54db752df1f", "size": 12220, "ext": "c", "lang": "C", "max_stars_repo_path": "oldjuila/juliakernel/ext_libraries/gsl/ode-initval2/driver.c", "max_stars_repo_name": "ruslankuzmin/julia", "max_stars_repo_head_hexsha": "2ad5bfb9c9684b1c800e96732a9e2f1e844b856f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "oldjuila/juliakernel/ext_libraries/gsl/ode-initval2/driver.c", "max_issues_repo_name": "ruslankuzmin/julia", "max_issues_repo_head_hexsha": "2ad5bfb9c9684b1c800e96732a9e2f1e844b856f", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "oldjuila/juliakernel/ext_libraries/gsl/ode-initval2/driver.c", "max_forks_repo_name": "ruslankuzmin/julia", "max_forks_repo_head_hexsha": "2ad5bfb9c9684b1c800e96732a9e2f1e844b856f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2015-10-02T01:32:59.000Z", "max_forks_repo_forks_event_max_datetime": "2015-10-02T01:32:59.000Z", "avg_line_length": 24.8879837067, "max_line_length": 81, "alphanum_fraction": 0.5928805237, "num_tokens": 3373, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4882833952958347, "lm_q2_score": 0.05500529216624421, "lm_q1q2_score": 0.026858170818173103}}
{"text": "//  This random generator is a C++ wrapper for the GNU Scientific Library\n//  Copyright (C) 2001 Torbjorn Vik\n\n//  This program is free software; you can redistribute it and/or modify\n//  it under the terms of the GNU General Public License as published by\n//  the Free Software Foundation; either version 2 of the License, or\n//  (at your option) any later version.\n\n//  This program is distributed in the hope that it will be useful,\n//  but WITHOUT ANY WARRANTY; without even the implied warranty of\n//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n//  GNU General Public License for more details.\n\n//  You should have received a copy of the GNU General Public License\n//  along with this program; if not, write to the Free Software\n//  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n#ifndef __min_fminimizer_h\n#define __min_fminimizer_h \n\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_min.h>\n\nnamespace gsl{\n\n//! Derive this class provide a user defined function for minimisation\nstruct min_f\n{\n\t//! This operator must be overridden\n\tvirtual double operator()(const double& x)=0;\n\t\n\t//! This is the function gsl calls to optimize f\n\tstatic double f(double x, void *p)\n\t{\n\t\treturn (*(min_f *)p)(x);\n\t}\n};\n\n//! Class for minimizing one dimensional functions. \n/*!\n  Usage: \n       - Create with optional minimize type\n\t   - Set with function object and inital bounds\n\t   - Loop the  iterate function until convergence or maxIterations (extra facility)\n\n\t   - Recover minimum and bounds\n */\nclass min_fminimizer \n{\n public:\n\t//! choose between gsl_min_fminimizer_goldensection and gsl_min_fminimizer_brent\n\tmin_fminimizer(const gsl_min_fminimizer_type* type=gsl_min_fminimizer_brent) : s(NULL), maxIterations(100), isSet(false)\n\t{\n\t\ts=gsl_min_fminimizer_alloc(type);\n\t\tnIterations=0;\n\t\tif (!s)\n\t\t{\n\t\t\t//error\n\t\t\t//cout << \"ERROR Couldn't allocate memory for minimizer\" << endl;\n\t\t\t//throw ? \n\t\t\texit(-1);\n\t\t}\n\t}\n\t~min_fminimizer(){if (s) gsl_min_fminimizer_free(s);}\n\t//! returns GSL_FAILURE if the interval does not contain a minimum\n\tint set(min_f& function, double minimum, double x_lower, double x_upper)\n\t{\n\t\tisSet=false;\n\t\tf.function = &function.f;\n\t\tf.params = &function;\n\t\tint status=\tgsl_min_fminimizer_set(s, &f, minimum, x_lower, x_upper);\n\t\tif (!status)\n\t\t{\n\t\t\tisSet=true;\n\t\t\tnIterations=0;\n\t\t}\n\t\treturn status;\n\t}\n\tint set_with_values(min_f& function, \n\t\t\t\t\t\tdouble minimum, double f_minimum, \n\t\t\t\t\t\tdouble x_lower,double f_lower, \n\t\t\t\t\t\tdouble x_upper, double f_upper)\n\t{\n\t\tisSet=false;\n\t\tf.function = &function.f;\n\t\tf.params = &function;\n\t\tint status=\tgsl_min_fminimizer_set_with_values(s, &f, minimum, f_minimum, x_lower, f_lower, x_upper, f_upper);\n\t\tif (!status)\n\t\t{\n\t\t\tisSet=true;\n\t\t\tnIterations=0;\n\t\t}\n\t\treturn status;\n\t}\n\tint iterate()\n\t{\n\t\tassert_set();\n\t\tint status=gsl_min_fminimizer_iterate(s);\n\t\tnIterations++;\n\t\tif (status==GSL_FAILURE)\n\t\t\tisConverged=true;\n\t\treturn status;\n\t}\n\tdouble minimum(){assert_set();return gsl_min_fminimizer_minimum(s);}\n\tdouble x_upper(){assert_set();return gsl_min_fminimizer_x_upper(s);}\n\tdouble x_lower(){assert_set();return gsl_min_fminimizer_x_lower(s);}\n\tvoid SetMaxIterations(int n){maxIterations=n;}\n\tint GetNIterations(){return nIterations;}\n\tbool is_converged(){if (nIterations>=maxIterations) return true; if (isConverged) return true; return false;}\n\t//string name() const;\n\t\n private:\n\tvoid assert_set(){if (!isSet)exit(-1);} // Old problem of error handling: TODO\n\t\n\tbool isSet;\n\tbool isConverged;\n\tint nIterations;\n\tint maxIterations;\n\tgsl_min_fminimizer* s;\n\tgsl_function f;\n};\n};\t // namespace gsl\n\n#endif //__min_fminimizer_h\n", "meta": {"hexsha": "a4e4ad37a17b6e87cc9f963534a8b0185229654c", "size": 3627, "ext": "h", "lang": "C", "max_stars_repo_path": "src/gslwrap/min_fminimizer.h", "max_stars_repo_name": "entn-at/GlottDNN", "max_stars_repo_head_hexsha": "b7db669d7f34da92ab34742d75a8ba3c70763a65", "max_stars_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2018-11-27T01:35:30.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-27T01:17:11.000Z", "max_issues_repo_path": "src/gslwrap/min_fminimizer.h", "max_issues_repo_name": "entn-at/GlottDNN", "max_issues_repo_head_hexsha": "b7db669d7f34da92ab34742d75a8ba3c70763a65", "max_issues_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/gslwrap/min_fminimizer.h", "max_forks_repo_name": "entn-at/GlottDNN", "max_forks_repo_head_hexsha": "b7db669d7f34da92ab34742d75a8ba3c70763a65", "max_forks_repo_licenses": ["ECL-2.0", "Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2018-11-27T01:35:33.000Z", "max_forks_repo_forks_event_max_datetime": "2018-11-27T01:35:33.000Z", "avg_line_length": 29.25, "max_line_length": 121, "alphanum_fraction": 0.723462917, "num_tokens": 969, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47657965106367595, "lm_q2_score": 0.055823143490797325, "lm_q1q2_score": 0.0266041742461217}}
{"text": "/* ode-initval/evolve.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Author:  G. Jungman\n */\n#include <config.h>\n#include <string.h>\n#include <stdlib.h>\n#include <gsl/gsl_math.h>\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_odeiv.h>\n\n#include \"odeiv_util.h\"\n\ngsl_odeiv_evolve *\ngsl_odeiv_evolve_alloc (size_t dim)\n{\n  gsl_odeiv_evolve *e =\n    (gsl_odeiv_evolve *) malloc (sizeof (gsl_odeiv_evolve));\n\n  if (e == 0)\n    {\n      GSL_ERROR_NULL (\"failed to allocate space for evolve struct\",\n                      GSL_ENOMEM);\n    }\n\n  e->y0 = (double *) malloc (dim * sizeof (double));\n\n  if (e->y0 == 0)\n    {\n      free (e);\n      GSL_ERROR_NULL (\"failed to allocate space for y0\", GSL_ENOMEM);\n    }\n\n  e->yerr = (double *) malloc (dim * sizeof (double));\n\n  if (e->yerr == 0)\n    {\n      free (e->y0);\n      free (e);\n      GSL_ERROR_NULL (\"failed to allocate space for yerr\", GSL_ENOMEM);\n    }\n\n  e->dydt_in = (double *) malloc (dim * sizeof (double));\n\n  if (e->dydt_in == 0)\n    {\n      free (e->yerr);\n      free (e->y0);\n      free (e);\n      GSL_ERROR_NULL (\"failed to allocate space for dydt_in\", GSL_ENOMEM);\n    }\n\n  e->dydt_out = (double *) malloc (dim * sizeof (double));\n\n  if (e->dydt_out == 0)\n    {\n      free (e->dydt_in);\n      free (e->yerr);\n      free (e->y0);\n      free (e);\n      GSL_ERROR_NULL (\"failed to allocate space for dydt_out\", GSL_ENOMEM);\n    }\n\n  e->dimension = dim;\n  e->count = 0;\n  e->failed_steps = 0;\n  e->last_step = 0.0;\n\n  return e;\n}\n\nint\ngsl_odeiv_evolve_reset (gsl_odeiv_evolve * e)\n{\n  e->count = 0;\n  e->failed_steps = 0;\n  e->last_step = 0.0;\n  return GSL_SUCCESS;\n}\n\nvoid\ngsl_odeiv_evolve_free (gsl_odeiv_evolve * e)\n{\n  RETURN_IF_NULL (e);\n  free (e->dydt_out);\n  free (e->dydt_in);\n  free (e->yerr);\n  free (e->y0);\n  free (e);\n}\n\n/* Evolution framework method.\n *\n * Uses an adaptive step control object\n */\nint\ngsl_odeiv_evolve_apply (gsl_odeiv_evolve * e,\n                        gsl_odeiv_control * con,\n                        gsl_odeiv_step * step,\n                        const gsl_odeiv_system * dydt,\n                        double *t, double t1, double *h, double y[])\n{\n  const double t0 = *t;\n  double h0 = *h;\n  int step_status;\n  int final_step = 0;\n  double dt = t1 - t0;  /* remaining time, possibly less than h */\n\n  if (e->dimension != step->dimension)\n    {\n      GSL_ERROR (\"step dimension must match evolution size\", GSL_EINVAL);\n    }\n\n  if ((dt < 0.0 && h0 > 0.0) || (dt > 0.0 && h0 < 0.0))\n    {\n      GSL_ERROR (\"step direction must match interval direction\", GSL_EINVAL);\n    }\n\n  /* No need to copy if we cannot control the step size. */\n\n  if (con != NULL)\n    {\n      DBL_MEMCPY (e->y0, y, e->dimension);\n    }\n\n  /* Calculate initial dydt once if the method can benefit. */\n\n  if (step->type->can_use_dydt_in)\n    {\n      int status = GSL_ODEIV_FN_EVAL (dydt, t0, y, e->dydt_in);\n\n      if (status) \n        {\n          return status;\n        }\n    }\n\ntry_step:\n    \n  if ((dt >= 0.0 && h0 > dt) || (dt < 0.0 && h0 < dt))\n    {\n      h0 = dt;\n      final_step = 1;\n    }\n  else\n    {\n      final_step = 0;\n    }\n\n  if (step->type->can_use_dydt_in)\n    {\n      step_status =\n        gsl_odeiv_step_apply (step, t0, h0, y, e->yerr, e->dydt_in,\n                              e->dydt_out, dydt);\n    }\n  else\n    {\n      step_status =\n        gsl_odeiv_step_apply (step, t0, h0, y, e->yerr, NULL, e->dydt_out,\n                              dydt);\n    }\n\n  /* Check for stepper internal failure */\n\n  if (step_status != GSL_SUCCESS) \n    {\n      *h = h0;  /* notify user of step-size which caused the failure */\n      *t = t0;  /* restore original t value */\n      return step_status;\n    }\n\n  e->count++;\n  e->last_step = h0;\n\n  if (final_step)\n    {\n      *t = t1;\n    }\n  else\n    {\n      *t = t0 + h0;\n    }\n\n  if (con != NULL)\n    {\n      /* Check error and attempt to adjust the step. */\n\n      double h_old = h0;\n\n      const int hadjust_status \n        = gsl_odeiv_control_hadjust (con, step, y, e->yerr, e->dydt_out, &h0);\n\n      if (hadjust_status == GSL_ODEIV_HADJ_DEC)\n        {\n          /* Check that the reported status is correct (i.e. an actual\n             decrease in h0 occured) and the suggested h0 will change\n             the time by at least 1 ulp */\n\n          double t_curr = GSL_COERCE_DBL(*t);\n          double t_next = GSL_COERCE_DBL((*t) + h0);\n\n          if (fabs(h0) < fabs(h_old) && t_next != t_curr) \n            {\n              /* Step was decreased. Undo step, and try again with new h0. */\n              DBL_MEMCPY (y, e->y0, dydt->dimension);\n              e->failed_steps++;\n              goto try_step;\n            }\n          else\n            {\n              h0 = h_old; /* keep current step size */\n            }\n        }\n    }\n\n  *h = h0;  /* suggest step size for next time-step */\n\n  return step_status;\n}\n", "meta": {"hexsha": "d61842a3dfc6dfb2e862336051ccc8dc116df9ed", "size": 5585, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/ode-initval/evolve.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-01-11T02:53:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-25T17:31:22.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/ode-initval/evolve.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/ode-initval/evolve.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 14.0, "max_forks_repo_forks_event_min_datetime": "2015-07-21T04:47:52.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-12T12:31:25.000Z", "avg_line_length": 23.5654008439, "max_line_length": 81, "alphanum_fraction": 0.5692032229, "num_tokens": 1673, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.40356683938849797, "lm_q2_score": 0.06560483837252304, "lm_q1q2_score": 0.026475937270592373}}
{"text": "/* spoper.c\n * \n * Copyright (C) 2012 Patrick Alken\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include <config.h>\n#include <stdlib.h>\n#include <math.h>\n\n#include <gsl/gsl_math.h>\n#include <gsl/gsl_matrix.h>\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_spmatrix.h>\n#include <gsl/gsl_spblas.h>\n\nint\ngsl_spmatrix_scale(gsl_spmatrix *m, const double x)\n{\n  size_t i;\n\n  for (i = 0; i < m->nz; ++i)\n    m->data[i] *= x;\n\n  return GSL_SUCCESS;\n} /* gsl_spmatrix_scale() */\n\nint\ngsl_spmatrix_minmax(const gsl_spmatrix *m, double *min_out, double *max_out)\n{\n  double min, max;\n  size_t n;\n\n  if (m->nz == 0)\n    {\n      GSL_ERROR(\"matrix is empty\", GSL_EINVAL);\n    }\n\n  min = m->data[0];\n  max = m->data[0];\n\n  for (n = 1; n < m->nz; ++n)\n    {\n      double x = m->data[n];\n\n      if (x < min)\n        min = x;\n\n      if (x > max)\n        max = x;\n    }\n\n  *min_out = min;\n  *max_out = max;\n\n  return GSL_SUCCESS;\n} /* gsl_spmatrix_minmax() */\n\n/*\ngsl_spmatrix_add()\n  Add two sparse matrices\n\nInputs: c - (output) a + b\n        a - (input) sparse matrix\n        b - (input) sparse matrix\n\nReturn: success or error\n*/\n\nint\ngsl_spmatrix_add(gsl_spmatrix *c, const gsl_spmatrix *a,\n                 const gsl_spmatrix *b)\n{\n  const size_t M = a->size1;\n  const size_t N = a->size2;\n\n  if (b->size1 != M || b->size2 != N || c->size1 != M || c->size2 != N)\n    {\n      GSL_ERROR(\"matrices must have same dimensions\", GSL_EBADLEN);\n    }\n  else if (a->sptype != b->sptype || a->sptype != c->sptype)\n    {\n      GSL_ERROR(\"matrices must have same sparse storage format\",\n                GSL_EINVAL);\n    }\n  else if (GSL_SPMATRIX_ISTRIPLET(a))\n    {\n      GSL_ERROR(\"triplet format not yet supported\", GSL_EINVAL);\n    }\n  else\n    {\n      int status = GSL_SUCCESS;\n      size_t *w = (size_t *) a->work;\n      double *x = (double *) b->work;\n      size_t *Cp, *Ci;\n      double *Cd;\n      size_t j, p;\n      size_t nz = 0; /* number of non-zeros in c */\n      size_t inner_size, outer_size;\n\n      if (GSL_SPMATRIX_ISCCS(a))\n        {\n          inner_size = M;\n          outer_size = N;\n        }\n      else if (GSL_SPMATRIX_ISCRS(a))\n        {\n          inner_size = N;\n          outer_size = M;\n        }\n      else\n        {\n          GSL_ERROR(\"unknown sparse matrix type\", GSL_EINVAL);\n        }\n\n      if (c->nzmax < a->nz + b->nz)\n        {\n          status = gsl_spmatrix_realloc(a->nz + b->nz, c);\n          if (status)\n            return status;\n        }\n\n      /* initialize w = 0 */\n      for (j = 0; j < inner_size; ++j)\n        w[j] = 0;\n\n      Ci = c->i;\n      Cp = c->p;\n      Cd = c->data;\n\n      for (j = 0; j < outer_size; ++j)\n        {\n          Cp[j] = nz;\n\n          /* CCS: x += A(:,j); CRS: x += A(j,:) */\n          nz = gsl_spblas_scatter(a, j, 1.0, w, x, j + 1, c, nz);\n\n          /* CCS: x += B(:,j); CRS: x += B(j,:) */\n          nz = gsl_spblas_scatter(b, j, 1.0, w, x, j + 1, c, nz);\n\n          for (p = Cp[j]; p < nz; ++p)\n            Cd[p] = x[Ci[p]];\n        }\n\n      /* finalize last column of c */\n      Cp[j] = nz;\n      c->nz = nz;\n\n      return status;\n    }\n} /* gsl_spmatrix_add() */\n\n/*\ngsl_spmatrix_d2sp()\n  Convert a dense gsl_matrix to sparse (triplet) format\n\nInputs: S - (output) sparse matrix in triplet format\n        A - (input) dense matrix to convert\n*/\n\nint\ngsl_spmatrix_d2sp(gsl_spmatrix *S, const gsl_matrix *A)\n{\n  int s = GSL_SUCCESS;\n  size_t i, j;\n\n  gsl_spmatrix_set_zero(S);\n  S->size1 = A->size1;\n  S->size2 = A->size2;\n\n  for (i = 0; i < A->size1; ++i)\n    {\n      for (j = 0; j < A->size2; ++j)\n        {\n          double x = gsl_matrix_get(A, i, j);\n\n          if (x != 0.0)\n            gsl_spmatrix_set(S, i, j, x);\n        }\n    }\n\n  return s;\n} /* gsl_spmatrix_d2sp() */\n\n/*\ngsl_spmatrix_sp2d()\n  Convert a sparse matrix to dense format\n*/\n\nint\ngsl_spmatrix_sp2d(gsl_matrix *A, const gsl_spmatrix *S)\n{\n  if (A->size1 != S->size1 || A->size2 != S->size2)\n    {\n      GSL_ERROR(\"matrix sizes do not match\", GSL_EBADLEN);\n    }\n  else\n    {\n      gsl_matrix_set_zero(A);\n\n      if (GSL_SPMATRIX_ISTRIPLET(S))\n        {\n          size_t n;\n\n          for (n = 0; n < S->nz; ++n)\n            {\n              size_t i = S->i[n];\n              size_t j = S->p[n];\n              double x = S->data[n];\n\n              gsl_matrix_set(A, i, j, x);\n            }\n        }\n      else\n        {\n          GSL_ERROR(\"non-triplet formats not yet supported\", GSL_EINVAL);\n        }\n\n      return GSL_SUCCESS;\n    }\n} /* gsl_spmatrix_sp2d() */\n", "meta": {"hexsha": "07268c18b5547dc3c8fb8e964010f63d1117f2e6", "size": 5172, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.4/spmatrix/spoper.c", "max_stars_repo_name": "peterahrens/FillEstimationIPDPS2017", "max_stars_repo_head_hexsha": "857b6ee8866a2950aa5721d575d2d7d0797c4302", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-01-13T05:01:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-13T05:01:59.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/spmatrix/spoper.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/spmatrix/spoper.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 22.0085106383, "max_line_length": 81, "alphanum_fraction": 0.5442768755, "num_tokens": 1610, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48047867804790706, "lm_q2_score": 0.054198729441259676, "lm_q1q2_score": 0.02604133387381263}}
{"text": "/* Copyright (c) 2011-2012, Jérémy Fix. All rights reserved. */\n\n/* Redistribution and use in source and binary forms, with or without */\n/* modification, are permitted provided that the following conditions are met: */\n\n/* * Redistributions of source code must retain the above copyright notice, */\n/* this list of conditions and the following disclaimer. */\n/* * Redistributions in binary form must reproduce the above copyright notice, */\n/* this list of conditions and the following disclaimer in the documentation */\n/* and/or other materials provided with the distribution. */\n/* * None of the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. */\n\n/* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS \"AS IS\" AND */\n/* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED */\n/* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE */\n/* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE */\n/* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL */\n/* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR */\n/* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER */\n/* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, */\n/* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE */\n/* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */\n\n#ifndef UKF_SAMPLES_H\n#define UKF_SAMPLES_H\n\n#include <gsl/gsl_vector.h>\n#include <gsl/gsl_matrix.h>\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_sort_vector_double.h>\n#include <gsl/gsl_permute_vector.h>\n#include <gsl/gsl_randist.h>\n\n#include <time.h>\n\n#include <iostream>\n\nnamespace ukf\n{\n    namespace samples\n    {\n        /**\n          * @short Generate 1D samples according to a uniform distribution :\n          * @brief In fact, gsl_ran_choose would do the job!!\n          */\n        class RandomSample_1D\n        {\n        public:\n            static void generateSample(gsl_vector * samples, unsigned int nb_samples, double min, double max, double delta)\n            {\n                if(samples->size != nb_samples)\n                {\n                    std::cerr << \"[ERROR] RandomSample_1D : samples should be allocated to the size of the requested number of samples\" << std::endl;\n                    return;\n                }\n\n\n                for(unsigned int i = 0 ; i < nb_samples ; i++)\n                    gsl_vector_set(samples, i, min + floor((max - min)*rand()/double(RAND_MAX)/delta)    * delta  );\n            }\n        };\n\n        /**\n          * @short Generate 2D samples according to a uniform distribution\n          * and put them alternativaly at the odd/even positions\n          */\n        class RandomSample_2D\n        {\n        public:\n            static void generateSample(gsl_vector * samples, unsigned int nb_samples, double minx, double maxx, double deltax, double miny, double maxy, double deltay)\n            {\n                if(samples->size != 2*nb_samples)\n                {\n                    std::cerr << \"[ERROR] RandomSample_2D : samples should be allocated to the size of the 2 times the requested number of samples\" << std::endl;\n                    return;\n                }\n\t\tgsl_vector_view vec_view = gsl_vector_subvector_with_stride (samples, 0, 2, nb_samples);\n                RandomSample_1D::generateSample(&vec_view.vector, nb_samples, minx, maxx, deltax);\n\t\tvec_view = gsl_vector_subvector_with_stride (samples, 1, 2, nb_samples);\n                RandomSample_1D::generateSample(&vec_view.vector, nb_samples, miny, maxy, deltay);\n            }\n        };\n\n        /**\n          * @short Generate 3D samples according to a uniform distribution\n          * and put them alternativaly at the odd/even positions\n          */\n        class RandomSample_3D\n        {\n        public:\n            static void generateSample(gsl_vector * samples, unsigned int nb_samples, double minx, double maxx, double deltax, double miny, double maxy, double deltay, double minz, double maxz, double deltaz)\n            {\n                if(samples->size != 3*nb_samples)\n                {\n                    std::cerr << \"[ERROR] RandomSample_2D : samples should be allocated to the size of the 2 times the requested number of samples\" << std::endl;\n                    return;\n                }\n\t\tgsl_vector_view vec_view = gsl_vector_subvector_with_stride (samples, 0, 3, nb_samples);\n                RandomSample_1D::generateSample(&vec_view.vector, nb_samples, minx, maxx, deltax);\n\t\tvec_view = gsl_vector_subvector_with_stride (samples, 1, 3, nb_samples);\n                RandomSample_1D::generateSample(&vec_view.vector, nb_samples, miny, maxy, deltay);\n\t\tvec_view = gsl_vector_subvector_with_stride (samples, 2, 3, nb_samples);\n                RandomSample_1D::generateSample(&vec_view.vector, nb_samples, minz, maxz, deltaz);\n            }\n        };\n\n        /**\n          * @short Extract the indexes of the nb_samples highest values of a vector\n          * Be carefull, this function is extracting the indexes as, the way it is used, it doesn't not to which sample a vector index corresponds\n          */\n        class MaximumIndexes_1D\n        {\n        public:\n            static void generateSample(gsl_vector * v, gsl_vector * indexes_samples, unsigned int nb_samples)\n            {\n                if(indexes_samples->size != nb_samples)\n                {\n                    std::cerr << \"[ERROR] MaximumIndexes_1D : samples should be allocated to the size of the requested number of samples\" << std::endl;\n                    return;\n                }\n                if(nb_samples > v->size)\n                {\n                    std::cerr << \"[ERROR] MaximumIndexes_1D : the vector v must hold at least nb_samples elements\" << std::endl;\n                    return;\n                }\n\n                gsl_permutation * p = gsl_permutation_alloc(v->size);\n                gsl_sort_vector_index(p,v);\n                for(unsigned int i = 0 ; i < nb_samples ; i++)\n                    gsl_vector_set(indexes_samples, i, gsl_permutation_get(p, p->size - i - 1));\n                gsl_permutation_free(p);\n            }\n        };\n\n        /**\n          * @short Extract the indexes of the nb_samples highest values of a matrix\n          * Be carefull, this function is extracting the indexes as, the way it is used, it doesn't not to which sample a vector index corresponds\n          */\n        class MaximumIndexes_2D\n        {\n        public:\n            static void generateSample(gsl_matrix * m, gsl_vector * indexes_samples, unsigned int nb_samples)\n            {\n\n                if(indexes_samples->size != 2*nb_samples)\n                {\n                    std::cerr << \"[ERROR] MaximumIndexes_2D : samples should be allocated to the size of 2 times the requested number of samples\" << std::endl;\n                    return;\n                }\n                if(nb_samples > m->size1 * m->size2 )\n                {\n                    std::cerr << \"[ERROR] MaximumIndexes_2D : the vector v must hold at least nb_samples elements\" << std::endl;\n                    return;\n                }\n\n                gsl_permutation * p = gsl_permutation_alloc(m->size1 * m->size2);\n                // We cast the matrix in a vector ordered in row-major and get the permutation to order the data by increasing value\n\t\tgsl_vector_view vec_view = gsl_vector_view_array(m->data,m->size1 * m->size2);\n                gsl_sort_vector_index(p,&vec_view.vector);\n\n                // The indexes stored in p are in row-major order\n                // we then convert the nb_samples first indexes into matrix indexes and copy them in indexes_samples\n                int k,l;\n                for(unsigned int i = 0 ; i < nb_samples ; i++)\n                {\n                    // Line\n                    k = gsl_permutation_get(p,p->size - i - 1) / m->size2;\n                    // Column\n                    l = gsl_permutation_get(p,p->size - i - 1) % m->size2;\n                    gsl_vector_set(indexes_samples, 2 * i, k);\n                    gsl_vector_set(indexes_samples, 2 * i + 1, l);\n                }\n\n                gsl_permutation_free(p);\n            }\n        };\n\n        /**\n          * @short Generate 1D samples according to a discrete vectorial distribution\n          */\n        class DistributionSample_1D\n        {\n        public:\n            static void generateSample(gsl_vector * v, gsl_vector * indexes_samples, unsigned int nb_samples)\n            {\n                if(indexes_samples->size != nb_samples)\n                {\n                    std::cerr << \"[ERROR] RandomSample_1D : samples should be allocated to the size of the requested number of samples\" << std::endl;\n                    return;\n                }\n\n                // Generating nb_samples samples from an array of weights for each index is easily done in the gsl with gsl_ran_discrete_* methods\n                // the weights v do not need to add up to one\n                gsl_rng * r = gsl_rng_alloc(gsl_rng_default);\n                // Init the random seed\n                gsl_rng_set(r, time(NULL));\n                gsl_ran_discrete_t * ran_pre = gsl_ran_discrete_preproc(v->size, v->data);\n\n                for(unsigned int i = 0 ; i < nb_samples ; i++)\n                    gsl_vector_set(indexes_samples, i , gsl_ran_discrete(r, ran_pre));\n\n                gsl_ran_discrete_free(ran_pre);\n                gsl_rng_free(r);\n            }\n        };\n\n        /**\n          * @short Generate 2D samples according to a discrete matricial distribution\n          */\n        class DistributionSample_2D\n        {\n        public:\n            static void generateSample(gsl_matrix * m, gsl_vector * indexes_samples, unsigned int nb_samples)\n            {\n                if(indexes_samples->size != 2*nb_samples)\n                {\n                    std::cerr << \"[ERROR] RandomSample_1D : samples should be allocated to the size of the requested number of samples\" << std::endl;\n                    return;\n                }\n\n                // To generate 2D samples according to a matrix of weights\n                // we simply cast the matrix into a vector, ask DistributionSample_1D to do the job\n                // and then convert the linear row-major indexes back into 2D indexes\n\n                gsl_vector * samples_tmp = gsl_vector_alloc(nb_samples);\n\t\tgsl_vector_view vec_view = gsl_vector_view_array(m->data,m->size1 * m->size2);\n                DistributionSample_1D::generateSample(&vec_view.vector, samples_tmp, nb_samples);\n\n                int k,l;\n                for(unsigned int i = 0 ; i < nb_samples ; i++)\n                {\n                    k = int(gsl_vector_get(samples_tmp,i)) / m->size2;\n                    l = int(gsl_vector_get(samples_tmp,i)) % m->size2;\n                    gsl_vector_set(indexes_samples, 2*i, k);\n                    gsl_vector_set(indexes_samples, 2*i+1, l);\n                }\n\n                gsl_vector_free(samples_tmp);\n            }\n        };\n    }\n}\n\n\n#endif // UKF_SAMPLES_H\n", "meta": {"hexsha": "e5afd0e7f5115350ab7e0f81e0677ec4f24e3f47", "size": 11226, "ext": "h", "lang": "C", "max_stars_repo_path": "src/ukf_samples.h", "max_stars_repo_name": "bahia14/C-Kalman-filtering", "max_stars_repo_head_hexsha": "7c01a11359bdd2e2b89ae8a8de88db215d8e061a", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 101.0, "max_stars_repo_stars_event_min_datetime": "2015-01-07T05:30:09.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-21T15:24:07.000Z", "max_issues_repo_path": "src/ukf_samples.h", "max_issues_repo_name": "bahia14/C-Kalman-filtering", "max_issues_repo_head_hexsha": "7c01a11359bdd2e2b89ae8a8de88db215d8e061a", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2018-10-16T10:29:05.000Z", "max_issues_repo_issues_event_max_datetime": "2018-10-17T21:45:18.000Z", "max_forks_repo_path": "src/ukf_samples.h", "max_forks_repo_name": "bahia14/C-Kalman-filtering", "max_forks_repo_head_hexsha": "7c01a11359bdd2e2b89ae8a8de88db215d8e061a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 52.0, "max_forks_repo_forks_event_min_datetime": "2015-03-10T01:02:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-13T02:47:35.000Z", "avg_line_length": 45.6341463415, "max_line_length": 208, "alphanum_fraction": 0.5905932656, "num_tokens": 2424, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47657965106367595, "lm_q2_score": 0.053403334319473035, "lm_q1q2_score": 0.02545094243561129}}
{"text": "/* spcompress.c\n * \n * Copyright (C) 2012-2014, 2016 Patrick Alken\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include <config.h>\n#include <stdlib.h>\n#include <math.h>\n#include <gsl/gsl_math.h>\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_spmatrix.h>\n\n/*\ngsl_spmatrix_ccs()\n  Create a sparse matrix in compressed column format\n\nInputs: T - sparse matrix in triplet format\n\nReturn: pointer to new matrix (should be freed when finished with it)\n*/\n\ngsl_spmatrix *\ngsl_spmatrix_ccs(const gsl_spmatrix *T)\n{\n  if (!GSL_SPMATRIX_ISTRIPLET(T))\n    {\n      GSL_ERROR_NULL(\"matrix must be in triplet format\", GSL_EINVAL);\n    }\n  else\n    {\n      const size_t *Tj; /* column indices of triplet matrix */\n      size_t *Cp;       /* column pointers of compressed column matrix */\n      size_t *w;        /* copy of column pointers */\n      gsl_spmatrix *m;\n      size_t n;\n\n      m = gsl_spmatrix_alloc_nzmax(T->size1, T->size2, T->nz,\n                                   GSL_SPMATRIX_CCS);\n      if (!m)\n        return NULL;\n\n      Tj = T->p;\n      Cp = m->p;\n\n      /* initialize column pointers to 0 */\n      for (n = 0; n < m->size2 + 1; ++n)\n        Cp[n] = 0;\n\n      /*\n       * compute the number of elements in each column:\n       * Cp[j] = # non-zero elements in column j\n       */\n      for (n = 0; n < T->nz; ++n)\n        Cp[Tj[n]]++;\n\n      /* compute column pointers: p[j] = p[j-1] + nnz[j-1] */\n      gsl_spmatrix_cumsum(m->size2, Cp);\n\n      /* make a copy of the column pointers */\n      w = (size_t *) m->work;\n      for (n = 0; n < m->size2; ++n)\n        w[n] = Cp[n];\n\n      /* transfer data from triplet format to CCS */\n      for (n = 0; n < T->nz; ++n)\n        {\n          size_t k = w[Tj[n]]++;\n          m->i[k] = T->i[n];\n          m->data[k] = T->data[n];\n        }\n\n      m->nz = T->nz;\n\n      return m;\n    }\n}\n\ngsl_spmatrix *\ngsl_spmatrix_compcol(const gsl_spmatrix *T)\n{\n  return gsl_spmatrix_ccs(T);\n}\n\n/*\ngsl_spmatrix_crs()\n  Create a sparse matrix in compressed row format\n\nInputs: T - sparse matrix in triplet format\n\nReturn: pointer to new matrix (should be freed when finished with it)\n*/\n\ngsl_spmatrix *\ngsl_spmatrix_crs(const gsl_spmatrix *T)\n{\n  if (!GSL_SPMATRIX_ISTRIPLET(T))\n    {\n      GSL_ERROR_NULL(\"matrix must be in triplet format\", GSL_EINVAL);\n    }\n  else\n    {\n      const size_t *Ti; /* row indices of triplet matrix */\n      size_t *Cp;       /* row pointers of compressed row matrix */\n      size_t *w;        /* copy of column pointers */\n      gsl_spmatrix *m;\n      size_t n;\n\n      m = gsl_spmatrix_alloc_nzmax(T->size1, T->size2, T->nz,\n                                   GSL_SPMATRIX_CRS);\n      if (!m)\n        return NULL;\n\n      Ti = T->i;\n      Cp = m->p;\n\n      /* initialize row pointers to 0 */\n      for (n = 0; n < m->size1 + 1; ++n)\n        Cp[n] = 0;\n\n      /*\n       * compute the number of elements in each row:\n       * Cp[i] = # non-zero elements in row i\n       */\n      for (n = 0; n < T->nz; ++n)\n        Cp[Ti[n]]++;\n\n      /* compute row pointers: p[i] = p[i-1] + nnz[i-1] */\n      gsl_spmatrix_cumsum(m->size1, Cp);\n\n      /* make a copy of the row pointers */\n      w = (size_t *) m->work;\n      for (n = 0; n < m->size1; ++n)\n        w[n] = Cp[n];\n\n      /* transfer data from triplet format to CRS */\n      for (n = 0; n < T->nz; ++n)\n        {\n          size_t k = w[Ti[n]]++;\n          m->i[k] = T->p[n];\n          m->data[k] = T->data[n];\n        }\n\n      m->nz = T->nz;\n\n      return m;\n    }\n}\n\n/*\ngsl_spmatrix_cumsum()\n\nCompute the cumulative sum:\n\np[j] = Sum_{k=0...j-1} c[k]\n\n0 <= j < n + 1\n\nAlternatively,\np[0] = 0\np[j] = p[j - 1] + c[j - 1]\n\nInputs: n - length of input array\n        c - (input/output) array of size n + 1\n            on input, contains the n values c[k]\n            on output, contains the n + 1 values p[j]\n\nReturn: success or error\n*/\n\nvoid\ngsl_spmatrix_cumsum(const size_t n, size_t *c)\n{\n  size_t sum = 0;\n  size_t k;\n\n  for (k = 0; k < n; ++k)\n    {\n      size_t ck = c[k];\n      c[k] = sum;\n      sum += ck;\n    }\n\n  c[n] = sum;\n} /* gsl_spmatrix_cumsum() */\n", "meta": {"hexsha": "d680fa550b80e4fc1f290dbbc1ab670bcf337923", "size": 4752, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.4/spmatrix/spcompress.c", "max_stars_repo_name": "peterahrens/FillEstimationIPDPS2017", "max_stars_repo_head_hexsha": "857b6ee8866a2950aa5721d575d2d7d0797c4302", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-01-13T05:01:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-13T05:01:59.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/spmatrix/spcompress.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/spmatrix/spcompress.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 23.8793969849, "max_line_length": 81, "alphanum_fraction": 0.5637626263, "num_tokens": 1434, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3775406547908327, "lm_q2_score": 0.06560483152162024, "lm_q1q2_score": 0.024768491050114767}}
{"text": "/*\n  10 Sept 08: Process_Error_Code is now static and thus private to\n              this library.\n*/\n\n#include <cblas.h>\n#include \"lbl.h\"\n#include \"ma57.h\"\n\n#ifdef __cplusplus\nextern \"C\" {   /* To prevent C++ compilers from mangling symbols */\n#endif\n\n  /* ================================================================= */\n\n#ifdef  __FUNCT__\n#undef  __FUNCT__\n#endif\n#define __FUNCT__ \"Process_Error_Code\"\nstatic int Process_Error_Code( Ma57_Data *ma57, int nerror ) {\n\n    LOGMSG( \" [%3d]\", nerror );\n    /* Take appropriate action according to error code */\n    /* Inflation factors are from the MA57 spec sheet  */\n    switch( nerror ) {\n\n    case 0:\n      break;\n\n      /* Warnings */\n    case 1:\n      LOGMSG( \" Found and ignored %d indices out of range.\\n\", ma57->info[2] );\n      break;\n\n    case 2:\n      LOGMSG( \" Found and summed %d duplicate entries.\\n\", ma57->info[3] );\n      break;\n\n    case 3:\n      LOGMSG( \" Found duplicate and out-of-range indices.\\n\" );\n      break;\n\n    case 4:\n      LOGMSG( \" Matrix has rank %d, deficient.\\n\", ma57->info[24] );\n      break;\n\n    case 5:\n      LOGMSG( \" Found %d pivot sign changes in definite matrix.\\n\",\n              ma57->info[25] );\n      break;\n\n    case 8:\n      LOGMSG( \" Infinity norm of solution found to be zero.\\n\" );\n      break;\n\n    case 10:\n      LOGMSG( \" Insufficient real space. Increased LFACT to %d.\\n\",\n              ma57->lfact );\n      break;\n\n    case 11:\n      LOGMSG( \" Insufficient integer space. Increased LIFACT to %d.\\n\",\n              ma57->lifact );\n      break;\n\n      /* Errors */\n    case -1:\n      LOGMSG( \" Value of n is out of range: %d.\\n\", ma57->info[1] );\n      break;\n\n    case -2:\n      LOGMSG( \" Value of nz is out of range: %d.\\n\", ma57->info[1] );\n      break;\n\n    case -3:\n      LOGMSG( \" Adjusted size of array FACT to %d.\\n\", ma57->lfact );\n      break;\n\n    case -4:\n      LOGMSG( \" Adjusting size of array IFACT to %d.\\n\", ma57->lifact );\n      break;\n\n    case -5:\n      LOGMSG( \" Small pivot encountered at pivot step %d. Threshold = %lf.\\n\",\n              ma57->info[1], ma57->cntl[1] );\n\n    case -6:\n      LOGMSG( \" Change in pivot sign detected at pivot step %d.\\n\",\n              ma57->info[1] );\n      break;\n\n    case -7:\n      LOGMSG( \" Erroneous sizing of array FACT or IFACT.\\n\" );\n      break;\n\n    case -8:\n      LOGMSG( \" Iterative refinement failed to converge.\\n\" );\n      break;\n\n    case -9:\n      LOGMSG( \" Error in user-supplied permutation array in component %d.\\n\",\n              ma57->info[1] );\n      break;\n\n    case -10:\n      LOGMSG( \" Unknown pivoting strategy: %d\\n.\", ma57->info[1] );\n      break;\n\n    case -11:\n      LOGMSG( \" Size of RHS must be %d. Received %d.\\n\",\n              ma57->n, ma57->info[1] );\n      break;\n\n    case -12:\n      LOGMSG( \" Invalid value of JOB (%d).\\n\", ma57->info[1] );\n      break;\n\n    case -13:\n      LOGMSG( \" Invalid number of iterative refinement steps (%d).\\n\",\n              ma57->info[1] );\n      break;\n\n    case -14:\n      LOGMSG( \" Failed to estimate condition number.\\n\" );\n      break;\n\n    case -15:\n      LOGMSG( \" LKEEP has value %d, less than minimum allowed.\\n\",\n              ma57->info[1] );\n      break;\n\n    case -16:\n      LOGMSG( \" Invalid number of RHS (%d).\\n\", ma57->info[1] );\n      break;\n\n    case -17:\n      LOGMSG( \" Increasing size of LWORK to %d.\\n\", ma57->lwork );\n      break;\n\n    case -18:\n      LOGMSG( \" MeTiS library not available or not found.\\n\" );\n      break;\n\n    default:\n      LOGMSG( \" Unrecognized flag from Factorize().\" );\n      nerror = -30;\n    }    \n    return nerror;\n  }\n\n  /* ================================================================= */\n\n#ifdef  __FUNCT__\n#undef  __FUNCT__\n#endif\n#define __FUNCT__ \"MA57_Initialize\"\n  Ma57_Data *Ma57_Initialize( int nz, int n, FILE *logfile ) {\n\n    /* Call initialize subroutine MA57ID and set defaults */\n    Ma57_Data *ma57 = (Ma57_Data *)LBL_Calloc( 1, sizeof(Ma57_Data) );\n    ma57->logfile   = logfile;\n\n    LOGMSG( \" MA57 :: Initializing...\" );\n\n    ma57->n         = n;\n    ma57->nz        = nz;\n    ma57->fetched   = 0;\n    ma57->irn       = (int *)LBL_Calloc( nz, sizeof(int) );\n    ma57->jcn       = (int *)LBL_Calloc( nz, sizeof(int) );\n    ma57->lkeep     = 5*n + nz + imax(n,nz) + 42 + n; // Add n to suggested val.\n    ma57->keep      = (int *)LBL_Calloc( ma57->lkeep, sizeof(int) );\n    ma57->iwork     = (int *)LBL_Calloc( 5*n, sizeof(int) );\n    ma57->work      = NULL; // Will be initialized in Ma57_Solve()\n\n    LOGMSG( \" Calling ma57id...\" );\n    MA57ID( ma57->cntl, ma57->icntl ); // Initialize all parameters\n\n    // Ensure some default parameters are appropriate\n    ma57->icntl[0] = -1;  // Stream for error messages.\n    ma57->icntl[1] = -1;  // Stream for warning messages.\n    ma57->icntl[2] = -1;  // Stream for monitoring printing.\n    ma57->icntl[3] = -1;  // Stream for printing of statistics.\n    ma57->icntl[4] =  0;  // Verbosity: 0=none, 1=errors, 2=1+warnings,\n                          //            3=2+monitor, 4=3+input,output\n    ma57->icntl[5] =  5;  // Pivot selection strategy:\n                          //  0: AMD using MC47\n                          //  1: User-supplied pivot sequence\n                          //  2: AMD with dense row strategy\n                          //  3: MD as in MA27\n                          //  4: MeTiS\n                          //  5: Automatic (4 with fallback on 2)\n    ma57->icntl[6] =  1;  // Numerical pivoting strategy\n                          //  1: Do pivoting using value in cntl(1)\n                          //  2: No pivoting; exit on sign change or zero\n                          //  3: No pivoting; exit if pivot modulus < cntl(2)\n                          //  4: No pivoting; alter pivots to have same sign\n    ma57->icntl[7] =  1;  // Memory will be re-allocated if necessary\n    ma57->icntl[15] = 0;  // No need to scale system before factorizing    \n    ma57->fetched = 0;\n\n    LOGMSG( \" done\\n\");\n    return ma57;\n  }\n\n  /* ================================================================= */\n\n#ifdef  __FUNCT__\n#undef  __FUNCT__\n#endif\n#define __FUNCT__ \"Ma57_Analyze\"\n  int Ma57_Analyze( Ma57_Data *ma57 ) {\n\n    int finished = 0, error;\n    LOGMSG( \" MA57 :: Analyzing...\" );\n\n    /* Unpack data structure and call MA57AD */\n    while( !finished ) {\n      LOGMSG( \"\\n         Calling ma57ad... \" );\n\n      MA57AD( &(ma57->n), &(ma57->nz), ma57->irn, ma57->jcn,\n              &(ma57->lkeep), ma57->keep, ma57->iwork, ma57->icntl,\n              ma57->info, ma57->rinfo );\n\n      error = ma57->info[0];\n\n      if( !error )\n        finished = 1;\n      else {\n        error = Process_Error_Code( ma57, error );\n        if( error != -3 && error != -4 && error != -8 && error != -14 )\n          return error;\n      }\n    }\n\n    // Allocate data for Factorize()\n    ma57->lfact = ceil( LFACT_GROW * ma57->info[8] );\n    ma57->fact = (double *)LBL_Calloc( ma57->lfact, sizeof(double) );\n    ma57->lifact = ceil( LIFACT_GROW * ma57->info[9] );\n    ma57->ifact = (int *)LBL_Calloc( ma57->lifact, sizeof(int) );\n    LBL_Free( ma57->iwork );\n    ma57->iwork = (int *)LBL_Calloc( ma57->n, sizeof(int) );\n    ma57->work = NULL;\n\n    LOGMSG( \" done\\n\");\n    return 0;\n  }\n\n  /* ================================================================= */\n\n#ifdef  __FUNCT__\n#undef  __FUNCT__\n#endif\n#define __FUNCT__ \"Ma57_Factorize\"\n  int Ma57_Factorize( Ma57_Data *ma57, double A[] ) {\n\n    // To ensure consistency with the MA27 interface, the user must pass\n    // the array A, *including* its zero-th element. Internally, A+1 is\n    // passed to MA57.\n\n    double *newFact;\n    int    *newIfact;\n    int     newSize, one = 1, zero = 0;\n    int     finished = 0, error;\n    LOGMSG( \" MA57 :: Factorizing...\\n\" );\n        \n    /* Unpack data structure and call MA57BD */\n    while( !finished ) {\n      LOGMSG( \"         Calling ma57bd... \" );\n\n      MA57BD( &(ma57->n), &(ma57->nz), A, ma57->fact, &(ma57->lfact),\n              ma57->ifact, &(ma57->lifact), &(ma57->lkeep), ma57->keep,\n              ma57->iwork, ma57->icntl, ma57->cntl, ma57->info, ma57->rinfo );\n\n      error = ma57->info[0];\n\n      if( !error ) {\n\n        finished = 1;\n\n      } else {\n\n        error = Process_Error_Code( ma57, error );\n\n        if( error == -3 || error == 10 ) {\n\n          /* Resize real workspace */\n          newSize = (error == 10) ? ma57->lfact : ma57->info[16];\n          newSize = ceil( LFACT_GROW * newSize );\n          LOGMSG(\"         Resizing real workspace for factors to %d\", newSize);\n          newFact = (double *)LBL_Calloc( newSize, sizeof(double) );\n          MA57ED( &(ma57->n), &zero, ma57->keep, ma57->fact, &(ma57->lfact),\n                  newFact, &newSize, ma57->ifact, &(ma57->lifact), NULL,\n                  &zero, ma57->info );\n          LBL_Free( ma57->fact );\n          ma57->fact = newFact; newFact = NULL;\n          ma57->lfact = newSize;\n\n        } else if( error == -4 || error == 11 ) {\n\n          /* Resize integer workspace */\n          newSize = (error == 11) ? ma57->lifact : ma57->info[17];\n          newSize = ceil( LIFACT_GROW * newSize );\n          LOGMSG(\"         Resizing int workspace for factors to %d\", newSize);\n          newIfact = (int *)LBL_Calloc( newSize, sizeof(int) );\n          MA57ED( &(ma57->n), &one, ma57->keep, ma57->fact, &(ma57->lfact),\n                  NULL, &zero, ma57->ifact, &(ma57->lifact), newIfact,\n                  &newSize, ma57->info );\n          LBL_Free( ma57->ifact );\n          ma57->ifact = newIfact; newIfact = NULL;\n          ma57->lifact = newSize;\n\n        } else {\n          finished = 1;\n          if( error < 0 ) return error;\n        }\n      }\n    }\n\n    LOGMSG(\"\\n\");\n    LOGMSG(\"         %-23s: %6i   %-28s: %6i\\n\",\n           \"No. of 2x2 pivots\"            , ma57->info[21],\n           \"Pivot step for modification\"  , ma57->info[26]);\n    LOGMSG(\"         %-28s: %6i   %-28s: %6i\\n\",\n           \"No. of negative e-vals\"       , ma57->info[23],\n           \"No. of entries in factor\"     , ma57->info[13]);\n    LOGMSG(\"         %-28s: %6i   %-28s: %6i\\n\",\n           \"Rank of factorization\"        , ma57->info[24],\n           \"No. of pivot sign changes\"    , ma57->info[25]);\n    LOGMSG(\"         done\\n\");\n    return 0;\n  }\n\n  /* ================================================================= */\n\n#ifdef  __FUNCT__\n#undef  __FUNCT__\n#endif\n#define __FUNCT__ \"Ma57_Solve\"\n  int Ma57_Solve( Ma57_Data *ma57, double x[] ) {\n\n    int one = 1, finished = 0, error;\n\n    LOGMSG( \" MA57 :: Solving...\" );\n\n    ma57->job = 1;\n    ma57->lrhs = ma57->n;\n    ma57->nrhs = 1;\n    ma57->lwork = ma57->n * ma57->nrhs;\n    if( !ma57->work ) {\n      LOGMSG(\"\\n         Sizing work array to size %d \", ma57->lwork);\n      ma57->work = (double *)LBL_Calloc( ma57->lwork, sizeof(double) );\n    }\n\n    while( !finished ) {\n      LOGMSG( \"\\n         Calling ma57cd... \" );\n\n      /* Unpack data structure and call MA57CD */\n      MA57CD( &(ma57->job), &(ma57->n), ma57->fact, &(ma57->lfact),\n              ma57->ifact, &(ma57->lifact), &ma57->nrhs, x, &(ma57->lrhs),\n              ma57->work, &(ma57->lwork), ma57->iwork, ma57->icntl,\n              ma57->info );\n\n      error = ma57->info[0];\n      if( error == -17 ) {\n        LBL_Free( ma57->work );\n        ma57->lwork = ceil( 1.2 * ma57->lwork );\n        LOGMSG(\"\\n         Resizing work array to size %d \", ma57->lwork);\n        ma57->work = (double *)LBL_Calloc( ma57->lwork, sizeof(double) );\n      } else\n        finished = 1;\n      if( error ) error = Process_Error_Code( ma57, error );\n    }\n\n    LOGMSG( \" done\\n\" );\n    return error;\n  }\n\n  /* ================================================================= */\n\n#ifdef  __FUNCT__\n#undef  __FUNCT__\n#endif\n#define __FUNCT__ \"Ma57_Refine\"\n  int Ma57_Refine( Ma57_Data *ma57, double x[], double rhs[],\n                   double A[], int maxitref, int job ) {\n    \n    int error;\n\n    LOGMSG( \" MA57 :: Performing iterative refinement...\" );\n\n    ma57->job = job;\n    /* For values of 'job' that demand the presence of the residual,\n     * it should be placed by the user in ma57->residual prior to calling\n     * this function.\n     */\n\n    /* Allocate work space */\n    ma57->icntl[8] = imax( 1, maxitref );  // Number of refinement iterations\n    ma57->icntl[9] = 1; // Return estimates of condition number\n    LBL_Free( ma57->iwork );\n    ma57->iwork = (int *)LBL_Calloc( ma57->n, sizeof(int) );\n\n    LBL_Free( ma57->work );\n    ma57->lwork = ma57->n;\n    if( ma57->icntl[8] > 1 ) {\n      ma57->lwork += 2 * ma57->n;\n      if( ma57->icntl[9] > 0 )\n        ma57->lwork += 2 * ma57->n;\n    }\n    ma57->work = (double *)LBL_Calloc( ma57->lwork, sizeof(double) );\n    ma57->residual = (double *)LBL_Calloc( ma57->n, sizeof(double) );\n\n    /* Perform iterative refinement */\n    MA57DD( &(ma57->job), &(ma57->n), &(ma57->nz), A, ma57->irn,\n            ma57->jcn, ma57->fact, &(ma57->lfact), ma57->ifact,\n            &(ma57->lifact), rhs, x, ma57->residual, ma57->work,\n            ma57->iwork, ma57->icntl, ma57->cntl, ma57->info,\n            ma57->rinfo );\n\n    error = ma57->info[0];\n    if( error ) error = Process_Error_Code(ma57, ma57->info[0]);\n    LOGMSG( \" done\\n\" );\n    return error;\n  }\n\n  /* ================================================================= */\n\n#ifdef  __FUNCT__\n#undef  __FUNCT__\n#endif\n#define __FUNCT__ \"Ma57_Finalize\"\n  void Ma57_Finalize( Ma57_Data *ma57 ) {\n\n    /* Free allocated memory */\n    LOGMSG( \" MA57 :: Deallocating data arrays...\" );\n    LBL_Free( ma57->irn );\n    LBL_Free( ma57->jcn );\n    LBL_Free( ma57->keep );\n    LBL_Free( ma57->iwork );\n    LBL_Free( ma57->fact );\n    LBL_Free( ma57->ifact );\n    LBL_Free( ma57->work );\n    if( ma57->residual ) LBL_Free(ma57->residual);\n    LOGMSG( \" done.\\n\" );\n    free(ma57);\n    return;\n  }\n\n  /* ================================================================= */\n    /* Currently, this routine doesn't do error checking on the\n       allowable parameter values. */\n\n#ifdef  __FUNCT__\n#undef  __FUNCT__\n#endif\n#define __FUNCT__ \"Ma57_set_int_parm\"\n  void Ma57_set_int_parm( Ma57_Data *ma57, int parm, int val ) {\n\n      switch (parm) {\n      case MA57_I_PIV_SELECTION:\n          ma57->icntl[MA57_I_PIV_SELECTION] = val;\n          LOGMSG(\" Set %-20s = %10d\\n\",\"I_PIV_SELECTION\",val);\n          break;\n      case MA57_I_PIV_NUMERICAL:\n          ma57->icntl[MA57_I_PIV_NUMERICAL] = val;\n          LOGMSG(\" Set %-20s = %10d\\n\",\"I_PIV_NUMERICAL\",val);\n          break;\n      case MA57_I_SCALING:\n          ma57->icntl[MA57_I_SCALING] = val;\n          LOGMSG(\" Set %-20s = %10d\\n\",\"I_SCALING\",val);\n          break;                 \n      }\n      return;\n  }\n\n  /* ================================================================= */\n    /* Currently, this routine doesn't do error checking on the\n       allowable parameter values. */\n\n#ifdef  __FUNCT__\n#undef  __FUNCT__\n#endif\n#define __FUNCT__ \"Ma57_set_real_parm\"\n  void Ma57_set_real_parm( Ma57_Data *ma57, int parm, double val ) {\n\n      switch (parm) {\n      case MA57_D_PIV_THRESH:\n          ma57->cntl[MA57_D_PIV_THRESH] = val;\n          LOGMSG(\" Set %-20s = %10.2e\\n\",\"D_PIV_THRESH\",val);\n          break;\n      case MA57_D_PIV_NONZERO:\n          ma57->cntl[MA57_D_PIV_NONZERO] = val;\n          LOGMSG(\" Set %-20s = %10.2e\\n\",\"D_PIV_NONZERO\",val);\n          break;\n      }\n      return;\n  }\n\n  /* ================================================================= */\n\n#ifdef  __FUNCT__\n#undef  __FUNCT__\n#endif\n#define __FUNCT__ \"Ma57_get_int_parm\"\n  int Ma57_get_int_parm( Ma57_Data *ma57, int parm ) {\n\n      switch (parm) {\n      case MA57_I_PIV_SELECTION:\n          return ma57->icntl[MA57_I_PIV_SELECTION];\n      case MA57_I_PIV_NUMERICAL:\n          return ma57->icntl[MA57_I_PIV_NUMERICAL];\n      case MA57_I_SCALING:\n          return ma57->icntl[MA57_I_SCALING];\n      }\n      return 0;\n  }\n\n  /* ================================================================= */\n\n#ifdef  __FUNCT__\n#undef  __FUNCT__\n#endif\n#define __FUNCT__ \"Ma57_get_real_parm\"\n  double Ma57_get_real_parm( Ma57_Data *ma57, int parm ) {\n\n      switch (parm) {\n      case MA57_D_PIV_THRESH:\n          return ma57->cntl[MA57_D_PIV_THRESH];\n      case MA57_D_PIV_NONZERO:\n          return ma57->cntl[MA57_D_PIV_NONZERO];\n      }\n      return 0.0;\n  }\n\n  /* ================================================================= */\n\n#ifdef __cplusplus\n}              /* Closing brace for  extern \"C\"  block */\n#endif\n", "meta": {"hexsha": "6b1014f9d0dfdf905abb48eb14cf57ae7170a05c", "size": 16468, "ext": "c", "lang": "C", "max_stars_repo_path": "externals/lbl/src/ma57_lib.c", "max_stars_repo_name": "fperignon/sandbox", "max_stars_repo_head_hexsha": "649f09d6db7bbd84c2418de74eb9453c0131f070", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 137.0, "max_stars_repo_stars_event_min_datetime": "2015-06-16T15:55:28.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-26T06:01:59.000Z", "max_issues_repo_path": "externals/lbl/src/ma57_lib.c", "max_issues_repo_name": "fperignon/sandbox", "max_issues_repo_head_hexsha": "649f09d6db7bbd84c2418de74eb9453c0131f070", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 381.0, "max_issues_repo_issues_event_min_datetime": "2015-09-22T15:31:08.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-14T09:05:23.000Z", "max_forks_repo_path": "externals/lbl/src/ma57_lib.c", "max_forks_repo_name": "fperignon/sandbox", "max_forks_repo_head_hexsha": "649f09d6db7bbd84c2418de74eb9453c0131f070", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 30.0, "max_forks_repo_forks_event_min_datetime": "2015-08-06T22:57:51.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-02T20:30:20.000Z", "avg_line_length": 30.4962962963, "max_line_length": 80, "alphanum_fraction": 0.5205853777, "num_tokens": 4861, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.38861802670584894, "lm_q2_score": 0.06371499291856339, "lm_q1q2_score": 0.024760794819589243}}
{"text": "/* multimin/fdfminimizer.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Fabrice Rossi\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n */\n\n#include <config.h>\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_multimin.h>\n\ngsl_multimin_fdfminimizer *\ngsl_multimin_fdfminimizer_alloc (const gsl_multimin_fdfminimizer_type * T,\n\t\t\t\t size_t n)\n{\n  int status;\n\n  gsl_multimin_fdfminimizer *s =\n    (gsl_multimin_fdfminimizer *) malloc (sizeof (gsl_multimin_fdfminimizer));\n\n  if (s == 0)\n    {\n      GSL_ERROR_VAL (\"failed to allocate space for minimizer struct\",\n\t\t     GSL_ENOMEM, 0);\n    }\n\n  s->type = T;\n\n  s->x = gsl_vector_calloc (n);\n\n  if (s->x == 0) \n    {\n      free (s);\n      GSL_ERROR_VAL (\"failed to allocate space for x\", GSL_ENOMEM, 0);\n    }\n\n  s->gradient = gsl_vector_calloc (n);\n\n  if (s->gradient == 0) \n    {\n      gsl_vector_free (s->x);\n      free (s);\n      GSL_ERROR_VAL (\"failed to allocate space for gradient\", GSL_ENOMEM, 0);\n    }\n\n  s->dx = gsl_vector_calloc (n);\n\n  if (s->dx == 0) \n    {\n      gsl_vector_free (s->x);\n      gsl_vector_free (s->gradient);\n      free (s);\n      GSL_ERROR_VAL (\"failed to allocate space for dx\", GSL_ENOMEM, 0);\n    }\n\n  s->state = malloc (T->size);\n\n  if (s->state == 0)\n    {\n      gsl_vector_free (s->x);\n      gsl_vector_free (s->gradient);\n      gsl_vector_free (s->dx);\n      free (s);\n      GSL_ERROR_VAL (\"failed to allocate space for minimizer state\",\n\t\t     GSL_ENOMEM, 0);\n    }\n\n  status = (T->alloc) (s->state, n);\n\n  if (status != GSL_SUCCESS)\n    {\n      free (s->state);\n      gsl_vector_free (s->x);\n      gsl_vector_free (s->gradient);\n      gsl_vector_free (s->dx);\n      free (s);\n\n      GSL_ERROR_VAL (\"failed to initialize minimizer state\", GSL_ENOMEM, 0);\n    }\n\n  return s;\n}\n\nint\ngsl_multimin_fdfminimizer_set (gsl_multimin_fdfminimizer * s,\n                               gsl_multimin_function_fdf * fdf,\n                               const gsl_vector * x,\n                               double step_size, double tol)\n{\n  if (s->x->size != fdf->n)\n    {\n      GSL_ERROR (\"function incompatible with solver size\", GSL_EBADLEN);\n    }\n  \n  if (x->size != fdf->n) \n    {\n      GSL_ERROR (\"vector length not compatible with function\", GSL_EBADLEN);\n    }  \n    \n  s->fdf = fdf;\n\n  gsl_vector_memcpy (s->x,x);\n  gsl_vector_set_zero (s->dx);\n  \n  return (s->type->set) (s->state, s->fdf, s->x, &(s->f), s->gradient, step_size, tol);\n}\n\nvoid\ngsl_multimin_fdfminimizer_free (gsl_multimin_fdfminimizer * s)\n{\n  (s->type->free) (s->state);\n  free (s->state);\n  gsl_vector_free (s->dx);\n  gsl_vector_free (s->gradient);\n  gsl_vector_free (s->x);\n  free (s);\n}\n\nint\ngsl_multimin_fdfminimizer_iterate (gsl_multimin_fdfminimizer * s)\n{\n  return (s->type->iterate) (s->state, s->fdf, s->x, &(s->f), s->gradient, s->dx);\n}\n\nint\ngsl_multimin_fdfminimizer_restart (gsl_multimin_fdfminimizer * s)\n{\n  return (s->type->restart) (s->state);\n}\n\nconst char * \ngsl_multimin_fdfminimizer_name (const gsl_multimin_fdfminimizer * s)\n{\n  return s->type->name;\n}\n\n\ngsl_vector * \ngsl_multimin_fdfminimizer_x (gsl_multimin_fdfminimizer * s)\n{\n  return s->x;\n}\n\ngsl_vector * \ngsl_multimin_fdfminimizer_dx (gsl_multimin_fdfminimizer * s)\n{\n  return s->dx;\n}\n\ngsl_vector * \ngsl_multimin_fdfminimizer_gradient (gsl_multimin_fdfminimizer * s)\n{\n  return s->gradient;\n}\n\ndouble \ngsl_multimin_fdfminimizer_minimum (gsl_multimin_fdfminimizer * s)\n{\n  return s->f;\n}\n\n", "meta": {"hexsha": "4029c375e9caa3353d8f3304163ed6b707161b24", "size": 4071, "ext": "c", "lang": "C", "max_stars_repo_path": "code/em/treba/gsl-1.0/multimin/fdfminimizer.c", "max_stars_repo_name": "ICML14MoMCompare/spectral-learn", "max_stars_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "code/em/treba/gsl-1.0/multimin/fdfminimizer.c", "max_issues_repo_name": "ICML14MoMCompare/spectral-learn", "max_issues_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/em/treba/gsl-1.0/multimin/fdfminimizer.c", "max_forks_repo_name": "ICML14MoMCompare/spectral-learn", "max_forks_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2015-10-02T01:32:59.000Z", "max_forks_repo_forks_event_max_datetime": "2015-10-02T01:32:59.000Z", "avg_line_length": 23.3965517241, "max_line_length": 87, "alphanum_fraction": 0.6502087939, "num_tokens": 1219, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.46101677931231594, "lm_q2_score": 0.053403330929736405, "lm_q1q2_score": 0.024619831629776864}}
{"text": "/** @file */\n#ifndef __CCL_CORE_H_INCLUDED__\n#define __CCL_CORE_H_INCLUDED__\n\n#include <stdbool.h>\n#include <stdio.h>\n#include <gsl/gsl_spline.h>\n#include <gsl/gsl_interp2d.h>\n#include <gsl/gsl_spline2d.h>\n#include <gsl/gsl_const_mksa.h>\n\n#include \"ccl_utils.h\"\n#include \"ccl_f1d.h\"\n#include \"ccl_f2d.h\"\n\nCCL_BEGIN_DECLS\n\n/**\n * Struct to hold physical constants.\n */\ntypedef struct ccl_physical_constants {\n  /**\n   * Lightspeed / H0 in units of Mpc/h (from CODATA 2014)\n   */\n  double CLIGHT_HMPC;\n\n  /**\n   * Newton's gravitational constant in units of m^3/Kg/s^2\n   */\n  double GNEWT;\n\n  /**\n   * Solar mass in units of kg (from GSL)\n   */\n  double SOLAR_MASS;\n\n  /**\n   * Mpc to meters (from PDG 2013)\n   */\n  double MPC_TO_METER;\n\n  /**\n   * pc to meters (from PDG 2013)\n   */\n  double PC_TO_METER;\n\n  /**\n   * Rho critical in units of M_sun/h / (Mpc/h)^3\n   */\n  double RHO_CRITICAL;\n\n  /**\n   * Boltzmann constant in units of J/K\n  */\n  double KBOLTZ;\n\n  /**\n   * Stefan-Boltzmann constant in units of kg/s^3 / K^4\n   */\n  double STBOLTZ;\n\n  /**\n   * Planck's constant in units kg m^2 / s\n   */\n  double HPLANCK;\n\n  /**\n   * The speed of light in m/s\n   */\n  double CLIGHT;\n\n  /**\n   * Electron volt to Joules convestion\n   */\n  double EV_IN_J;\n\n  /**\n   * Temperature of the CMB in K\n   */\n  double T_CMB;\n\n  /**\n   * T_ncdm, as taken from CLASS, explanatory.ini\n   */\n  double TNCDM;\n\n  /**\n   * neutrino mass splitting differences\n   * See Lesgourgues and Pastor, 2012 for these values.\n   * Adv. High Energy Phys. 2012 (2012) 608515,\n   * arXiv:1212.6154, page 13\n  */\n  double DELTAM12_sq;\n  double DELTAM13_sq_pos;\n  double DELTAM13_sq_neg;\n} ccl_physical_constants;\n\nextern ccl_physical_constants ccl_constants;\n\n/**\n * Struct that contains all the parameters needed to create certain splines.\n * This includes splines for the scale factor, masses, and power spectra.\n */\ntypedef struct ccl_spline_params {\n  // scale factor splines\n  int A_SPLINE_NA;\n  double A_SPLINE_MIN;\n  double A_SPLINE_MINLOG_PK;\n  double A_SPLINE_MIN_PK;\n  double A_SPLINE_MINLOG_SM;\n  double A_SPLINE_MIN_SM;\n  double A_SPLINE_MAX;\n  double A_SPLINE_MINLOG;\n  int A_SPLINE_NLOG;\n\n  //Mass splines\n  double LOGM_SPLINE_DELTA;\n  int LOGM_SPLINE_NM;\n  double LOGM_SPLINE_MIN;\n  double LOGM_SPLINE_MAX;\n\n  //PS a and k spline\n  int A_SPLINE_NA_SM;\n  int A_SPLINE_NLOG_SM;\n  int A_SPLINE_NA_PK;\n  int A_SPLINE_NLOG_PK;\n\n  //k-splines and integrals\n  double K_MAX_SPLINE;\n  double K_MAX;\n  double K_MIN;\n  double DLOGK_INTEGRATION;\n  int N_K;\n  int N_K_3DCOR;\n\n  //Correlation function parameters\n  double ELL_MIN_CORR;\n  double ELL_MAX_CORR;\n  int N_ELL_CORR;\n\n  // interpolation types\n  const gsl_interp_type* A_SPLINE_TYPE;\n  const gsl_interp_type* K_SPLINE_TYPE;\n  const gsl_interp_type* M_SPLINE_TYPE;\n  const gsl_interp_type* D_SPLINE_TYPE;\n  const gsl_interp2d_type* PNL_SPLINE_TYPE;\n  const gsl_interp2d_type* PLIN_SPLINE_TYPE;\n  const gsl_interp_type* CORR_SPLINE_TYPE;\n} ccl_spline_params;\n\nextern const ccl_spline_params default_spline_params;\n\n/**\n * Struct that contains parameters that control the accuracy of various GSL\n * routines.\n */\ntypedef struct ccl_gsl_params {\n  // General parameters\n  size_t N_ITERATION;\n\n  // Integration\n  int INTEGRATION_GAUSS_KRONROD_POINTS;\n  double INTEGRATION_EPSREL;\n  // Limber integration\n  int INTEGRATION_LIMBER_GAUSS_KRONROD_POINTS;\n  double INTEGRATION_LIMBER_EPSREL;\n  // Distance integrals\n  double INTEGRATION_DISTANCE_EPSREL;\n  // sigma_R integral\n  double INTEGRATION_SIGMAR_EPSREL;\n  // k_NL integral\n  double INTEGRATION_KNL_EPSREL;\n\n  // Root finding\n  double ROOT_EPSREL;\n  int ROOT_N_ITERATION;\n\n  // ODE\n  double ODE_GROWTH_EPSREL;\n\n  // growth\n  double EPS_SCALEFAC_GROWTH;\n\n  // halo model\n  double HM_MMIN;\n  double HM_MMAX;\n  double HM_EPSABS;\n  double HM_EPSREL;\n  size_t HM_LIMIT;\n  int HM_INT_METHOD;\n\n} ccl_gsl_params;\n\nextern const ccl_gsl_params default_gsl_params;\n\n/**\n * Struct containing the parameters defining a cosmology\n */\ntypedef struct ccl_parameters {\n\n  // Densities: CDM, baryons, total matter, neutrinos, curvature\n  double Omega_c; /**< Density of CDM relative to the critical density*/\n  double Omega_b; /**< Density of baryons relative to the critical density*/\n  double Omega_m; /**< Density of all matter relative to the critical density*/\n  double Omega_k; /**< Density of curvature relative to the critical density*/\n  double sqrtk; /**< Square root of the magnitude of curvature, k */ //TODO check\n  int k_sign; /**<Sign of the curvature k */\n\n\n  // Dark Energy\n  double w0;\n  double wa;\n\n  // Hubble parameters\n  double H0;\n  double h;\n\n  // Neutrino properties\n\n  double Neff; // Effective number of relativistic neutrino species in the early universe.\n  int N_nu_mass; // Number of species of neutrinos which are nonrelativistic today\n  double N_nu_rel;  // Number of species of neutrinos which are relativistic  today\n  double *m_nu;  // total mass of massive neutrinos (This is a pointer so that it can hold multiple masses.)\n  double sum_nu_masses; // sum of the neutrino masses.\n  double Omega_nu_mass; // Omega_nu for MASSIVE neutrinos\n  double Omega_nu_rel; // Omega_nu for MASSLESS neutrinos\n\n  // Primordial power spectra\n  double A_s;\n  double n_s;\n\n  // Radiation parameters\n  double Omega_g;\n  double T_CMB;\n\n  // BCM baryonic model parameters\n  double bcm_log10Mc;\n  double bcm_etab;\n  double bcm_ks;\n\n  // mu / Sigma quasistatica parameterisation of modified gravity params\n  double mu_0;\n  double sigma_0;\n\n  // Derived parameters\n  double sigma8;\n  double Omega_l;\n  double z_star;\n\n  //Modified growth rate\n  bool has_mgrowth;\n  int nz_mgrowth;\n  double *z_mgrowth;\n  double *df_mgrowth;\n} ccl_parameters;\n\n\n/**\n * Struct containing references to gsl splines for distance and acceleration calculations\n */\ntypedef struct ccl_data {\n  // These are all functions of the scale factor a.\n\n  // Distances are defined in Mpc\n  double growth0;\n  gsl_spline * chi;\n  gsl_spline * growth;\n  gsl_spline * fgrowth;\n  gsl_spline * E;\n  gsl_spline * achi;\n\n  // Function of Halo mass M\n  gsl_spline2d * logsigma;\n\n  // real-space splines for RSD\n  ccl_f1d_t* rsd_splines[3];\n  double rsd_splines_scalefactor;\n} ccl_data;\n\n/**\n * Sturct containing references to instances of the above structs, and boolean flags of precomputed values.\n */\ntypedef struct ccl_cosmology {\n  ccl_parameters    params;\n  ccl_configuration config;\n  ccl_data          data;\n  ccl_spline_params spline_params;\n  ccl_gsl_params    gsl_params;\n\n  bool computed_distances;\n  bool computed_growth;\n  bool computed_sigma;\n\n  int status;\n  //this is optional - less tedious than tracking all numerical values for status in error handler function\n  char status_message[500];\n\n  // other flags?\n} ccl_cosmology;\n\n// Initialization and life cycle of objects\nccl_cosmology * ccl_cosmology_create(ccl_parameters params, ccl_configuration config);\n\n/* Internal function to set the status message safely. */\nvoid ccl_cosmology_set_status_message(ccl_cosmology * cosmo, const char * status_message, ...);\n\n// User-facing creation routines\n/**\n * Create a cosmology\n * @param Omega_c Omega_c\n * @param Omega_b Omega_b\n * @param Omega_k Omega_k\n * @param Neff Number of relativistic neutrino species in the early universe\n * @param mnu neutrino mass, either sum or list of length 3\n * @param mnu_type determines neutrino mass convention (ccl_mnu_list, ccl_mnu_sum, ccl_mnu_sum_inverted, ccl_mnu_sum_equal)\n * @param w0 Dark energy EoS parameter\n * @param wa Dark energy EoS parameter\n * @param h Hubble constant in units of 100 km/s/Mpc\n * @param norm_pk the normalization of the power spectrum, either A_s or sigma8\n * @param n_s the power-law index of the power spectrum\n * @param bcm_log10Mc log10 cluster mass, one of the parameters of the BCM model\n * @param bcm_etab ejection radius parameter, one of the parameters of the BCM model\n * @param bcm_ks wavenumber for the stellar profile, one of the parameters of the BCM model\n * @param nz_mgrowth the number of redshifts where the modified growth is provided\n * @param zarr_mgrowth the array of redshifts where the modified growth is provided\n * @param dfarr_mgrowth the modified growth function vector provided\n * @param status Status flag. 0 if there are no errors, nonzero otherwise.\n * For specific cases see documentation for ccl_error.c\n * @return void\n */\nccl_parameters ccl_parameters_create(double Omega_c, double Omega_b, double Omega_k,\n\t\t\t\t     double Neff, double* mnu, int n_mnu,\n\t\t\t\t     double w0, double wa, double h, double norm_pk,\n\t\t\t\t     double n_s, double bcm_log10Mc, double bcm_etab, double bcm_ks,\n\t\t\t\t     double mu_0, double sigma_0, int nz_mgrowth, double *zarr_mgrowth,\n\t\t\t\t     double *dfarr_mgrowth, int *status);\n\n\n/**\n * Free a parameters struct\n * @param params ccl_parameters struct\n * @return void\n */\nvoid ccl_parameters_free(ccl_parameters * params);\n\n\n/**\n * Write a cosmology parameters object to a file in yaml format, .\n * @param params Cosmological parameters\n * @param filename Name of file to create and write\n * @param status Status flag. 0 if there are no errors, nonzero otherwise.\n * @return void\n */\nvoid ccl_parameters_write_yaml(ccl_parameters * params, const char * filename, int * status);\n\n/**\n * Read a cosmology parameters object from a file in yaml format, .\n * @param filename Name of existing file to read from\n * @param status Status flag. 0 if there are no errors, nonzero otherwise.\n * @return cosmo Cosmological parameters\n */\nccl_parameters ccl_parameters_read_yaml(const char * filename, int *status);\n\n/**\n * Free a cosmology struct\n * @param cosmo Cosmological parameters\n * @return void\n */\nvoid ccl_cosmology_free(ccl_cosmology * cosmo);\n\nint ccl_get_pk_spline_na(ccl_cosmology *cosmo);\nint ccl_get_pk_spline_nk(ccl_cosmology *cosmo);\nvoid ccl_get_pk_spline_a_array(ccl_cosmology *cosmo,int ndout,double* doutput,int *status);\nvoid ccl_get_pk_spline_lk_array(ccl_cosmology *cosmo,int ndout,double* doutput,int *status);\n\nCCL_END_DECLS\n\n#endif\n", "meta": {"hexsha": "4e536aa6c74b6e01dd605f1cefd1f240a04cd9ae", "size": 10021, "ext": "h", "lang": "C", "max_stars_repo_path": "include/ccl_core.h", "max_stars_repo_name": "borisbolliet/CCL", "max_stars_repo_head_hexsha": "6ddd35e49f9d2968cef3d3bc1bac8b55dbb4cf91", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/ccl_core.h", "max_issues_repo_name": "borisbolliet/CCL", "max_issues_repo_head_hexsha": "6ddd35e49f9d2968cef3d3bc1bac8b55dbb4cf91", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/ccl_core.h", "max_forks_repo_name": "borisbolliet/CCL", "max_forks_repo_head_hexsha": "6ddd35e49f9d2968cef3d3bc1bac8b55dbb4cf91", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.4406332454, "max_line_length": 123, "alphanum_fraction": 0.7386488374, "num_tokens": 2783, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48438008427698437, "lm_q2_score": 0.05033063669284357, "lm_q1q2_score": 0.024379158042993853}}
{"text": "/*\n    Copyright (C) 2008 Wei Dong <wdong@princeton.edu>. All Rights Reserved.\n\n    This file is part of LSHKIT.\n\n    LSHKIT is free software: you can redistribute it and/or modify\n    it under the terms of the GNU General Public License as published by\n    the Free Software Foundation, either version 3 of the License, or\n    (at your option) any later version.\n\n    LSHKIT is distributed in the hope that it will be useful,\n    but WITHOUT ANY WARRANTY; without even the implied warranty of\n    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n    GNU General Public License for more details.\n\n    You should have received a copy of the GNU General Public License\n    along with LSHKIT.  If not, see <http://www.gnu.org/licenses/>.\n*/\n\n/**\n *  \\file fitdata.cpp\n *  \\brief Gather statistics from dataset for MPLSH tuning.\n *\n *  This program gahters statistical data from a small sample dataset\n *  for automatic MPLSH parameter tuning.  It carries out the following\n *  steps:\n *  -# Sample N points from the dataset. Only those N points will be used for future computation.\n *  -# Sample P pairs of points from the sample, calculate the distance for each pair.\n *  -# Sample Q points from the sample as queries points.\n *  -# Divide the sample into F folds.\n *  -# For i = 1 to F, take i folds and run K-NN search, so the query points\n *     will be searched against sample datasets of N/F, 2N/F, ..., N/F points.\n *\n *  The statistical data is printed to standard output after the progress display.\n *\n\\verbatim\nAllowed options:\n  -h [ --help ]          produce help message.\n  -N [ -- ] arg (=0)     number of points to use\n  -P [ -- ] arg (=50000) number of pairs to sample\n  -Q [ -- ] arg (=1000)  number of queries to sample\n  -K [ -- ] arg (=100)   search for K nearest neighbors\n  -F [ -- ] arg (=10)    divide the sample to F folds\n  -D [ --data ] arg      data file\n\\endverbatim\n */\n\n#ifndef _MPLSH_FITDATA_H_\n#define _MPLSH_FITDATA_H_\n\n#include \"logging.h\"\n\n#include <cstdlib>\n#include <sstream>\n#include <gsl/gsl_multifit.h>\n\nnamespace lshkit {\n\ninline\nbool is_good_value (double v) {\n    return ((v > -std::numeric_limits<double>::max()) &&\n            (v < std::numeric_limits<double>::max()));\n}\n\ninline\nstd::string FitData(const FloatMatrix& data,\n                    unsigned N,            // number of points to use\n                    unsigned P,            // number of pairs to sample\n                    unsigned Q,            // number of queries to sample\n                    unsigned K,            // search for K neighbors neighbors\n                    unsigned F             // divide the sample to F folds\n                   )\n{\n    LOG(LIB_INFO) << \"started running FitData\" << std::endl;\n\n    std::vector<unsigned> idx(data.getSize());\n    for (size_t i = 0; i < idx.size(); ++i) idx[i] = i;\n    std::random_shuffle(idx.begin(), idx.end());\n\n    if (N > 0 && N < static_cast<unsigned>(data.getSize())) idx.resize(N);\n\n    metric::l2sqr<float> l2sqr(data.getDim());\n\n    DefaultRng rng;\n    boost::variate_generator<DefaultRng &, UniformUnsigned> gen(rng,\n             UniformUnsigned(0, idx.size()-1));\n\n    double gM = 0.0;\n    double gG = 0.0;\n    {\n        // sample P pairs of points\n        for (unsigned k = 0; k < P; ++k)\n        {\n            double dist, logdist;\n            for (;;)\n            {\n                unsigned i = gen();\n                unsigned j = gen();\n                if (i == j) continue;\n                dist = l2sqr(data[idx[i]], data[idx[j]]);\n                logdist = log(dist);\n                if (is_good_value(logdist)) break;\n            }\n            gM += dist;\n            gG += logdist;\n        }\n        gM /= P;\n        gG /= P;\n        gG = exp(gG);\n    }\n\n    if (Q > idx.size()) Q = idx.size();\n    if (K > idx.size() - Q) K = idx.size() - Q;\n    /* sample query */\n    std::vector<unsigned> qry(Q);\n\n    SampleQueries(&qry, idx.size(), rng);\n\n    /* do the queries */\n    std::vector<Topk<unsigned> > topks(Q);\n    for (unsigned i = 0; i < Q; ++i) topks[i].reset(K);\n\n    /* ... */\n    gsl_matrix *X = gsl_matrix_alloc(F * K, 3);\n    gsl_vector *yM = gsl_vector_alloc(F * K);\n    gsl_vector *yG = gsl_vector_alloc(F * K);\n    gsl_vector *pM = gsl_vector_alloc(3);\n    gsl_vector *pG = gsl_vector_alloc(3);\n    gsl_matrix *cov = gsl_matrix_alloc(3,3);\n\n    std::vector<double> M(K);\n    std::vector<double> G(K);\n\n    unsigned m = 0;\n    for (unsigned l = 0; l < F; l++)\n    {\n        // Scan\n        for (unsigned i = l; i< idx.size(); i += F)\n        {\n            for (unsigned j = 0; j < Q; j++)\n            {\n                unsigned id = qry[j];\n                if (i != id)\n                {\n                    float d = l2sqr(data[idx[id]], data[idx[i]]);\n                    if (is_good_value(log(double(d))))\n                      topks[j] << Topk<unsigned>::Element(i, d);\n                }\n            }\n        }\n\n        fill(M.begin(), M.end(), 0.0);\n        fill(G.begin(), G.end(), 0.0);\n\n        for (unsigned i = 0; i < Q; i++)\n        {\n            for (unsigned k = 0; k < K; k++)\n            {\n                M[k] += topks[i][k].dist;\n                G[k] += log(topks[i][k].dist);\n            }\n        }\n\n        for (unsigned k = 0; k < K; k++)\n        {\n            M[k] = log(M[k]/Q);\n            G[k] /= Q;\n            gsl_matrix_set(X, m, 0, 1.0);\n            gsl_matrix_set(X, m, 1, log(double(data.getSize() * (l + 1)) / double(F)));\n            gsl_matrix_set(X, m, 2, log(double(k + 1)));\n            gsl_vector_set(yM, m, M[k]);\n            gsl_vector_set(yG, m, G[k]);\n            ++m;\n        }\n\n        //++progress;\n    }\n\n    gsl_multifit_linear_workspace *work = gsl_multifit_linear_alloc(F * K, 3);\n\n    double chisq;\n\n    gsl_multifit_linear(X, yM, pM, cov, &chisq, work);\n    gsl_multifit_linear(X, yG, pG, cov, &chisq, work);\n\n    std::stringstream ss;\n    ss << gM << \" \" << gG << std::endl;\n    ss << gsl_vector_get(pM, 0) << \" \"\n       << gsl_vector_get(pM, 1) << \" \"\n       << gsl_vector_get(pM, 2) << std::endl;\n    ss << gsl_vector_get(pG, 0) << \" \"\n       << gsl_vector_get(pG, 1) << \" \"\n       << gsl_vector_get(pG, 2) << std::endl;\n\n    gsl_matrix_free(X);\n    gsl_matrix_free(cov);\n    gsl_vector_free(pM);\n    gsl_vector_free(pG);\n    gsl_vector_free(yM);\n    gsl_vector_free(yG);\n\n    LOG(LIB_INFO) << ss.str(); \n    LOG(LIB_INFO) << \"finished FitData\";\n\n    return ss.str();\n}\n\n}     // namespace lshkit\n\n#endif\n", "meta": {"hexsha": "c4db8a575d054e5d400daf0d9c8b6fb317973e66", "size": 6465, "ext": "h", "lang": "C", "max_stars_repo_path": "algorithms/NMSLIB/code/lshkit/include/lshkit/multiprobelsh-fitdata.h", "max_stars_repo_name": "sourabhpoddar404/nns_benchmark", "max_stars_repo_head_hexsha": "44cdd81ab984c87c2246a0464a7ac93321c58815", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 150.0, "max_stars_repo_stars_event_min_datetime": "2016-06-03T16:39:13.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-24T05:32:56.000Z", "max_issues_repo_path": "algorithms/NMSLIB/code/lshkit/include/lshkit/multiprobelsh-fitdata.h", "max_issues_repo_name": "sourabhpoddar404/nns_benchmark", "max_issues_repo_head_hexsha": "44cdd81ab984c87c2246a0464a7ac93321c58815", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 7.0, "max_issues_repo_issues_event_min_datetime": "2016-06-03T13:43:21.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-28T07:42:02.000Z", "max_forks_repo_path": "algorithms/NMSLIB/code/lshkit/include/lshkit/multiprobelsh-fitdata.h", "max_forks_repo_name": "sourabhpoddar404/nns_benchmark", "max_forks_repo_head_hexsha": "44cdd81ab984c87c2246a0464a7ac93321c58815", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 42.0, "max_forks_repo_forks_event_min_datetime": "2016-05-18T05:53:00.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-27T19:57:52.000Z", "avg_line_length": 30.6398104265, "max_line_length": 97, "alphanum_fraction": 0.5415313225, "num_tokens": 1765, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4843800842769843, "lm_q2_score": 0.0503306329535957, "lm_q1q2_score": 0.02437915623177665}}
{"text": "#ifndef SOURCE_UTILS_H_\n#define SOURCE_UTILS_H_\n\n// *** source/utils.h ***\n// Author: Kevin Wolz, date: 08/2018\n//\n// Various utilities used in the code.\n\n#include <fstream>\n#include <iostream>\n#include <iomanip>\n#include <sstream>\n#include <vector>\n#include <string>\n#include <unistd.h>\n#include <algorithm>\n#include <stdlib.h>\n#include <sys/stat.h>\n#include <time.h>\n\n#include <gsl/gsl_math.h>\n#include <gsl/gsl_matrix.h>\n#include <gsl/gsl_vector.h>\n#include <gsl/gsl_blas.h>\n#include <gsl/gsl_linalg.h>\n#include <gsl/gsl_cblas.h>\n#include <gsl/gsl_eigen.h>\n#include <gsl/gsl_integration.h>\n#include <gsl/gsl_sort_vector.h>\n#include <gsl/gsl_permutation.h>\n#include <gsl/gsl_histogram.h>\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_roots.h>\n#include <gsl/gsl_cdf.h>\n\n\nstd::string Timestamp();\n\ndouble get_signum(double x);\n\nvoid PrintGslVector(gsl_vector* vector);\n\nvoid PrintGslVector(gsl_vector* vector, std::string label);\n\nvoid PrintGslMatrix(gsl_matrix* matrix);\n\nvoid PrintGslMatrix(gsl_matrix* matrix, std::string label);\n\nbool file_exists(const std::string& filename);\n\nvoid AppendTwoGslVectors(gsl_vector* vector1, gsl_vector* vector2, \n                         gsl_vector* new_vector);\n\nvoid ConcatenateTwoGslMatrices(gsl_matrix* mmatrix1, gsl_matrix* matrix2,\n                               gsl_matrix* new_matrix, bool vertical_axis);\n\nvoid BlockDiagFromTwoGslMatrices(gsl_matrix* matrix1, gsl_matrix* matrix2,\n                                 gsl_matrix* new_matrix, unsigned int dimnew1,\n                                 unsigned int dimnew2);\n\nvoid SubtractTwoDoubleVectors(const std::vector<double> &vector1,\n                              const std::vector<double> &vector2,\n                              std::vector<double> &difference);\n\ndouble GslVec1MatVec2(gsl_vector* vector1, gsl_matrix* matrix,\n                      gsl_vector* vector2, int dim);\n\nvoid InvertGslMatrix(gsl_matrix* tobeinverted, unsigned int dim, \n                     gsl_matrix* inverted);\n\ndouble DeterminantGslMatrix(gsl_matrix* square_matrix, unsigned int dim);\n\ndouble Vec1MatVec2(std::vector<double> vector1, gsl_matrix* matrix,\n                   std::vector<double> vector2, int dim);\n\ndouble TraceGslMatrix(gsl_matrix* square_matrix, int dim);\n\nvoid MultiplyFourGslMatrices(gsl_matrix* matrix1, gsl_matrix* matrix2,\n                             gsl_matrix* matrix3, gsl_matrix* matrix4,\n                             int dim, gsl_matrix* resulting_matrix);\n\nvoid MultiplyThreeGslMatrices(gsl_matrix* matrix1, gsl_matrix* matrix2,\n                              gsl_matrix* matrix3, int dim, \n                              gsl_matrix* resulting_matrix);\n\n#endif // SOURCE_UTILS_H_\n", "meta": {"hexsha": "fbdd3642a4708ea56c46ca728debcbeef8727ca1", "size": 2682, "ext": "h", "lang": "C", "max_stars_repo_path": "source/utils.h", "max_stars_repo_name": "kevguitar/Robustness", "max_stars_repo_head_hexsha": "ab83a09a82fcc7f8ee10027b3ccb24194731b4ac", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "source/utils.h", "max_issues_repo_name": "kevguitar/Robustness", "max_issues_repo_head_hexsha": "ab83a09a82fcc7f8ee10027b3ccb24194731b4ac", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "source/utils.h", "max_forks_repo_name": "kevguitar/Robustness", "max_forks_repo_head_hexsha": "ab83a09a82fcc7f8ee10027b3ccb24194731b4ac", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.8275862069, "max_line_length": 78, "alphanum_fraction": 0.6759880686, "num_tokens": 643, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4610167793123159, "lm_q2_score": 0.05261895706184315, "lm_q1q2_score": 0.02425822211542397}}
{"text": "/* ode-initval/gsl_odeiv.h\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Author:  G. Jungman\n */\n#ifndef __GSL_ODEIV_H__\n#define __GSL_ODEIV_H__\n\n#if !defined( GSL_FUN )\n#  if !defined( GSL_DLL )\n#    define GSL_FUN extern\n#  elif defined( BUILD_GSL_DLL )\n#    define GSL_FUN extern __declspec(dllexport)\n#  else\n#    define GSL_FUN extern __declspec(dllimport)\n#  endif\n#endif\n\n#include <stdio.h>\n#include <stdlib.h>\n#include <gsl/gsl_types.h>\n\n#undef __BEGIN_DECLS\n#undef __END_DECLS\n#ifdef __cplusplus\n# define __BEGIN_DECLS extern \"C\" {\n# define __END_DECLS }\n#else\n# define __BEGIN_DECLS /* empty */\n# define __END_DECLS /* empty */\n#endif\n\n__BEGIN_DECLS\n\n\n/* Description of a system of ODEs.\n *\n * y' = f(t,y) = dydt(t, y)\n *\n * The system is specified by giving the right-hand-side\n * of the equation and possibly a jacobian function.\n *\n * Some methods require the jacobian function, which calculates\n * the matrix dfdy and the vector dfdt. The matrix dfdy conforms\n * to the GSL standard, being a continuous range of floating point\n * values, in row-order.\n *\n * As with GSL function objects, user-supplied parameter\n * data is also present. \n */\n\ntypedef struct  \n{\n  int (* function) (double t, const double y[], double dydt[], void * params);\n  int (* jacobian) (double t, const double y[], double * dfdy, double dfdt[], void * params);\n  size_t dimension;\n  void * params;\n}\ngsl_odeiv_system;\n\n#define GSL_ODEIV_FN_EVAL(S,t,y,f)  (*((S)->function))(t,y,f,(S)->params)\n#define GSL_ODEIV_JA_EVAL(S,t,y,dfdy,dfdt)  (*((S)->jacobian))(t,y,dfdy,dfdt,(S)->params)\n\n\n/* General stepper object.\n *\n * Opaque object for stepping an ODE system from t to t+h.\n * In general the object has some state which facilitates\n * iterating the stepping operation.\n */\n\ntypedef struct \n{\n  const char * name;\n  int can_use_dydt_in;\n  int gives_exact_dydt_out;\n  void * (*alloc) (size_t dim);\n  int  (*apply)  (void * state, size_t dim, double t, double h, double y[], double yerr[], const double dydt_in[], double dydt_out[], const gsl_odeiv_system * dydt);\n  int  (*reset) (void * state, size_t dim);\n  unsigned int  (*order) (void * state);\n  void (*free)  (void * state);\n}\ngsl_odeiv_step_type;\n\ntypedef struct {\n  const gsl_odeiv_step_type * type;\n  size_t dimension;\n  void * state;\n}\ngsl_odeiv_step;\n\n\n/* Available stepper types.\n *\n * rk2    : embedded 2nd(3rd) Runge-Kutta\n * rk4    : 4th order (classical) Runge-Kutta\n * rkck   : embedded 4th(5th) Runge-Kutta, Cash-Karp\n * rk8pd  : embedded 8th(9th) Runge-Kutta, Prince-Dormand\n * rk2imp : implicit 2nd order Runge-Kutta at Gaussian points\n * rk4imp : implicit 4th order Runge-Kutta at Gaussian points\n * gear1  : M=1 implicit Gear method\n * gear2  : M=2 implicit Gear method\n */\n\nGSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rk2;\nGSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rk4;\nGSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rkf45;\nGSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rkck;\nGSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rk8pd;\nGSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rk2imp;\nGSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rk2simp;\nGSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_rk4imp;\nGSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_bsimp;\nGSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_gear1;\nGSL_VAR const gsl_odeiv_step_type *gsl_odeiv_step_gear2;\n\n\n/* Constructor for specialized stepper objects.\n */\nGSL_FUN gsl_odeiv_step * gsl_odeiv_step_alloc(const gsl_odeiv_step_type * T, size_t dim);\nGSL_FUN int  gsl_odeiv_step_reset(gsl_odeiv_step * s);\nGSL_FUN void gsl_odeiv_step_free(gsl_odeiv_step * s);\n\n/* General stepper object methods.\n */\nGSL_FUN const char * gsl_odeiv_step_name(const gsl_odeiv_step * s);\nGSL_FUN unsigned int gsl_odeiv_step_order(const gsl_odeiv_step * s);\n\nGSL_FUN int  gsl_odeiv_step_apply(gsl_odeiv_step * s, double t, double h, double y[], double yerr[], const double dydt_in[], double dydt_out[], const gsl_odeiv_system * dydt);\n\n/* General step size control object.\n *\n * The hadjust() method controls the adjustment of\n * step size given the result of a step and the error.\n * Valid hadjust() methods must return one of the codes below.\n *\n * The general data can be used by specializations\n * to store state and control their heuristics.\n */\n\ntypedef struct \n{\n  const char * name;\n  void * (*alloc) (void);\n  int  (*init) (void * state, double eps_abs, double eps_rel, double a_y, double a_dydt);\n  int  (*hadjust) (void * state, size_t dim, unsigned int ord, const double y[], const double yerr[], const double yp[], double * h);\n  void (*free) (void * state);\n}\ngsl_odeiv_control_type;\n\ntypedef struct \n{\n  const gsl_odeiv_control_type * type;\n  void * state;\n}\ngsl_odeiv_control;\n\n/* Possible return values for an hadjust() evolution method.\n */\n#define GSL_ODEIV_HADJ_INC   1  /* step was increased */\n#define GSL_ODEIV_HADJ_NIL   0  /* step unchanged     */\n#define GSL_ODEIV_HADJ_DEC (-1) /* step decreased     */\n\nGSL_FUN gsl_odeiv_control * gsl_odeiv_control_alloc(const gsl_odeiv_control_type * T);\nGSL_FUN int gsl_odeiv_control_init(gsl_odeiv_control * c, double eps_abs, double eps_rel, double a_y, double a_dydt);\nGSL_FUN void gsl_odeiv_control_free(gsl_odeiv_control * c);\nGSL_FUN int gsl_odeiv_control_hadjust (gsl_odeiv_control * c, gsl_odeiv_step * s, const double y[], const double yerr[], const double dydt[], double * h);\nGSL_FUN const char * gsl_odeiv_control_name(const gsl_odeiv_control * c);\n\n/* Available control object constructors.\n *\n * The standard control object is a four parameter heuristic\n * defined as follows:\n *    D0 = eps_abs + eps_rel * (a_y |y| + a_dydt h |y'|)\n *    D1 = |yerr|\n *    q  = consistency order of method (q=4 for 4(5) embedded RK)\n *    S  = safety factor (0.9 say)\n *\n *                      /  (D0/D1)^(1/(q+1))  D0 >= D1\n *    h_NEW = S h_OLD * |\n *                      \\  (D0/D1)^(1/q)      D0 < D1\n *\n * This encompasses all the standard error scaling methods.\n *\n * The y method is the standard method with a_y=1, a_dydt=0.\n * The yp method is the standard method with a_y=0, a_dydt=1.\n */\n\nGSL_FUN gsl_odeiv_control * gsl_odeiv_control_standard_new(double eps_abs, double eps_rel, double a_y, double a_dydt);\nGSL_FUN gsl_odeiv_control * gsl_odeiv_control_y_new(double eps_abs, double eps_rel);\nGSL_FUN gsl_odeiv_control * gsl_odeiv_control_yp_new(double eps_abs, double eps_rel);\n\n/* This controller computes errors using different absolute errors for\n * each component\n *\n *    D0 = eps_abs * scale_abs[i] + eps_rel * (a_y |y| + a_dydt h |y'|)\n */\nGSL_FUN gsl_odeiv_control * gsl_odeiv_control_scaled_new(double eps_abs, double eps_rel, double a_y, double a_dydt, const double scale_abs[], size_t dim);\n\n/* General evolution object.\n */\ntypedef struct {\n  size_t dimension;\n  double * y0;\n  double * yerr;\n  double * dydt_in;\n  double * dydt_out;\n  double last_step;\n  unsigned long int count;\n  unsigned long int failed_steps;\n}\ngsl_odeiv_evolve;\n\n/* Evolution object methods.\n */\nGSL_FUN gsl_odeiv_evolve * gsl_odeiv_evolve_alloc(size_t dim);\nGSL_FUN int gsl_odeiv_evolve_apply(gsl_odeiv_evolve * e, gsl_odeiv_control * con, gsl_odeiv_step * step, const gsl_odeiv_system * dydt, double * t, double t1, double * h, double y[]);\nGSL_FUN int gsl_odeiv_evolve_reset(gsl_odeiv_evolve * e);\nGSL_FUN void gsl_odeiv_evolve_free(gsl_odeiv_evolve * e);\n\n\n__END_DECLS\n\n#endif /* __GSL_ODEIV_H__ */\n", "meta": {"hexsha": "0019c74d4f6f15e947cf6d45a9befb41486ef374", "size": 8145, "ext": "h", "lang": "C", "max_stars_repo_path": "Chimera/3rd_Party/GSL_MSVC/gsl/gsl_odeiv.h", "max_stars_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_stars_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-09-28T08:20:20.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-28T08:20:20.000Z", "max_issues_repo_path": "Chimera/3rd_Party/GSL_MSVC/gsl/gsl_odeiv.h", "max_issues_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_issues_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chimera/3rd_Party/GSL_MSVC/gsl/gsl_odeiv.h", "max_forks_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_forks_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-10-14T12:45:35.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-14T12:45:35.000Z", "avg_line_length": 33.7966804979, "max_line_length": 183, "alphanum_fraction": 0.7321055862, "num_tokens": 2400, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4649015713733885, "lm_q2_score": 0.051845468297913956, "lm_q1q2_score": 0.024103039680289397}}
{"text": "/*\n * author: Achim Gaedke\n * created: January 2002\n * file: pygsl/src/multiminmodule.c\n * $Id: multiminmodule.c,v 1.5 2004/03/08 08:42:16 schnizer Exp $\n */\n#include <setjmp.h>\n#include <pygsl/block_helpers.h>\n#include <pygsl/error_helpers.h>\n#include <pygsl/function_helpers.h>\n\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_multimin.h>\n#include \"multiminmodule_doc.h\"\n/* \n * I have two different types to minimize and I am too lazy to implement the same\n * twice. Therefore I use unions and add a flag to the minimizer for the type\n */\n\nunion pygsl_multimin_minimizer_type{\n     const gsl_multimin_fminimizer_type   *f; \n     const gsl_multimin_fdfminimizer_type *fdf; \n};\n\nunion pygsl_multimin_minimizer{\n     gsl_multimin_fminimizer   *f; \n     gsl_multimin_fdfminimizer *fdf; \n};\n\nunion pygsl_multimin_func{\n     gsl_multimin_function     *f; \n     gsl_multimin_function_fdf *fdf; \n};\n\nstruct pygsl_solver_types{\n     const char * f_minimizer;\n     const char * fdf_minimizer;\n};\nstatic struct pygsl_solver_types my_solvers = {\"F-Minimizer\", \"Fdf-Minimizer\"};\n\n/* \n *  type: \n *\t == 0 -> f \n *\t != 0 -> fdf\n */\ntypedef struct {\n     PyObject_HEAD\n     PyObject* py_f;\n     PyObject* py_df;\n     PyObject* py_fdf;\n     PyObject* trailing_params;\n     union pygsl_multimin_func      func;\n     union pygsl_multimin_minimizer min;\n     size_t n;\n     const char *mytype;\n     int isset; /* Used as a flag if the jmp_buf is set */\n     jmp_buf buffer;\n} PyGSL_multimin;\n\n#define PyGSL_multimin_check(op)  ((op)->ob_type == &PyGSL_multimin_pytype)\n#define PyGSL_multimin_isf(op)    ((op)->mytype  == my_solvers.f_minimizer)\n\n\nstatic void\nPyGSL_multimin_dealloc(PyGSL_multimin* self);\nstatic PyObject*\nPyGSL_multimin_getattr(PyGSL_multimin * obj, char *name);\n\n\n\nPyTypeObject PyGSL_multimin_pytype = {\n  PyObject_HEAD_INIT(NULL)\t /* fix up the type slot in initcrng */\n  0,\t\t\t\t /* ob_size */\n  \"PyGSL_multimin\",\t\t /* tp_name */\n  sizeof(PyGSL_multimin),\t /* tp_basicsize */\n  0,\t\t\t\t /* tp_itemsize */\n\n  /* standard methods */\n  (destructor)  PyGSL_multimin_dealloc, /* tp_dealloc  ref-count==0  */\n  (printfunc)   0,\t\t /* tp_print    \"print x\"     */\n  (getattrfunc) PyGSL_multimin_getattr,/* tp_getattr  \"x.attr\"      */\n  (setattrfunc) 0,\t\t /* tp_setattr  \"x.attr=v\"    */\n  (cmpfunc)     0,\t\t   /* tp_compare  \"x > y\"       */\n  (reprfunc)    0,                 /* tp_repr     `x`, print x  */\n\n  /* type categories */\n  0,\t\t\t\t/* tp_as_number   +,-,*,/,%,&,>>,pow...*/\n  0,\t\t\t\t/* tp_as_sequence +,[i],[i:j],len, ...*/\n  0,\t\t\t\t/* tp_as_mapping  [key], len, ...*/\n\n  /* more methods */\n  (hashfunc)     0,\t\t/* tp_hash    \"dict[x]\" */\n  (ternaryfunc)  0,      /* tp_call    \"x()\"     */\n  (reprfunc)     0,             /* tp_str     \"str(x)\"  */\n  (getattrofunc) 0,\t\t/* tp_getattro */\n  (setattrofunc) 0,\t\t/* tp_setattro */\n  0,\t\t\t\t/* tp_as_buffer */\n  0L,\t\t\t\t/* tp_flags */\n  (char *) PyGSL_multimin_type_doc\t\t/* tp_doc */\n};\n\n\n/* Reference to this module */\nPyObject *module = NULL;\nstatic const char filename[] = __FILE__;\n\n/* The Callbacks */\ndouble \nPyGSL_multimin_function_f(const gsl_vector* x, void* params) \n{\n     double result;\n     int flag;\n     int i;\n\n     FUNC_MESS_BEGIN();     \n     PyGSL_multimin *min_o;     \n     min_o = (PyGSL_multimin *) params;\n     assert(PyGSL_multimin_check(min_o));     \n     for(i = 0; i<x->size; i++){\n\t  DEBUG_MESS(2, \"Got a x[%d] of %f\", i, gsl_vector_get(x, i));\n     }\n     flag = PyGSL_function_wrap_On_O(x, min_o->py_f, min_o->trailing_params, &result,\n\t\t\t\t     NULL, x->size, __FUNCTION__);\n     if (flag!= GSL_SUCCESS){\n\t  result = gsl_nan();\n\t  if(min_o->isset == 1) longjmp(min_o->buffer,flag);\t  \n     }  \n     DEBUG_MESS(2, \"Got a result of %f\", result);\n     FUNC_MESS_END();\n     return result;\n}\n\nvoid \nPyGSL_multimin_function_df(const gsl_vector* x, void* params, gsl_vector *df)\n{\n     int flag, i;\n     PyGSL_multimin *min_o;     \n     min_o = (PyGSL_multimin *) params;\n\n     FUNC_MESS_BEGIN();\n     assert(PyGSL_multimin_check(min_o));     \n     for(i = 0; i<x->size; i++){\n\t  DEBUG_MESS(2, \"Got a x[%d] of %f\", i, gsl_vector_get(x, i));\n     }\n     flag = PyGSL_function_wrap_Op_On(x, df, min_o->py_df, min_o->trailing_params,\n\t\t\t\t      x->size, x->size, __FUNCTION__);\n     for(i = 0; i<df->size; i++){\n\t  DEBUG_MESS(2, \"Got df x[%d] of %f\", i, gsl_vector_get(df, i));\n     }\n     if(flag!=GSL_SUCCESS){\n\t  if(min_o->isset == 1) longjmp(min_o->buffer,flag);\t  \n     }\n     FUNC_MESS_END();\n} \nvoid \nPyGSL_multimin_function_fdf(const gsl_vector* x, void* params, double *f, gsl_vector *df)\n{\n     int flag, i;\n     PyGSL_multimin *min_o;     \n\n     FUNC_MESS_BEGIN();\n     min_o = (PyGSL_multimin *) params;\n     assert(PyGSL_multimin_check(min_o));     \n     for(i = 0; i<x->size; i++){\n\t  DEBUG_MESS(2, \"Got a x[%d] of %f\", i, gsl_vector_get(x, i));\n     }\n     flag = PyGSL_function_wrap_On_O(x, min_o->py_fdf, min_o->trailing_params, f,\n\t\t\t\t     df, x->size, __FUNCTION__);\n     DEBUG_MESS(2, \"Got a result of %f\", *f);\n     for(i = 0; i<df->size; i++){\n\t  DEBUG_MESS(2, \"Got df x[%d] of %f\", i, gsl_vector_get(df, i));\n     }\n     if (flag!= GSL_SUCCESS){\n\t  *f = gsl_nan();\n\t  if(min_o->isset == 1) longjmp(min_o->buffer,flag);  \n     }  \n     FUNC_MESS_END();\n     return;\n}\n\nstatic PyObject* \nPyGSL_multimin_set_f(PyGSL_multimin *self, PyObject *args, PyObject *kw) \n{\n\n     PyObject* func = NULL, * params = NULL, * x = NULL, * steps = NULL;\n     PyArrayObject * xa = NULL, * stepsa = NULL;\n     int n=0, flag=GSL_EFAILED;\n     int stride_recalc;\n     gsl_vector_view gsl_x;\n     gsl_vector_view gsl_steps;\n     static const char *kwlist[] = {\"f\", \"x0\", \"args\", \"steps\", NULL};\n\n     FUNC_MESS_BEGIN();\n     assert(PyGSL_multimin_check(self));     \n     if (self->min.f == NULL) {\n\t  gsl_error(\"Got a NULL Pointer of min.f\",  filename, __LINE__ - 3, GSL_EFAULT);\n\t  return NULL;\n     }\n\n     assert(args);\n     /* arguments PyFunction, Parameters, start Vector, step Vector */\n     if (0==PyArg_ParseTupleAndKeywords(args,kw,\"OOOO\", (char **) kwlist, &func,&x,&params,&steps))\n\t  return NULL;\n\n     if(!PyCallable_Check(func)){\n\t  gsl_error(\"First argument must be callable\",  filename, __LINE__ - 3, GSL_EBADFUNC);\n\t  return NULL;\t  \n     }\n     n=self->n;\n     xa  = PyGSL_PyArray_PREPARE_gsl_vector_view(x, PyArray_DOUBLE, 0, n, 4, NULL);\n     if (xa == NULL){\n\t  PyGSL_add_traceback(module, filename, __FUNCTION__, __LINE__ - 1);\n\t  goto fail;\n     }\n     if(PyGSL_STRIDE_RECALC(xa->strides[0],sizeof(double), &stride_recalc) != GSL_SUCCESS)\n\t  goto fail;\n\n     gsl_x = gsl_vector_view_array_with_stride((double *)(xa->data), stride_recalc, xa->dimensions[0]);\n     stepsa =  PyGSL_PyArray_PREPARE_gsl_vector_view(steps, PyArray_DOUBLE, 0, n, 5, NULL);\n     if (stepsa == NULL){\n\t  PyGSL_add_traceback(module, filename, __FUNCTION__, __LINE__ - 1);\n\t  goto fail;\n     }\n     if(PyGSL_STRIDE_RECALC(stepsa->strides[0],sizeof(double), &stride_recalc) != GSL_SUCCESS)\n\t  goto fail;\n\n     gsl_steps = gsl_vector_view_array_with_stride((double *)(stepsa->data), stride_recalc, stepsa->dimensions[0]);\n\n     if (self->func.f != NULL) {\n\t  /* free the previous function and params */\n\t  Py_XDECREF(self->trailing_params);\n\t  Py_XDECREF(self->py_f);\n     } else {\n\t  /* allocate function space */\n\t  self->func.f=calloc(1, sizeof(gsl_multimin_function));\n\t  if (self->func.f==NULL) {\n\t       gsl_error(\"Could not allocate the object for the minimizer function\", \n\t\t\t filename, __LINE__ - 3, GSL_ENOMEM);\n\t       goto fail;\n\t  }\n     }\n     /* add new function  and parameters */\n     self->trailing_params=params;\n     Py_INCREF(params);\n     self->py_f=func;\n     Py_INCREF(func);\n     \n     /* initialize the function struct */\n     self->func.f->n=n;\n     self->func.f->f=PyGSL_multimin_function_f;\n     self->func.f->params=(void*)self;\n     \n     if((flag = setjmp(self->buffer)) == 0){\n\t  self->isset = 1;\n\t  flag = gsl_multimin_fminimizer_set(self->min.f,self->func.f, &gsl_x.vector, &gsl_steps.vector);\n\t  if(PyGSL_ERROR_FLAG(flag) != GSL_SUCCESS){\n\t       goto fail;\n\t  }\n     } else {\n\t  goto fail;\n     }\n     Py_DECREF(xa);\n     Py_DECREF(stepsa);\n\n     Py_INCREF(Py_None);\n     self->isset = 0;\n     FUNC_MESS_END();\n     return Py_None;\n\n     \n fail:\n     FUNC_MESS(\"Fail\");\n     PyGSL_ERROR_FLAG(flag);\n     self->isset = 0;\n     Py_XDECREF(xa);\n     Py_XDECREF(stepsa);\n     return NULL;\n     \n}\nstatic PyObject* \nPyGSL_multimin_set_fdf(PyGSL_multimin *self, PyObject *args, PyObject *kw) \n{\n\n     PyObject * f = NULL, * df = NULL, * fdf = NULL, * params = NULL,\n\t      * x = NULL;\n     PyArrayObject * xa = NULL;\n     int n=0, flag=GSL_EFAILED;\n     int stride_recalc=-1;\n     double step=0.01, tol=1e-4;\n     gsl_vector_view gsl_x;\n     static const char *kwlist[] = {\"f\", \"df\", \"fdf\",  \"x0\", \"args\", \"step\", \"tol\", NULL};\n\n     FUNC_MESS_BEGIN();\n     assert(PyGSL_multimin_check(self));     \n     if (self->min.fdf == NULL) {\n\t  gsl_error(\"Got a NULL Pointer of min.fdf\", filename, __LINE__ - 3, GSL_EFAULT);\n\t       return NULL;\n\t  }\t  \n\n     /* arguments PyFunction, Parameters, start Vector, step Vector */\n     if (0==PyArg_ParseTupleAndKeywords(args, kw, \"OOOO|Odd\", (char **)kwlist, \n\t\t\t\t\t&f, &df, &fdf, &x, &params, &step, &tol))\n\t  return NULL;\n\n     n=self->n;\n     xa  = PyGSL_PyArray_PREPARE_gsl_vector_view(x, PyArray_DOUBLE, 0, n, 4, NULL);\n     if (xa == NULL){\n\t  PyGSL_add_traceback(module, filename, __FUNCTION__, __LINE__ - 1);\n\t  goto fail;\n     }\n     if(params == NULL){\n          /* Reference counter increased later, when the parameters are set */\n\t  params = Py_None; \n     }\n     if(PyGSL_STRIDE_RECALC(xa->strides[0],sizeof(double), &stride_recalc) != GSL_SUCCESS)\n\t  goto fail;\n     gsl_x = gsl_vector_view_array_with_stride((double *)(xa->data), stride_recalc, xa->dimensions[0]);\n\n     if (self->func.fdf != NULL) {\n\t  /* free the previous function and params */\n\t  Py_XDECREF(self->trailing_params);\n\t  Py_XDECREF(self->py_f);\n\t  Py_XDECREF(self->py_df);\n\t  Py_XDECREF(self->py_fdf);\n     } else {\n\t  /* allocate function space */\n\t  self->func.fdf=malloc(sizeof(gsl_multimin_function_fdf));\n\t  if (self->func.fdf==NULL) {\n\t       gsl_error(\"Could not allocate the object for the minimizer function\", \n\t\t\t filename, __LINE__ - 3, GSL_ENOMEM);\n\t       goto fail;\n\t  }\n     }\n     /* add new function  and parameters */\n     self->trailing_params=params;     Py_INCREF(params);\n     self->py_f=f;                     Py_INCREF(f);\n     self->py_df=df;                   Py_INCREF(df);\n     self->py_fdf=fdf;                 Py_INCREF(fdf);\n     \n     /* initialize the function struct */\n     self->func.fdf->n=n;\n     self->func.fdf->f  =PyGSL_multimin_function_f;\n     self->func.fdf->df =PyGSL_multimin_function_df;  \n     self->func.fdf->fdf=PyGSL_multimin_function_fdf;\n     self->func.fdf->params=(void*)self;\n\n     if((flag = setjmp(self->buffer)) == 0){\n\t  self->isset = 1;\t  \n\t  flag = gsl_multimin_fdfminimizer_set(self->min.fdf,self->func.fdf, &gsl_x.vector, step, tol);\n\t  if(PyGSL_ERROR_FLAG(flag) != GSL_SUCCESS){\n\t       goto fail;\n\t  }\n     }else{\n\t  goto fail;\n     }\n     self->isset = 0;\n     Py_DECREF(xa);\n\n     Py_INCREF(Py_None);\n     FUNC_MESS_END();\n     return Py_None;\n\n fail:\n     PyGSL_ERROR_FLAG(flag);\n     self->isset = 0;\n     Py_XDECREF(xa);\n     return NULL;\n     \n}\n/*\nstatic PyObject* \nPyGSL_multimin_set(PyGSL_multimin *self, PyObject *args) \n{\n\n     if(PyGSL_multimin_isf(self)){       \n\t  return PyGSL_multimin_set_f(self, args);\n     }else {\n\t  return PyGSL_multimin_set_fdf(self, args);\n     }  \n}\n*/\nstatic PyObject* \nPyGSL_multimin_iterate(PyGSL_multimin *self, PyObject *args) \n{\n     int result, flag;\n\n     FUNC_MESS_BEGIN();\n     assert(PyGSL_multimin_check(self));     \n     if ( self->min.f ==NULL || self->func.f ==NULL) {\n\t  gsl_error(\"Got a NULL Pointer of min.f\", filename, __LINE__ - 3, GSL_EFAULT);\n\t  return NULL;\n     }\n\n     if((flag = setjmp(self->buffer)) == 0){\n\t  self->isset = 1;\t      \n\t  if(PyGSL_multimin_isf(self)){       \n\t       result = gsl_multimin_fminimizer_iterate(self->min.f);\n\t  } else {\n\t       result = gsl_multimin_fdfminimizer_iterate(self->min.fdf);\n\t  }\n     } else {\n\t  PyGSL_ERROR_FLAG(flag);\n\t  self->isset = 0;\n\t  return NULL;\n     }\n     self->isset = 0;\n     FUNC_MESS_END();\n     return PyGSL_error_flag_to_pyint(result);\n}\n\n\nstatic PyObject* \nPyGSL_multimin_x(PyGSL_multimin *self, PyObject *args) \n{\n     gsl_vector* result;\n     \n     FUNC_MESS_BEGIN();\n     assert(PyGSL_multimin_check(self));     \n     if (self->min.f==NULL || self->func.f==NULL) {\n\t  gsl_error(\"Got a NULL Pointer for min.f\", filename, __LINE__ - 3, GSL_EFAULT);\n\t  return NULL;\n     }\n     if(PyGSL_multimin_isf(self)){       \n\t  result=gsl_multimin_fminimizer_x(self->min.f);\n     } else {\n\t  result=gsl_multimin_fdfminimizer_x(self->min.fdf);\n     }\n     if (result==NULL) {\n\t  gsl_error(\"How could that happen?\",  filename, __LINE__ - 3, GSL_ESANITY);\n\t  return NULL;\n     }\n     FUNC_MESS_END();\n     return (PyObject *) PyGSL_copy_gslvector_to_pyarray(result);\n}\n\nstatic PyObject* \nPyGSL_multimin_minimum(PyGSL_multimin *self, PyObject *args) \n{\n     double min;\n\n     FUNC_MESS_BEGIN();\n     assert(PyGSL_multimin_check(self));     \n     if (self->min.f == NULL || self->func.f ==NULL) {\n\t  gsl_error(\"Got a NULL Pointer of min.f\", filename, __LINE__ - 3, GSL_EFAULT);\n\t  return NULL;\n     }\n     if(PyGSL_multimin_isf(self)){       \n\t  min = gsl_multimin_fminimizer_minimum(self->min.f);\n     } else {\n\t  min = gsl_multimin_fdfminimizer_minimum(self->min.fdf);\n     }\n     FUNC_MESS_END();\n     return PyFloat_FromDouble(min);\n}\n\nstatic PyObject* \nPyGSL_multimin_name(PyGSL_multimin *self, PyObject *args) \n{\n     const char * name;\n     FUNC_MESS_BEGIN();\n     assert(PyGSL_multimin_check(self));     \n     if(PyGSL_multimin_isf(self)){       \n\t  name = gsl_multimin_fminimizer_name(self->min.f);\n     } else {\n\t  name = gsl_multimin_fdfminimizer_name(self->min.fdf);\n     }\n     FUNC_MESS_END();\n     return PyString_FromString(name);\n}\n\nstatic PyObject* \nPyGSL_multimin_size(PyGSL_multimin *self, PyObject *args) \n{\n     double size;\n     FUNC_MESS_BEGIN();\n     assert(PyGSL_multimin_check(self));     \n     if ( self->min.f ==NULL || self->func.f ==NULL) {\n\t  PyErr_SetString(PyExc_RuntimeError,\"no function specified!\");\n\t  return NULL;\n     }\n     if(PyGSL_multimin_isf(self)){       \n\t  size = gsl_multimin_fminimizer_size(self->min.f);\n     } else {\n\t  gsl_error(\"Can not calculate size for a FDF\", filename, __LINE__, GSL_ESANITY);\n\t  return NULL;\n     }\n     FUNC_MESS_END();\n     return PyFloat_FromDouble(size);\n}\n\nstatic PyObject* \nPyGSL_multimin_test_size_method(PyGSL_multimin *self, PyObject *args) \n{\n     int flag=GSL_EFAILED;\n     double epsabs;\n\n     FUNC_MESS_BEGIN();\n     assert(PyGSL_multimin_check(self));     \n     if ( self->min.f ==NULL || self->func.f ==NULL) {\n\t  PyErr_SetString(PyExc_RuntimeError,\"no function specified!\");\n\t  return NULL;\n     }\n\n     if(PyGSL_multimin_isf(self)){\n\t  if (0==PyArg_ParseTuple(args,\"d\", &epsabs))\n\t       return NULL;            \n\t  flag = gsl_multimin_test_size(gsl_multimin_fminimizer_size(self->min.f), epsabs);\n     } else {\n\t  gsl_error(\"Can not calculate size for a FDF\", filename, __LINE__, GSL_ESANITY);\n\t  return NULL;\n     }\n\n     FUNC_MESS_END();\n     return PyGSL_ERROR_FLAG_TO_PYINT(flag);\n}\n\nstatic PyObject* \nPyGSL_multimin_restart(PyGSL_multimin *self, PyObject *args) \n{\n     int flag;\n\n     FUNC_MESS_BEGIN();\n     assert(PyGSL_multimin_check(self));     \n     if(PyGSL_multimin_isf(self)){       \n\t  gsl_error(\"Can not restart for a F type solver\", filename, __LINE__, GSL_ESANITY);\n\t  return NULL;\n     }\n     flag = gsl_multimin_fdfminimizer_restart(self->min.fdf);\n\n     if(PyGSL_ERROR_FLAG(flag) != GSL_SUCCESS){\n\t  return NULL;\n     }\n     FUNC_MESS_END();\n     Py_INCREF(Py_None);\n     return Py_None;\n}\nstatic PyObject* \nPyGSL_multimin_vec_fdf(PyGSL_multimin *self, PyObject *args, \n\t\t       gsl_vector *(*func)(gsl_multimin_fdfminimizer * s))\n{\n     gsl_vector *result;\n     FUNC_MESS_BEGIN();\n     assert(PyGSL_multimin_check(self));     \n     if(PyGSL_multimin_isf(self)){       \n\t  gsl_error(\"Can not retrieve this information for a F type solver!\", filename, __LINE__, GSL_ESANITY);\n\t  return NULL;\n     } else {\n\t  result=func(self->min.fdf);\n     }\n     FUNC_MESS_END();\n     return (PyObject *) PyGSL_copy_gslvector_to_pyarray(result);\n} \n\nstatic PyObject* \nPyGSL_multimin_istype(PyGSL_multimin *self, PyObject *args)\n{\n     static const char *f = \"F-Minimizer\",  *fdf = \"Fdf-Minimizer\";\n     const char *p;\n\n     FUNC_MESS_BEGIN();\n     assert(PyGSL_multimin_check(self));     \n     if(PyGSL_multimin_isf(self)){ \n\t  p = f;\n     } else {\n\t  p = fdf;\n     }\n     FUNC_MESS_END();\n     return PyString_FromString(p);\n}\n\nstatic PyObject* \nPyGSL_multimin_dx(PyGSL_multimin *self, PyObject *args)\n{\n     return PyGSL_multimin_vec_fdf(self, args, gsl_multimin_fdfminimizer_dx);\n}\n\nstatic PyObject* \nPyGSL_multimin_gradient(PyGSL_multimin *self, PyObject *args)\n{\n     return PyGSL_multimin_vec_fdf(self, args, gsl_multimin_fdfminimizer_gradient);\n}\n\nstatic PyObject*\nPyGSL_multimin_test_gradient_method(PyGSL_multimin * self, PyObject *args)\n{\n\n     double epsabs;\n     int flag;\n     FUNC_MESS_BEGIN();\n\n     assert(PyGSL_multimin_check(self));     \n     if (0==PyArg_ParseTuple(args,\"d\", &epsabs))\n\t  return NULL;     \n\n     if(PyGSL_multimin_isf(self)){       \n\t  gsl_error(\"Can not retrieve this information for a F type solver!\", filename, __LINE__, GSL_ESANITY);\n\t  return NULL;\n     }\n     flag = gsl_multimin_test_gradient(gsl_multimin_fdfminimizer_gradient(self->min.fdf), epsabs);\n     FUNC_MESS_END();\n     return PyGSL_ERROR_FLAG_TO_PYINT(flag);\n     \n}\n\n#define PyGSL_MULTIMIN_COMMON_METHODS  \\\n  {\"iterate\",     (PyCFunction)PyGSL_multimin_iterate,METH_NOARGS,(char *)multimin_iterate_doc,}, \\\n  {\"x\",           (PyCFunction)PyGSL_multimin_x,      METH_NOARGS,(char *)multimin_x_doc,      }, \\\n  {\"minimum\",     (PyCFunction)PyGSL_multimin_minimum,METH_NOARGS,(char *)multimin_minimum_doc,}, \\\n  {\"name\",        (PyCFunction)PyGSL_multimin_name,   METH_NOARGS,(char *)multimin_name_doc,   }, \\\n  {\"type\",        (PyCFunction)PyGSL_multimin_istype, METH_NOARGS,(char *)multimin_istype_doc, },\n\nstatic PyMethodDef PyGSL_multimin_fmethods[] = {\n     PyGSL_MULTIMIN_COMMON_METHODS\n     {\"set\",      (PyCFunction)PyGSL_multimin_set_f,           METH_VARARGS|METH_KEYWORDS, (char *)multimin_set_f_doc    },     \n     {\"size\",     (PyCFunction)PyGSL_multimin_size,            METH_NOARGS,  (char *)multimin_size_doc     },\n     {\"test_size\",(PyCFunction)PyGSL_multimin_test_size_method,METH_VARARGS, (char *)multimin_test_size_doc},\n     {NULL, NULL, 0, NULL}           /* sentinel */\n};\n\nstatic PyMethodDef PyGSL_multimin_fdfmethods[] = {\n     PyGSL_MULTIMIN_COMMON_METHODS\n     {\"set\",      (PyCFunction)PyGSL_multimin_set_fdf,                 METH_VARARGS|METH_KEYWORDS, (char *)multimin_set_fdf_doc      },     \n     {\"restart\",  (PyCFunction)PyGSL_multimin_restart,                 METH_NOARGS,  (char *)multimin_restart_doc      },     \n     {\"dx\",       (PyCFunction)PyGSL_multimin_dx,                      METH_NOARGS,  (char *)multimin_dx_doc           },     \n     {\"gradient\", (PyCFunction)PyGSL_multimin_gradient,                METH_NOARGS,  (char *)multimin_gradient_doc     },     \n     {\"test_gradient\",(PyCFunction)PyGSL_multimin_test_gradient_method,METH_VARARGS, (char *)multimin_test_gradient_doc},     \n     {NULL, NULL, 0, NULL}           /* sentinel */\n};\n\nstatic PyObject* \nPyGSL_multimin_init(PyObject *self, PyObject *args, \n\t\t    union pygsl_multimin_minimizer_type type, int t) \n{\n\n     PyGSL_multimin *min_o=NULL;\n     size_t n;\n     /* static const char functionname [] = __FUNCTION__; */\n\n     FUNC_MESS_BEGIN();     \n     min_o =  (PyGSL_multimin *) PyObject_NEW(PyGSL_multimin, &PyGSL_multimin_pytype);\n     if(min_o == NULL){\n\t  return NULL;\n     }\n\n     if (0==PyArg_ParseTuple(args,\"l\", &n))\n\t  return NULL;\n\n\n     if (n<=0) {\n\t  PyErr_SetString(PyExc_RuntimeError, \"dimension must be >0\");\n\t  return NULL;\n     }\n     min_o->n=n;\n     min_o->min.f=NULL;\n     min_o->min.fdf=NULL;\n     min_o->func.f=NULL;\n     min_o->func.fdf=NULL;\n     min_o->py_f=NULL;\n     min_o->py_df=NULL;\n     min_o->py_fdf=NULL;\n     min_o->trailing_params=NULL;\n     min_o->mytype=NULL;\n\n     if(t == 0){\n\t  min_o->min.f = gsl_multimin_fminimizer_alloc(type.f,n);\n\t  if (min_o->min.f == NULL) {\n\t\tgsl_error(\"Could not allocate the object for the minimizer\", \n\t\t\t  filename, __LINE__ - 3, GSL_ENOMEM);\n\t       goto fail;\n\t  }\n\t  min_o->mytype = my_solvers.f_minimizer;\n\t  assert(PyGSL_multimin_isf(min_o));\n     } else {\n\t  min_o->min.fdf = gsl_multimin_fdfminimizer_alloc(type.fdf,n);\n\t  if (min_o->min.fdf == NULL) {\n\t\tgsl_error(\"Could not allocate the object for the fdfminimizer\", \n\t\t\t  filename, __LINE__ - 3, GSL_ENOMEM);\n\t       goto fail;\n\t  }\n\t  min_o->mytype = my_solvers.fdf_minimizer;\n\t  assert(!PyGSL_multimin_isf(min_o));\n     }\n     FUNC_MESS_END();\n     return (PyObject *) min_o;\n fail:\n     Py_XDECREF(min_o);\n     return NULL;\n}\n\n#define AMINIMIZER(name)                                                      \\\nstatic PyObject* PyGSL_multimin_init_ ## name (PyObject *self, PyObject *args)\\\n{                                                                             \\\n     PyObject *tmp = NULL;                                                    \\\n     union pygsl_multimin_minimizer_type type;                                \\\n     FUNC_MESS_BEGIN();                                                       \\\n     type.f  = gsl_multimin_fminimizer_ ## name;                              \\\n     tmp = PyGSL_multimin_init(self, args, type, 0);                          \\\n     if (tmp == NULL){                                                        \\\n\t  PyGSL_add_traceback(module, (char *) filename, __FUNCTION__, __LINE__);      \\\n     }                                                                        \\\n     FUNC_MESS_END();                                                         \\\n     return tmp;                                                              \\\n}\n#define AMINIMIZER_FDF(name)                                                  \\\nstatic PyObject* PyGSL_multimin_init_ ## name (PyObject *self, PyObject *args)\\\n{                                                                             \\\n     PyObject *tmp = NULL;                                                    \\\n     union pygsl_multimin_minimizer_type type;                                \\\n     FUNC_MESS_BEGIN();                                                       \\\n     type.fdf  = gsl_multimin_fdfminimizer_ ## name;                          \\\n     tmp = PyGSL_multimin_init(self, args,  type, 1);                         \\\n     if (tmp == NULL){                                                        \\\n\t  PyGSL_add_traceback(module, (char *) filename, __FUNCTION__, __LINE__);      \\\n     }                                                                        \\\n     FUNC_MESS_END();                                                         \\\n     return tmp;                                                              \\\n}\n\nAMINIMIZER(nmsimplex)\nAMINIMIZER_FDF(steepest_descent)\nAMINIMIZER_FDF(vector_bfgs)\nAMINIMIZER_FDF(conjugate_pr)\nAMINIMIZER_FDF(conjugate_fr)\n\n\n\nstatic void\nPyGSL_multimin_dealloc(PyGSL_multimin *self)\n{\n     FUNC_MESS_BEGIN();\n     assert(PyGSL_multimin_check(self));     \n     if(PyGSL_multimin_isf(self)){\n\t  if (self->min.f  != NULL)   gsl_multimin_fminimizer_free(self->min.f);\n\t  if (self->func.f != NULL)  free(self->func.f); \n     }else{\n\t  if (self->min.fdf  != NULL)   gsl_multimin_fdfminimizer_free(self->min.fdf);\n\t  if (self->func.fdf != NULL)  free(self->func.fdf); \n     }\n\n     Py_XDECREF(self->trailing_params);     \n     Py_XDECREF(self->py_f);     \n     Py_XDECREF(self->py_df);     \n     Py_XDECREF(self->py_fdf);     \n     PyMem_Free(self);\n     FUNC_MESS_END();\n}\n\n\nstatic PyObject*\nPyGSL_multimin_getattr(PyGSL_multimin *self, char *name)\n{\n\n     PyObject *tmp = NULL;\n\n\n     FUNC_MESS_BEGIN();\n     assert(PyGSL_multimin_check(self));     \n     if(PyGSL_multimin_isf(self)){\n\t  tmp = Py_FindMethod(PyGSL_multimin_fmethods, (PyObject *) self, name);\n     } else {\n\t  tmp = Py_FindMethod(PyGSL_multimin_fdfmethods, (PyObject *) self, name);\n     }\n     FUNC_MESS_END();\n     return tmp;\n}\n\n\n\n\nstatic PyObject*\nPyGSL_multimin_test_size(PyObject * self, PyObject *args)\n{\n     double size, epsabs;\n     int flag = GSL_EFAILED;\n     FUNC_MESS_BEGIN();\n     if (0==PyArg_ParseTuple(args,\"dd\", &size, &epsabs))\n\t  return NULL;     \n     flag = gsl_multimin_test_size(size, epsabs);\n     FUNC_MESS_END();\n     return PyGSL_ERROR_FLAG_TO_PYINT(flag);\n     \n}\n\nstatic PyObject*\nPyGSL_multimin_test_gradient(PyObject * self, PyObject *args)\n{\n     PyObject *g=NULL;\n     PyArrayObject *ga=NULL;\n     gsl_vector_view gradient;\n\n     double epsabs;\n     int flag = GSL_EFAILED, stride_recalc=-1;\n\n     FUNC_MESS_BEGIN();\n     if (0==PyArg_ParseTuple(args,\"Od\", &g, &epsabs))\n\t  return NULL;     \n\n     ga  = PyGSL_PyArray_PREPARE_gsl_vector_view(g, PyArray_DOUBLE, 0, -1, 1, NULL);\n     if (ga == NULL){\n\t  PyGSL_add_traceback(module, filename, __FUNCTION__, __LINE__ - 1);\n\t  return NULL;\n     }\n     if((PyGSL_STRIDE_RECALC(ga->strides[0],sizeof(double), &stride_recalc)) != GSL_SUCCESS){\n\t  Py_XDECREF(ga);\n\t  return NULL;\n     }\n     gradient = gsl_vector_view_array_with_stride((double *)(ga->data), stride_recalc, ga->dimensions[0]);\n\n     flag = gsl_multimin_test_gradient(&gradient.vector, epsabs);\n     FUNC_MESS_END();\n     return PyGSL_ERROR_FLAG_TO_PYINT(flag);\n     \n}\n\n\n\n\nstatic PyMethodDef multiminMethods[] = {\n     {\"nmsimplex\",        PyGSL_multimin_init_nmsimplex,        METH_VARARGS, (char *)nmsimplex_doc       },\n     {\"steepest_descent\", PyGSL_multimin_init_steepest_descent, METH_VARARGS, (char *)steepest_descent_doc},\n     {\"vector_bfgs\",      PyGSL_multimin_init_vector_bfgs,      METH_VARARGS, (char *)vector_bfgs_doc     },\n     {\"conjugate_pr\",     PyGSL_multimin_init_conjugate_pr,     METH_VARARGS, (char *)conjugate_pr_doc    },\n     {\"conjugate_fr\",     PyGSL_multimin_init_conjugate_fr,     METH_VARARGS, (char *)conjugate_fr_doc    },\n     {\"test_size\",        PyGSL_multimin_test_size,             METH_VARARGS, (char *)test_size_doc       },\n     {\"test_gradient\",    PyGSL_multimin_test_gradient,         METH_VARARGS, (char *)test_gradient_doc   },\n     {NULL, NULL, 0, NULL}        /* Sentinel */\n};\n\n\n\nvoid\ninitmultimin(void)\n{\n  PyObject* m, *dict, *item;\n  m=Py_InitModule(\"multimin\", multiminMethods);\n  import_array();\n  init_pygsl();\n  /* init multimin type */\n  PyGSL_multimin_pytype.ob_type  = &PyType_Type;\n\n\n  module = m;\n\n  Py_INCREF((PyObject*)&PyGSL_multimin_pytype);\n\n  dict = PyModule_GetDict(m);\n  if(!dict)\n       goto fail;\n  \n  if (!(item = PyString_FromString((char*)PyGSL_multimin_module_doc))){\n       PyErr_SetString(PyExc_ImportError, \n\t\t       \"I could not generate module doc string!\");\n       goto fail;\n  }\n  if (PyDict_SetItemString(dict, \"__doc__\", item) != 0){\n       PyErr_SetString(PyExc_ImportError, \n\t\t       \"I could not init doc string!\");\n       goto fail;\n  }\n\n fail:\n  return;\n}\n", "meta": {"hexsha": "96e6562364d3b6e3cd22b2de8d2fb6f5605f115c", "size": 27317, "ext": "c", "lang": "C", "max_stars_repo_path": "production/pygsl-0.9.5/testing/src/multiminmodule.c", "max_stars_repo_name": "juhnowski/FishingRod", "max_stars_repo_head_hexsha": "457e7afb5cab424296dff95e1acf10ebf70d32a9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "production/pygsl-0.9.5/testing/src/multiminmodule.c", "max_issues_repo_name": "juhnowski/FishingRod", "max_issues_repo_head_hexsha": "457e7afb5cab424296dff95e1acf10ebf70d32a9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "production/pygsl-0.9.5/testing/src/multiminmodule.c", "max_forks_repo_name": "juhnowski/FishingRod", "max_forks_repo_head_hexsha": "457e7afb5cab424296dff95e1acf10ebf70d32a9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2018-10-02T06:18:07.000Z", "max_forks_repo_forks_event_max_datetime": "2018-10-02T06:18:07.000Z", "avg_line_length": 31.6168981481, "max_line_length": 140, "alphanum_fraction": 0.6160266501, "num_tokens": 7747, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.46879062662624377, "lm_q2_score": 0.051082739846285856, "lm_q1q2_score": 0.023947109622325737}}
{"text": "#include <stdio.h>\n#include <stdlib.h>\n#include <stdarg.h>\n#include <math.h>\n#include <string.h>\n\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_odeiv.h>\n#include <gsl/gsl_spline.h>\n#include <gsl/gsl_integration.h>\n\n#include \"ccl.h\"\n#include \"ccl_params.h\"\n\n//\n// Macros for replacing relative paths\n#define EXPAND_STR(s) STRING(s)\n#define STRING(s) #s\n\n\nconst ccl_configuration default_config = {ccl_boltzmann_class, ccl_halofit, ccl_nobaryons, ccl_tinker10, ccl_duffy2008, ccl_emu_strict};\n\nconst ccl_gsl_params default_gsl_params = {GSL_EPSREL,                          // EPSREL\n                                           GSL_N_ITERATION,                     // N_ITERATION\n                                           GSL_INTEGRATION_GAUSS_KRONROD_POINTS,// INTEGRATION_GAUSS_KRONROD_POINTS\n                                           GSL_EPSREL,                          // INTEGRATION_EPSREL\n                                           GSL_INTEGRATION_GAUSS_KRONROD_POINTS,// INTEGRATION_LIMBER_GAUSS_KRONROD_POINTS\n                                           GSL_EPSREL,                          // INTEGRATION_LIMBER_EPSREL\n                                           GSL_EPSREL_DIST,                     // INTEGRATION_DISTANCE_EPSREL\n                                           GSL_EPSREL_DNDZ,                     // INTEGRATION_DNDZ_EPSREL\n                                           GSL_EPSREL_SIGMAR,                   // INTEGRATION_SIGMAR_EPSREL\n                                           GSL_EPSREL_NU,                       // INTEGRATION_NU_EPSREL\n                                           GSL_EPSABS_NU,                       // INTEGRATION_NU_EPSABS\n                                           GSL_EPSREL,                          // ROOT_EPSREL\n                                           GSL_N_ITERATION,                     // ROOT_N_ITERATION\n                                           GSL_EPSREL_GROWTH                    // ODE_GROWTH_EPSREL\n                                          };\n\n/* ------- ROUTINE: ccl_cosmology_read_config ------\n   INPUTS: none, but will look for ini file in include/ dir\n   TASK: fill out global variables of splines with user defined input.\n   The variables are defined in ccl_params.h.\n\n   The following are the relevant global variables:\n*/\n\nccl_spline_params * ccl_splines=NULL; // Global variable\nccl_gsl_params * ccl_gsl=NULL; // Global variable\n\nvoid ccl_cosmology_read_config(void)\n{\n\n  int CONFIG_LINE_BUFFER_SIZE=100;\n  int MAX_CONFIG_VAR_LEN=100;\n  FILE *fconfig;\n  char buf[CONFIG_LINE_BUFFER_SIZE];\n  char var_name[MAX_CONFIG_VAR_LEN];\n  char* rtn;\n  double var_dbl;\n\n  // Get parameter .ini filename from environment variable or default location\n  const char* param_file;\n  const char* param_file_env = getenv(\"CCL_PARAM_FILE\");\n  if (param_file_env != NULL) {\n    param_file = param_file_env;\n  }\n  else {\n    // Use default ini file\n    param_file = EXPAND_STR(__CCL_DATA_DIR__) \"/ccl_params.ini\";\n  }\n  if ((fconfig=fopen(param_file, \"r\")) == NULL) {\n    ccl_raise_exception(CCL_ERROR_MISSING_CONFIG_FILE, \"ccl_core.c: Failed to open config file: %s\", param_file);\n    return;\n  }\n\n  if(ccl_splines == NULL) {\n    ccl_splines = malloc(sizeof(ccl_spline_params));\n  }\n  if(ccl_gsl == NULL) {\n    ccl_gsl = malloc(sizeof(ccl_gsl_params));\n    memcpy(ccl_gsl, &default_gsl_params, sizeof(ccl_gsl_params));\n  }\n\n  /* Exit gracefully if we couldn't allocate memory */\n  if(ccl_splines==NULL || ccl_gsl==NULL) {\n    ccl_raise_exception(CCL_ERROR_MEMORY, \"ccl_core.c: Failed to allocate memory for config file data.\");\n    return;\n  }\n\n#define MATCH(s, action) if (0 == strcmp(var_name, s)) { action ; continue;} do{} while(0)\n\n  int lineno = 0;\n  while(! feof(fconfig)) {\n    rtn = fgets(buf, CONFIG_LINE_BUFFER_SIZE, fconfig);\n    lineno ++;\n\n    if (buf[0]==';' || buf[0]=='[' || buf[0]=='\\n') {\n      continue;\n    }\n    else {\n      sscanf(buf, \"%99[^=]=%le\\n\",var_name, &var_dbl);\n\n      // Spline parameters\n      MATCH(\"A_SPLINE_NA\", ccl_splines->A_SPLINE_NA=(int) var_dbl);\n      MATCH(\"A_SPLINE_NLOG\", ccl_splines->A_SPLINE_NLOG=(int) var_dbl);\n      MATCH(\"A_SPLINE_MINLOG\", ccl_splines->A_SPLINE_MINLOG=var_dbl);\n      MATCH(\"A_SPLINE_MIN\", ccl_splines->A_SPLINE_MIN=var_dbl);\n      MATCH(\"A_SPLINE_MINLOG_PK\", ccl_splines->A_SPLINE_MINLOG_PK=var_dbl);\n      MATCH(\"A_SPLINE_MIN_PK\", ccl_splines->A_SPLINE_MIN_PK=var_dbl);\n      MATCH(\"A_SPLINE_MAX\", ccl_splines->A_SPLINE_MAX=var_dbl);\n      MATCH(\"LOGM_SPLINE_DELTA\", ccl_splines->LOGM_SPLINE_DELTA=var_dbl);\n      MATCH(\"LOGM_SPLINE_NM\", ccl_splines->LOGM_SPLINE_NM=(int) var_dbl);\n      MATCH(\"LOGM_SPLINE_MIN\", ccl_splines->LOGM_SPLINE_MIN=var_dbl);\n      MATCH(\"LOGM_SPLINE_MAX\", ccl_splines->LOGM_SPLINE_MAX=var_dbl);\n      MATCH(\"A_SPLINE_NA_PK\", ccl_splines->A_SPLINE_NA_PK=(int) var_dbl);\n      MATCH(\"A_SPLINE_NLOG_PK\", ccl_splines->A_SPLINE_NLOG_PK=(int) var_dbl);\n      MATCH(\"K_MAX_SPLINE\", ccl_splines->K_MAX_SPLINE=var_dbl);\n      MATCH(\"K_MAX\", ccl_splines->K_MAX=var_dbl);\n      MATCH(\"K_MIN\", ccl_splines->K_MIN=var_dbl);\n      MATCH(\"N_K\", ccl_splines->N_K=(int) var_dbl);\n\n      // 3dcorr parameters\n      MATCH(\"N_K_3DCOR\", ccl_splines->N_K_3DCOR=(int) var_dbl);\n\n      // GSL parameters\n      MATCH(\"GSL_EPSREL\", ccl_gsl->EPSREL=var_dbl);\n      MATCH(\"GSL_N_ITERATION\", ccl_gsl->N_ITERATION=(size_t) var_dbl);\n      MATCH(\"GSL_INTEGRATION_GAUSS_KRONROD_POINTS\", ccl_gsl->INTEGRATION_GAUSS_KRONROD_POINTS=(int) var_dbl);\n      MATCH(\"GSL_INTEGRATION_EPSREL\", ccl_gsl->INTEGRATION_EPSREL=var_dbl);\n      MATCH(\"GSL_INTEGRATION_DISTANCE_EPSREL\", ccl_gsl->INTEGRATION_DISTANCE_EPSREL=var_dbl);\n      MATCH(\"GSL_INTEGRATION_DNDZ_EPSREL\", ccl_gsl->INTEGRATION_DNDZ_EPSREL=var_dbl);\n      MATCH(\"GSL_INTEGRATION_SIGMAR_EPSREL\", ccl_gsl->INTEGRATION_SIGMAR_EPSREL=var_dbl);\n      MATCH(\"GSL_INTEGRATION_NU_EPSREL\", ccl_gsl->INTEGRATION_NU_EPSREL=var_dbl);\n      MATCH(\"GSL_INTEGRATION_NU_EPSABS\", ccl_gsl->INTEGRATION_NU_EPSABS=var_dbl);\n      MATCH(\"GSL_INTEGRATION_LIMBER_GAUSS_KRONROD_POINTS\", ccl_gsl->INTEGRATION_LIMBER_GAUSS_KRONROD_POINTS=(int) var_dbl);\n      MATCH(\"GSL_INTEGRATION_LIMBER_EPSREL\", ccl_gsl->INTEGRATION_LIMBER_EPSREL=var_dbl);\n      MATCH(\"GSL_ROOT_EPSREL\", ccl_gsl->ROOT_EPSREL=var_dbl);\n      MATCH(\"GSL_ROOT_N_ITERATION\", ccl_gsl->ROOT_N_ITERATION=(int) var_dbl);\n      MATCH(\"GSL_ODE_GROWTH_EPSREL\", ccl_gsl->ODE_GROWTH_EPSREL=var_dbl);\n\n      ccl_raise_exception(CCL_ERROR_MISSING_CONFIG_FILE, \"ccl_core.c: Failed to parse config file at line %d: %s\", lineno, buf);\n    }\n  }\n#undef MATCH\n\n  fclose(fconfig);\n}\n\n\n/* ------- ROUTINE: ccl_cosmology_create ------\nINPUTS: ccl_parameters params\n        ccl_configuration config\nTASK: creates the ccl_cosmology struct and passes some values to it\nDEFINITIONS:\nchi: comoving distance [Mpc]\ngrowth: growth function (density)\nfgrowth: logarithmic derivative of the growth (density) (dlnD/da?)\nE: E(a)=H(a)/H0\naccelerator: interpolation accelerator for functions of a\naccelerator_achi: interpolation accelerator for functions of chi\ngrowth0: growth at z=0, defined to be 1\nsigma: ?\np_lin: linear matter power spectrum at z=0?\np_lnl: nonlinear matter power spectrum at z=0?\ncomputed_distances, computed_growth,\ncomputed_power, computed_sigma: store status of the computations\n*/\nccl_cosmology * ccl_cosmology_create(ccl_parameters params, ccl_configuration config)\n{\n  ccl_cosmology * cosmo = malloc(sizeof(ccl_cosmology));\n  cosmo->params = params;\n  cosmo->config = config;\n\n  cosmo->data.chi = NULL;\n  cosmo->data.growth = NULL;\n  cosmo->data.fgrowth = NULL;\n  cosmo->data.E = NULL;\n  cosmo->data.accelerator=NULL;\n  cosmo->data.accelerator_achi=NULL;\n  cosmo->data.accelerator_m=NULL;\n  cosmo->data.accelerator_d=NULL;\n  cosmo->data.accelerator_k=NULL;\n  cosmo->data.growth0 = 1.;\n  cosmo->data.achi=NULL;\n\n  cosmo->data.logsigma = NULL;\n  cosmo->data.dlnsigma_dlogm = NULL;\n\n  // hmf parameter for interpolation\n  cosmo->data.alphahmf = NULL;\n  cosmo->data.betahmf = NULL;\n  cosmo->data.gammahmf = NULL;\n  cosmo->data.phihmf = NULL;\n  cosmo->data.etahmf = NULL;\n\n  cosmo->data.p_lin = NULL;\n  cosmo->data.p_nl = NULL;\n  //cosmo->data.nu_pspace_int = NULL;\n  cosmo->computed_distances = false;\n  cosmo->computed_growth = false;\n  cosmo->computed_power = false;\n  cosmo->computed_sigma = false;\n  cosmo->computed_hmfparams = false;\n  cosmo->status = 0;\n  ccl_cosmology_set_status_message(cosmo, \"\");\n\n  return cosmo;\n}\n\n/* ------ ROUTINE: ccl_parameters_fill_initial -------\nINPUT: ccl_parameters: params\nTASK: fill parameters not set by ccl_parameters_create with some initial values\nDEFINITIONS:\nOmega_g = (Omega_g*h^2)/h^2 is the radiation parameter; \"g\" is for photons, as in CLASS\nT_CMB: CMB temperature in Kelvin\nOmega_l: Lambda\nA_s: amplitude of the primordial PS, enforced here to initially set to NaN\nsigma8: variance in 8 Mpc/h spheres for normalization of matter PS, enforced here to initially set to NaN\nz_star: recombination redshift\n */\nvoid ccl_parameters_fill_initial(ccl_parameters * params, int *status)\n{\n  // Fixed radiation parameters\n  // Omega_g * h**2 is known from T_CMB\n  params->T_CMB =  TCMB;\n  // kg / m^3\n  double rho_g = 4. * STBOLTZ / pow(CLIGHT, 3) * pow(params->T_CMB, 4);\n  // kg / m^3\n  double rho_crit = RHO_CRITICAL * SOLAR_MASS/pow(MPC_TO_METER, 3) * pow(params->h, 2);\n  params->Omega_g = rho_g/rho_crit;\n\n  // Get the N_nu_rel from Neff and N_nu_mass\n  params->N_nu_rel = params->Neff - params->N_nu_mass * pow(TNCDM, 4) / pow(4./11.,4./3.);\n\n  // Temperature of the relativistic neutrinos in K\n  double T_nu= (params->T_CMB) * pow(4./11.,1./3.);\n  // in kg / m^3\n  double rho_nu_rel = params->N_nu_rel* 7.0/8.0 * 4. * STBOLTZ / pow(CLIGHT, 3) * pow(T_nu, 4);\n  params-> Omega_n_rel = rho_nu_rel/rho_crit;\n\n  // If non-relativistic neutrinos are present, calculate the phase_space integral.\n  if((params->N_nu_mass)>0) {\n    // Pass NULL for the accelerator here because we don't have our cosmology object defined yet.\n    params->Omega_n_mass = ccl_Omeganuh2(1.0, params->N_nu_mass, params->mnu, params->T_CMB, NULL, status) / ((params->h)*(params->h));\n    ccl_check_status_nocosmo(status);\n  }\n  else{\n    params->Omega_n_mass = 0.;\n  }\n\n  params->Omega_m = params->Omega_b + params-> Omega_c;\n  params->Omega_l = 1.0 - params->Omega_m - params->Omega_g - params->Omega_n_rel -params->Omega_n_mass- params->Omega_k;\n  // Initially undetermined parameters - set to nan to trigger\n  // problems if they are mistakenly used.\n  if (isfinite(params->A_s)) {params->sigma8 = NAN;}\n  if (isfinite(params->sigma8)) {params->A_s = NAN;}\n  params->z_star = NAN;\n\n  if(fabs(params->Omega_k)<1E-6)\n    params->k_sign=0;\n  else if(params->Omega_k>0)\n    params->k_sign=-1;\n  else\n    params->k_sign=1;\n  params->sqrtk=sqrt(fabs(params->Omega_k))*params->h/CLIGHT_HMPC;\n}\n\n\n/* ------ ROUTINE: ccl_parameters_create -------\nINPUT: numbers for the basic cosmological parameters needed by CCL\nTASK: fill params with some initial values provided by the user\nDEFINITIONS:\nOmega_c: cold dark matter\nOmega_b: baryons\nOmega_m: matter\nOmega_k: curvature\nlittle omega_x means Omega_x*h^2\nNeff : Effective number of neutrino speces\nmnu : Pointer to either sum of neutrino masses or list of three masses.\nmnu_type : how the neutrino mass(es) should be treated\nw0: Dark energy eq of state parameter\nwa: Dark energy eq of state parameter, time variation\nH0: Hubble's constant in km/s/Mpc.\nh: Hubble's constant divided by (100 km/s/Mpc).\nA_s: amplitude of the primordial PS\nn_s: index of the primordial PS\n\n */\nccl_parameters ccl_parameters_create(\n                     double Omega_c, double Omega_b, double Omega_k,\n\t\t\t\t     double Neff, double* mnu, ccl_mnu_convention mnu_type,\n\t\t\t\t     double w0, double wa, double h, double norm_pk,\n\t\t\t\t     double n_s, double bcm_log10Mc, double bcm_etab,\n\t\t\t\t     double bcm_ks, int nz_mgrowth, double *zarr_mgrowth,\n\t\t\t\t     double *dfarr_mgrowth, int *status)\n{\n  #ifndef USE_GSL_ERROR\n    gsl_set_error_handler_off ();\n  #endif\n\n  ccl_parameters params;\n  // Initialize params\n  params.mnu = NULL;\n  params.z_mgrowth=NULL;\n  params.df_mgrowth=NULL;\n  params.sigma8 = NAN;\n  params.A_s = NAN;\n  params.Omega_c = Omega_c;\n  params.Omega_b = Omega_b;\n  params.Omega_k = Omega_k;\n  params.Neff = Neff;\n\n  // Set the sum of neutrino masses\n  params.sum_nu_masses = *mnu;\n  double mnusum = *mnu;\n  double *mnu_in = NULL;\n\n  /* Check whether ccl_splines and ccl_gsl exist. If either is not set yet, load\n     parameters from the config file. */\n  if(ccl_splines==NULL || ccl_gsl==NULL) {\n    ccl_cosmology_read_config();\n  }\n\n  // Decide how to split sum of neutrino masses between 3 neutrinos. We use\n  // a Newton's rule numerical solution (thanks M. Jarvis).\n\n  if (mnu_type==ccl_mnu_sum){\n\t  // Normal hierarchy\n\n\t  mnu_in = malloc(3*sizeof(double));\n\n\t  // Check if the sum is zero\n\t  if (*mnu<1e-15){\n\t\t  mnu_in[0] = 0.;\n\t\t  mnu_in[1] = 0.;\n\t\t  mnu_in[2] = 0.;\n\t  } else{\n\n\t      mnu_in[0] = 0.; // This is a starting guess.\n\n\t      double sum_check;\n\t      // Check that sum is consistent\n\t      mnu_in[1] = sqrt(DELTAM12_sq);\n\t      mnu_in[2] = sqrt(DELTAM13_sq_pos);\n\t      sum_check = mnu_in[0] + mnu_in[1] + mnu_in[2];\n\t      if (ccl_mnu_sum < sum_check){\n\t\t      *status = CCL_ERROR_MNU_UNPHYSICAL;\n          }\n\n          double dsdm1;\n          // This is the Newton's method\n          while (fabs(*mnu - sum_check) > 1e-15){\n\n              dsdm1 = 1. + mnu_in[0] / mnu_in[1] + mnu_in[0] / mnu_in[2];\n              mnu_in[0] = mnu_in[0] - (sum_check - *mnu) / dsdm1;\n              mnu_in[1] = sqrt(mnu_in[0]*mnu_in[0] + DELTAM12_sq);\n              mnu_in[2] = sqrt(mnu_in[0]*mnu_in[0] + DELTAM13_sq_pos);\n              sum_check = mnu_in[0] + mnu_in[1] + mnu_in[2];\n          }\n\t  }\n\n  } else if (mnu_type==ccl_mnu_sum_inverted){\n\t  // Inverted hierarchy\n\n\t  mnu_in = malloc(3*sizeof(double));\n\n\t  \t  // Check if the sum is zero\n\t  if (*mnu<1e-15){\n\t\t  mnu_in[0] = 0.;\n\t\t  mnu_in[1] = 0.;\n\t\t  mnu_in[2] = 0.;\n\t  } else{\n\n\t      mnu_in[0] = 0.; // This is a starting guess.\n\n\t      double sum_check;\n\t      // Check that sum is consistent\n\t      mnu_in[1] = sqrt(-1.* DELTAM13_sq_neg - DELTAM12_sq);\n\t      mnu_in[2] = sqrt(-1.* DELTAM13_sq_neg);\n\t      sum_check = mnu_in[0] + mnu_in[1] + mnu_in[2];\n\t      if (ccl_mnu_sum < sum_check){\n\t\t      *status = CCL_ERROR_MNU_UNPHYSICAL;\n          }\n\n\n          double dsdm1;\n          // This is the Newton's method\n          while (fabs(*mnu- sum_check) > 1e-15){\n              dsdm1 = 1. + (mnu_in[0] / mnu_in[1]) + (mnu_in[0] / mnu_in[2]);\n              mnu_in[0] = mnu_in[0] - (sum_check - *mnu) / dsdm1;\n              mnu_in[1] = sqrt(mnu_in[0]*mnu_in[0] + DELTAM12_sq);\n              mnu_in[2] = sqrt(mnu_in[0]*mnu_in[0] + DELTAM13_sq_neg);\n              sum_check = mnu_in[0] + mnu_in[1] + mnu_in[2];\n          }\n\n      }\n\n  } else if (mnu_type==ccl_mnu_sum_equal){\n\t    // Split the sum of masses equally\n\t    mnu_in = malloc(3*sizeof(double));\n\t    mnu_in[0] = params.sum_nu_masses / 3.;\n\t    mnu_in[1] = params.sum_nu_masses / 3.;\n\t    mnu_in[2] = params.sum_nu_masses / 3.;\n  } else if (mnu_type == ccl_mnu_list){\n      // A list of neutrino masses was already passed in\n\t  params.sum_nu_masses = mnu[0] + mnu[1] + mnu[2];\n\t  mnu_in = malloc(3*sizeof(double));\n\t  for(int i=0; i<3; i++) mnu_in[i] = mnu[i];\n  } else {\n\t  *status = CCL_ERROR_NOT_IMPLEMENTED;\n  }\n  // Check for errors in the neutrino set up (e.g. unphysical mnu)\n  ccl_check_status_nocosmo(status);\n\n  // Check which of the neutrino species are non-relativistic today\n  int N_nu_mass = 0;\n  for(int i = 0; i<3; i=i+1){\n  \tif (mnu_in[i] > 0.00017){ // Limit taken from Lesgourges et al. 2012\n  \t\tN_nu_mass = N_nu_mass + 1;\n  \t}\n  }\n  params.N_nu_mass = N_nu_mass;\n\n  // Fill the array of massive neutrinos\n  if (N_nu_mass>0){\n  \tparams.mnu = malloc(params.N_nu_mass*sizeof(double));\n  \tint relativistic[3] = {0, 0, 0};\n\tfor (int i = 0; i < N_nu_mass; i = i + 1){\n\t\tfor (int j = 0; j<3; j = j +1){\n\t\t\tif ((mnu_in[j]>0.00017) && (relativistic[j]==0)){\n\t\t\t\trelativistic[j]=1;\n\t\t\t\tparams.mnu[i] = mnu_in[j];\n\t\t\t\tbreak;\n\t\t\t}\n\t\t} // end loop over neutrinos\n\t} // end loop over massive neutrinos\n  } else{\n\t  params.mnu = malloc(sizeof(double));\n\t  params.mnu[0] = 0.;\n  }\n  // Free mnu_in\n  if (mnu_in != NULL) free(mnu_in);\n\n  // Dark Energy\n  params.w0 = w0;\n  params.wa = wa;\n\n  // Hubble parameters\n  params.h = h;\n  params.H0 = h*100;\n\n  // Primordial power spectra\n  if(norm_pk<1E-5)\n    params.A_s=norm_pk;\n  else\n    params.sigma8=norm_pk;\n  params.n_s = n_s;\n\n  //Baryonic params\n  if(bcm_log10Mc<0)\n    params.bcm_log10Mc=log10(1.2e14);\n  else\n    params.bcm_log10Mc=bcm_log10Mc;\n  if(bcm_etab<0)\n    params.bcm_etab=0.5;\n  else\n    params.bcm_etab=bcm_etab;\n  if(bcm_ks<0)\n    params.bcm_ks=55.0;\n  else\n    params.bcm_ks=bcm_ks;\n\n  // Set remaining standard and easily derived parameters\n  ccl_parameters_fill_initial(&params, status);\n\n  //Trigger modified growth function if nz>0\n  if(nz_mgrowth>0) {\n    params.has_mgrowth=true;\n    params.nz_mgrowth=nz_mgrowth;\n    params.z_mgrowth=malloc(params.nz_mgrowth*sizeof(double));\n    params.df_mgrowth=malloc(params.nz_mgrowth*sizeof(double));\n    memcpy(params.z_mgrowth,zarr_mgrowth,params.nz_mgrowth*sizeof(double));\n    memcpy(params.df_mgrowth,dfarr_mgrowth,params.nz_mgrowth*sizeof(double));\n  }\n  else {\n    params.has_mgrowth=false;\n    params.nz_mgrowth=0;\n    params.z_mgrowth=NULL;\n    params.df_mgrowth=NULL;\n  }\n\n  return params;\n}\n\n\n/* ------- ROUTINE: ccl_parameters_create_flat_lcdm --------\nINPUT: some cosmological parameters needed to create a flat LCDM model\nTASK: call ccl_parameters_create to produce an LCDM model\n*/\nccl_parameters ccl_parameters_create_flat_lcdm(double Omega_c, double Omega_b, double h,\n                                               double norm_pk, double n_s, int *status)\n{\n  double Omega_k = 0.0;\n  double Neff = 3.046;\n  double w0 = -1.0;\n  double wa = 0.0;\n  double *mnu;\n  double mnuval = 0.;  // a pointer to the variable is not kept past the lifetime of this function\n  mnu = &mnuval;\n  ccl_mnu_convention mnu_type = ccl_mnu_sum;\n\n  ccl_parameters params = ccl_parameters_create(Omega_c, Omega_b, Omega_k, Neff,\n        mnu, mnu_type, w0, wa, h, norm_pk, n_s, -1, -1, -1, -1, NULL, NULL, status);\n\n  return params;\n\n}\n\n\n/**\n * Write a cosmology parameters object to a file in yaml format.\n * @param cosmo Cosmological parameters\n * @param f FILE* pointer opened for reading\n * @return void\n */\nvoid ccl_parameters_write_yaml(ccl_parameters * params, const char * filename, int *status)\n{\n\n  FILE * f = fopen(filename, \"w\");\n\n  if (!f){\n    *status = CCL_ERROR_FILE_WRITE;\n    return;\n  }\n\n#define WRITE_DOUBLE(name) fprintf(f, #name \": %le\\n\",params->name)\n#define WRITE_INT(name) fprintf(f, #name \": %d\\n\",params->name)\n\n  // Densities: CDM, baryons, total matter, curvature\n  WRITE_DOUBLE(Omega_c);\n  WRITE_DOUBLE(Omega_b);\n  WRITE_DOUBLE(Omega_m);\n  WRITE_DOUBLE(Omega_k);\n  WRITE_INT(k_sign);\n\n  // Dark Energy\n  WRITE_DOUBLE(w0);\n  WRITE_DOUBLE(wa);\n\n  // Hubble parameters\n  WRITE_DOUBLE(H0);\n  WRITE_DOUBLE(h);\n\n  // Neutrino properties\n  WRITE_DOUBLE(Neff);\n  WRITE_INT(N_nu_mass);\n  WRITE_DOUBLE(N_nu_rel);\n\n  if (params->N_nu_mass>0){\n    fprintf(f, \"mnu: [\");\n    for (int i=0; i<params->N_nu_mass; i++){\n      fprintf(f, \"%le, \", params->mnu[i]);\n    }\n    fprintf(f, \"]\\n\");\n  }\n\n  WRITE_DOUBLE(sum_nu_masses);\n  WRITE_DOUBLE(Omega_n_mass);\n  WRITE_DOUBLE(Omega_n_rel);\n\n  // Primordial power spectra\n  WRITE_DOUBLE(A_s);\n  WRITE_DOUBLE(n_s);\n\n  // Radiation parameters\n  WRITE_DOUBLE(Omega_g);\n  WRITE_DOUBLE(T_CMB);\n\n  // BCM baryonic model parameters\n  WRITE_DOUBLE(bcm_log10Mc);\n  WRITE_DOUBLE(bcm_etab);\n  WRITE_DOUBLE(bcm_ks);\n\n  // Derived parameters\n  WRITE_DOUBLE(sigma8);\n  WRITE_DOUBLE(Omega_l);\n  WRITE_DOUBLE(z_star);\n\n  WRITE_INT(has_mgrowth);\n  WRITE_INT(nz_mgrowth);\n\n  if (params->has_mgrowth){\n    fprintf(f, \"z_mgrowth: [\");\n    for (int i=0; i<params->nz_mgrowth; i++){\n      fprintf(f, \"%le, \", params->z_mgrowth[i]);\n    }\n    fprintf(f, \"]\\n\");\n\n    fprintf(f, \"df_mgrowth: [\");\n    for (int i=0; i<params->nz_mgrowth; i++){\n      fprintf(f, \"%le, \", params->df_mgrowth[i]);\n    }\n    fprintf(f, \"]\\n\");\n  }\n\n#undef WRITE_DOUBLE\n#undef WRITE_INT\n\n  fclose(f);\n\n}\n\n/**\n * Write a cosmology parameters object to a file in yaml format.\n * @param cosmo Cosmological parameters\n * @param f FILE* pointer opened for reading\n * @return void\n */\nccl_parameters ccl_parameters_read_yaml(const char * filename, int *status)\n{\n\n  FILE * f = fopen(filename, \"r\");\n\n  if (!f){\n    *status = CCL_ERROR_FILE_READ;\n    ccl_parameters bad_params;\n\n    ccl_raise_exception(CCL_ERROR_FILE_READ, \"ccl_core.c: Failed to read parameters from file.\");\n\n    return bad_params;\n  }\n\n#define READ_DOUBLE(name) double name; *status |= (0==fscanf(f, #name \": %le\\n\",&name));\n#define READ_INT(name) int name; *status |= (0==fscanf(f, #name \": %d\\n\",&name))\n\n  // Densities: CDM, baryons, total matter, curvature\n  READ_DOUBLE(Omega_c);\n  READ_DOUBLE(Omega_b);\n  READ_DOUBLE(Omega_m);\n  READ_DOUBLE(Omega_k);\n  READ_INT(k_sign);\n\n  // Dark Energy\n  READ_DOUBLE(w0);\n  READ_DOUBLE(wa);\n\n  // Hubble parameters\n  READ_DOUBLE(H0);\n  READ_DOUBLE(h);\n\n  // Neutrino properties\n  READ_DOUBLE(Neff);\n  READ_INT(N_nu_mass);\n  READ_DOUBLE(N_nu_rel);\n\n  double mnu[3] = {0.0, 0.0, 0.0};\n  if (N_nu_mass>0){\n    *status |= (0==fscanf(f, \"mnu: [\"));\n    for (int i=0; i<N_nu_mass; i++){\n      *status |= (0==fscanf(f, \"%le, \", mnu+i));\n    }\n    *status |= (0==fscanf(f, \"]\\n\"));\n  }\n\n  READ_DOUBLE(sum_nu_masses);\n  READ_DOUBLE(Omega_n_mass);\n  READ_DOUBLE(Omega_n_rel);\n\n  // Primordial power spectra\n  READ_DOUBLE(A_s);\n  READ_DOUBLE(n_s);\n\n  // Radiation parameters\n  READ_DOUBLE(Omega_g);\n  READ_DOUBLE(T_CMB);\n\n  // BCM baryonic model parameters\n  READ_DOUBLE(bcm_log10Mc);\n  READ_DOUBLE(bcm_etab);\n  READ_DOUBLE(bcm_ks);\n\n  // Derived parameters\n  READ_DOUBLE(sigma8);\n  READ_DOUBLE(Omega_l);\n  READ_DOUBLE(z_star);\n\n  READ_INT(has_mgrowth);\n  READ_INT(nz_mgrowth);\n\n  double *z_mgrowth;\n  double *df_mgrowth;\n\n\n  if (has_mgrowth){\n    z_mgrowth = malloc(nz_mgrowth*sizeof(double));\n    df_mgrowth = malloc(nz_mgrowth*sizeof(double));\n    *status |= (0==fscanf(f, \"z_mgrowth: [\"));\n    for (int i=0; i<nz_mgrowth; i++){\n      *status |= (0==fscanf(f, \"%le, \", z_mgrowth+i));\n    }\n    *status |= (0==fscanf(f, \"]\\n\"));\n\n    *status |= (0==fscanf(f, \"df_mgrowth: [\"));\n    for (int i=0; i<nz_mgrowth; i++){\n      *status |= (0==fscanf(f, \"%le, \", df_mgrowth+i));\n    }\n    *status |= (0==fscanf(f, \"]\\n\"));\n  }\n  else{\n    z_mgrowth = NULL;\n    df_mgrowth = NULL;\n  }\n\n#undef READ_DOUBLE\n#undef READ_INT\n\n  fclose(f);\n\n\n  if (status){\n    char msg[256];\n    snprintf(msg, 256, \"ccl_core.c: Structure of YAML file incorrect: %s\", filename);\n    ccl_raise_exception(*status, msg);\n  }\n\n  double norm_pk;\n\n  if (isnan(A_s)){\n    norm_pk = sigma8;\n  }\n  else{\n   norm_pk = A_s;\n  }\n\n  ccl_parameters params = ccl_parameters_create(\n    Omega_c, Omega_b, Omega_k,\n    Neff, mnu, ccl_mnu_list,\n    w0, wa, h, norm_pk,\n    n_s, bcm_log10Mc, bcm_etab,\n    bcm_ks, nz_mgrowth, z_mgrowth,\n    df_mgrowth, status);\n\n  if(z_mgrowth) free(z_mgrowth);\n  if (df_mgrowth) free(df_mgrowth);\n\n  return params;\n\n}\n\n\n\n/* ------- ROUTINE: ccl_data_free --------\nINPUT: ccl_data\nTASK: free the input data\n*/\nvoid ccl_data_free(ccl_data * data)\n{\n  //We cannot assume that all of these have been allocated\n  //TODO: it would actually make more sense to do this within ccl_cosmology_free,\n  //where we could make use of the flags \"computed_distances\" etc. to figure out\n  //what to free up\n  gsl_spline_free(data->chi);\n  gsl_spline_free(data->growth);\n  gsl_spline_free(data->fgrowth);\n  gsl_interp_accel_free(data->accelerator);\n  gsl_interp_accel_free(data->accelerator_achi);\n  gsl_spline_free(data->E);\n  gsl_spline_free(data->achi);\n  gsl_spline_free(data->logsigma);\n  gsl_spline_free(data->dlnsigma_dlogm);\n  gsl_spline2d_free(data->p_lin);\n  gsl_spline2d_free(data->p_nl);\n  gsl_spline_free(data->alphahmf);\n  gsl_spline_free(data->betahmf);\n  gsl_spline_free(data->gammahmf);\n  gsl_spline_free(data->phihmf);\n  gsl_spline_free(data->etahmf);\n  gsl_interp_accel_free(data->accelerator_d);\n  gsl_interp_accel_free(data->accelerator_m);\n  gsl_interp_accel_free(data->accelerator_k);\n}\n\n/* ------- ROUTINE: ccl_cosmology_set_status_message --------\nINPUT: ccl_cosmology struct, status_string\nTASK: set the status message safely.\n*/\nvoid ccl_cosmology_set_status_message(ccl_cosmology * cosmo, const char * message, ...)\n{\n  const int trunc = 480; /* must be < 500 - 4 */\n  va_list va;\n  va_start(va, message);\n  vsnprintf(cosmo->status_message, trunc, message, va);\n  va_end(va);\n\n  /* if truncation happens, message[trunc - 1] is not NULL, ... will show up. */\n  strcpy(&cosmo->status_message[trunc], \"...\");\n}\n\n/* ------- ROUTINE: ccl_parameters_free --------\nINPUT: ccl_parameters struct\nTASK: free allocated quantities in the parameters struct\n*/\nvoid ccl_parameters_free(ccl_parameters * params)\n{\n  if (params->mnu != NULL){\n    free(params->mnu);\n    params->mnu = NULL;\n  }\n  if (params->z_mgrowth != NULL){\n    free(params->z_mgrowth);\n    params->z_mgrowth = NULL;\n  }\n  if (params->df_mgrowth != NULL){\n    free(params->df_mgrowth);\n    params->df_mgrowth = NULL;\n  }\n}\n\n\n/* ------- ROUTINE: ccl_cosmology_free --------\nINPUT: ccl_cosmology struct\nTASK: free the input data and the cosmology struct\n*/\nvoid ccl_cosmology_free(ccl_cosmology * cosmo)\n{\n  ccl_data_free(&cosmo->data);\n  free(cosmo);\n}\n", "meta": {"hexsha": "65ea1938aef1bf4adab4b63bc82476e12ec1552b", "size": 25591, "ext": "c", "lang": "C", "max_stars_repo_path": "src/ccl_core.c", "max_stars_repo_name": "Russell-Jones-OxPhys/CCL", "max_stars_repo_head_hexsha": "1cdc4ecb8ae6fb23806540b39799cc3317473e71", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/ccl_core.c", "max_issues_repo_name": "Russell-Jones-OxPhys/CCL", "max_issues_repo_head_hexsha": "1cdc4ecb8ae6fb23806540b39799cc3317473e71", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/ccl_core.c", "max_forks_repo_name": "Russell-Jones-OxPhys/CCL", "max_forks_repo_head_hexsha": "1cdc4ecb8ae6fb23806540b39799cc3317473e71", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.8697225573, "max_line_length": 136, "alphanum_fraction": 0.6606228752, "num_tokens": 7845, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4455295203152604, "lm_q2_score": 0.05261895520477843, "lm_q1q2_score": 0.02344329787187511}}
{"text": "/*\n * C version of Diffusive Nested Sampling (DNest4) by Brendon J. Brewer\n *\n * Yan-Rong Li, liyanrong@mail.ihep.ac.cn\n * Jun 30, 2016\n *\n */\n\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <time.h>\n#include <unistd.h>\n#include <math.h>\n#include <float.h>\n#include <mpi.h>\n#include <sys/stat.h>\n#include <gsl/gsl_rng.h>\n#include <gsl/gsl_randist.h>\n\n#include \"dnest.h\"\n#include \"dnestvars.h\"\n\n/*\n * dnest\n * call this function to do sampling\n * ========================================================\n * arguments:\n * argc:        number of command-line options (mandatory)\n * argv:        command-line options  (mandatory)\n * fptrset:     function set pointers required  (mandatory)\n * num_params:  number of parameters (mandatory)\n * param_range: parameter ranges  (mandatory)\n * prior_type:  prior types  (optional)\n * prior_info:  prior informations  (optional)\n * sample_dir:  output directory for sampling  (mandatory)\n * optfile:     option files  (optional)\n * opts:        options struct. if optfile is empty, use this struct (optional)\n * args:        any other arguments transferred to cdnest.  (optional)\n *              useful when referring to external variables or calling external functions (optional)\n * ========================================================\n * optional arguments can be set to \"NULL\"\n */\ndouble dnest(int argc, char** argv, DNestFptrSet *fptrset, int num_params, \n             double *param_range, int *prior_type, double *prior_info,\n             char *sample_dir, char *optfile, DNestOptions *opts, void *args)\n{\n  int optid;\n\n  MPI_Comm_rank(MPI_COMM_WORLD, &dnest_thistask);\n  MPI_Comm_size(MPI_COMM_WORLD, &dnest_totaltask);\n  \n  if(dnest_thistask == dnest_root)\n  {\n    printf(\"#=======================================================\\n\");\n    printf(\"# Starting CDNest.\\n\");\n    printf(\"# Use %d cores.\\n\", dnest_totaltask);\n  }\n\n  dnest_check_fptrset(fptrset);\n  \n  // cope with argv\n  if(dnest_thistask == dnest_root )\n  {\n    dnest_post_temp = 1.0;\n    dnest_flag_restart = 0;\n    dnest_flag_postprc = 0;\n    dnest_flag_sample_info = 0;\n    dnest_flag_limits = 0;\n\n    strcpy(file_save_restart, \"restart_dnest.txt\");\n    strcpy(dnest_sample_postfix, \"\\0\");\n    strcpy(dnest_sample_tag, \"\\0\");\n\n    opterr = 0;\n    optind = 0;\n    while( (optid = getopt(argc, argv, \"r:s:pt:clx:g:\")) != -1)\n    {\n      switch(optid)\n      {\n        case 'r':\n          dnest_flag_restart = 1;\n          strcpy(file_restart, optarg);\n          printf(\"# Dnest restarts.\\n\");\n          break;\n        case 's':\n          strcpy(file_save_restart, optarg);\n          printf(\"# Dnest sets restart file %s.\\n\", file_save_restart);\n          break;\n        case 'p':\n          dnest_flag_postprc = 1;\n          dnest_post_temp = 1.0;\n          printf(\"# Dnest does postprocess.\\n\");\n          break;\n        case 't':\n          dnest_post_temp = atof(optarg);\n          printf(\"# Dnest sets a temperature %f.\\n\", dnest_post_temp);\n          if(dnest_post_temp == 0.0)\n          {\n            printf(\"# Dnest incorrect option -t %s.\\n\", optarg);\n            exit(0);\n          }\n          if(dnest_post_temp < 1.0)\n          {\n            printf(\"# Dnest temperature should >= 1.0\\n\");\n            exit(0);\n          }\n          break;\n        case 'c':\n          dnest_flag_sample_info = 1;\n          printf(\"# Dnest recalculates sample information.\\n\");\n          break;\n        case 'l':\n          dnest_flag_limits = 1;\n          printf(\"# Dnest level-dependent sampling.\\n\");\n          break;\n        case 'x':\n          strcpy(dnest_sample_postfix, optarg);\n          printf(\"# Dnest sets sample postfix %s.\\n\", dnest_sample_postfix);\n          break;\n        case 'g':\n          strcpy(dnest_sample_tag, optarg);\n          printf(\"# Dnest sets sample tag %s.\\n\", dnest_sample_tag);\n          break;\n        case '?':\n          printf(\"# Dnest incorrect option -%c %s.\\n\", optopt, optarg);\n          exit(0);\n          break;\n        default:\n          break;\n      }\n    }\n  }\n  \n  MPI_Bcast(&dnest_flag_restart, 1, MPI_INT, dnest_root, MPI_COMM_WORLD);\n  MPI_Bcast(&dnest_flag_postprc, 1, MPI_INT, dnest_root, MPI_COMM_WORLD);\n  MPI_Bcast(&dnest_flag_sample_info, 1, MPI_INT,dnest_root, MPI_COMM_WORLD);\n  MPI_Bcast(&dnest_post_temp, 1, MPI_DOUBLE, dnest_root, MPI_COMM_WORLD);\n  MPI_Bcast(&dnest_flag_limits, 1, MPI_INT, dnest_root, MPI_COMM_WORLD);\n\n  setup(argc, argv, fptrset, num_params, param_range, prior_type, prior_info, sample_dir, optfile, opts, args);\n\n  if(dnest_flag_postprc == 1)\n  {\n    dnest_postprocess(dnest_post_temp, optfile, opts);\n    MPI_Barrier(MPI_COMM_WORLD);\n    finalise();\n    return post_logz;\n  }\n\n  if(dnest_flag_sample_info == 1)\n  {\n    dnest_postprocess(dnest_post_temp, optfile, opts);\n    finalise();\n    return post_logz;\n  }\n\n  if(dnest_flag_restart==1)\n    dnest_restart();\n\n  initialize_output_file();\n  dnest_run();\n  close_output_file();\n\n  dnest_postprocess(dnest_post_temp, optfile, opts);\n\n  finalise();\n  \n  return post_logz;\n}\n\n// postprocess, calculate evidence, generate posterior sample.\nvoid dnest_postprocess(double temperature,char *optfile, DNestOptions *opts)\n{\n  if(dnest_thistask == dnest_root)\n  {\n    options_load(optfile, opts);\n    postprocess(temperature);\n  }\n  MPI_Bcast(&post_logz, 1, MPI_DOUBLE, dnest_root, MPI_COMM_WORLD);\n}\n\nvoid dnest_run()\n{\n  int i, j, k, size_all_above_incr;\n  Level *pl, *levels_orig;\n  int *buf_size_above, *buf_displs;\n  double *plimits;\n  \n  // used to gather levels' information\n  if(dnest_thistask == dnest_root)\n  {\n    buf_size_above = malloc(dnest_totaltask * sizeof(int));  \n    buf_displs = malloc(dnest_totaltask * sizeof(int));\n  }\n\n  if(dnest_thistask == dnest_root)\n  {\n    printf(\"#=======================================================\\n\");\n    printf(\"# Starting diffusive nested sampling.\\n\");\n  }\n  MPI_Barrier(MPI_COMM_WORLD);\n\n  while(true)\n  {\n    //check for termination\n    if(options.max_num_saves !=0 &&\n        count_saves != 0 && (count_saves%options.max_num_saves == 0))\n      break;\n\n    dnest_mcmc_run();\n    MPI_Barrier(MPI_COMM_WORLD);\n    \n    //gather levels\n    MPI_Gather(levels, size_levels*sizeof(Level), MPI_BYTE, \n             copies_of_levels, size_levels*sizeof(Level), MPI_BYTE, dnest_root, MPI_COMM_WORLD);\n\n    //gather limits\n    if(dnest_flag_limits == 1)\n    {\n      MPI_Gather(limits, size_levels*particle_offset_double*2, MPI_DOUBLE, \n               copies_of_limits, size_levels*particle_offset_double*2, MPI_DOUBLE, dnest_root, MPI_COMM_WORLD );\n    }\n    \n    //gather size_above \n    MPI_Gather(&size_above, 1, MPI_INT, buf_size_above, 1, MPI_INT, dnest_root, MPI_COMM_WORLD);\n\n    // task 0 responsible for updating levels\n    if(dnest_thistask == dnest_root)\n    {\n      size_all_above_incr = 0;\n      for(i = 0; i<dnest_totaltask; i++)\n      {\n        size_all_above_incr += buf_size_above[i];\n\n        buf_size_above[i] *= sizeof(LikelihoodType);\n      }\n\n      // store new points following the end of all_above array.\n      buf_displs[0] = size_all_above * sizeof(LikelihoodType);\n      for(i=1; i<dnest_totaltask; i++)\n      {\n        buf_displs[i] = buf_displs[i-1] + buf_size_above[i-1];\n      }\n      \n      //update size_all_above\n      size_all_above += size_all_above_incr; \n\n      if(size_all_above > options.new_level_interval*2)\n      {\n        printf(\"# Error, all above overflow.\\n\");\n        exit(0);\n      }\n    }\n    \n\n    // gather above into all_above, stored in task 0, note that its size is different among tasks\n    MPI_Gatherv(above, size_above * sizeof(LikelihoodType), MPI_BYTE, \n                all_above, buf_size_above, buf_displs, MPI_BYTE, dnest_root, MPI_COMM_WORLD);\n\n    // reset size_above for each task\n    size_above = 0;\n\n    count_mcmc_steps += options.thread_steps * dnest_totaltask;\n\n    if(dnest_thistask == dnest_root)\n    {\n      //backup levels_combine\n      levels_orig = malloc(size_levels_combine * sizeof(Level));\n      memcpy(levels_orig, levels_combine, size_levels_combine*sizeof(Level));\n\n      //scan over all copies of levels\n      pl = copies_of_levels;\n      for(i=0; i< dnest_totaltask; i++)\n      {\n        for(j=0; j<size_levels_combine; j++)\n        {\n          levels_combine[j].accepts += (pl[j].accepts - levels_orig[j].accepts);\n          levels_combine[j].tries += (pl[j].tries - levels_orig[j].tries);\n          levels_combine[j].visits += (pl[j].visits - levels_orig[j].visits);\n          levels_combine[j].exceeds += (pl[j].exceeds - levels_orig[j].exceeds);\n          //printf(\"%d %d\\n\", thistask, (pl[j].accepts - levels_orig[j].accepts) );;\n        }\n        pl += size_levels_combine;\n      }\n\n      free(levels_orig);\n\n      // scan over all copies of limits\n      if(dnest_flag_limits == 1)\n      {\n        plimits = copies_of_limits;\n        for(i=0; i< dnest_totaltask; i++)\n        {\n          for(j=0; j < size_levels; j++)\n          {\n            for(k=0; k<particle_offset_double; k++)\n            {\n              limits[j * particle_offset_double *2 + k*2 ] = fmin(limits[j * particle_offset_double *2 + k*2 ],\n                plimits[j * particle_offset_double *2 + k*2]);\n              limits[j * particle_offset_double *2 + k*2 +1 ] = fmax(limits[j * particle_offset_double *2 + k*2 +1 ],\n                plimits[j * particle_offset_double *2 + k*2 + 1]);\n            }\n          \n          }\n          plimits += size_levels * particle_offset_double * 2;\n        }\n\n        // limits of smaller levels should be larger than those of higher levels\n        for(j=size_levels-2; j >= 0; j--)\n          for(k=0; k<particle_offset_double; k++)\n          {\n            limits[ j * particle_offset_double *2 + k*2 ] = fmin( limits[ j * particle_offset_double *2 + k*2 ],\n                    limits[ (j+1) * particle_offset_double *2 + k*2 ] );\n\n            limits[ j * particle_offset_double *2 + k*2 + 1] = fmax( limits[ j * particle_offset_double *2 + k*2 +1 ],\n                    limits[ (j+1) * particle_offset_double *2 + k*2 + 1 ] );\n          }\n      }\n\n      do_bookkeeping();\n\n      size_levels = size_levels_combine;\n      memcpy(levels, levels_combine, size_levels * sizeof(Level));\n    }\n\n    //broadcast levels\n    MPI_Bcast(&size_levels, 1, MPI_INT, dnest_root, MPI_COMM_WORLD);\n    //MPI_Bcast(&count_saves, 1, MPI_INT, root, MPI_COMM_WORLD);\n    MPI_Bcast(levels, size_levels * sizeof(Level), MPI_BYTE, dnest_root,  MPI_COMM_WORLD); \n\n    if(dnest_flag_limits == 1)\n      MPI_Bcast(limits, size_levels * particle_offset_double *2, MPI_DOUBLE, dnest_root, MPI_COMM_WORLD);\n\n    if(count_mcmc_steps >= (count_saves + 1)*options.save_interval)\n    {\n      save_particle();\n\n      if(dnest_thistask == dnest_root )\n      {\n        // save levels, limits, sync samples when running a number of steps\n        if( count_saves % num_saves == 0 )\n        {\n          save_levels();\n          if(dnest_flag_limits == 1)\n            save_limits();\n          fflush(fsample_info);\n          fsync(fileno(fsample_info));\n          fflush(fsample);\n          fsync(fileno(fsample));\n          printf(\"# Save levels, limits, and sync samples at N= %d.\\n\", count_saves);\n        }\n      }\n\n      if( count_saves % num_saves_restart == 0 )\n      {\n        dnest_save_restart();\n      }\n    }\n  }\n  \n  //dnest_save_restart();\n\n  if(dnest_thistask == dnest_root)\n  {\n    //save levels\n    save_levels();\n    if(dnest_flag_limits == 1)\n      save_limits();\n\n    /* output state of sampler */\n    FILE *fp;\n    fp = fopen(options.sampler_state_file, \"w\");\n    fprintf(fp, \"%d %d\\n\", size_levels, count_saves);\n    fclose(fp);\n\n    free(buf_size_above);\n    free(buf_displs);\n  }\n}\n\nvoid do_bookkeeping()\n{\n  int i;\n  //bool created_level = false;\n\n  if(!enough_levels(levels_combine, size_levels_combine) && size_all_above >= options.new_level_interval)\n  {\n    // in descending order \n    qsort(all_above, size_all_above, sizeof(LikelihoodType), dnest_cmp);\n    int index = (int)( (1.0/compression) * size_all_above);\n\n    Level level_tmp = {all_above[index], 0.0, 0, 0, 0, 0};\n    levels_combine[size_levels_combine] = level_tmp;\n    size_levels_combine++;\n    \n    printf(\"# Creating level %d with log likelihood = %e.\\n\", \n               size_levels_combine-1, levels_combine[size_levels_combine-1].log_likelihood.value);\n\n    // clear out the last index records\n    for(i=index; i<size_all_above; i++)\n    {\n      all_above[i].value = 0.0;\n      all_above[i].tiebreaker = 0.0;\n    }\n    size_all_above = index;\n\n    if(enough_levels(levels_combine, size_levels_combine))\n    {\n      renormalise_visits();\n      options.max_num_levels = size_levels_combine;\n      printf(\"# Done creating levles.\\n\");\n    }\n    else\n    {\n      kill_lagging_particles();\n    }\n\n    //created_level = true;\n  }\n  \n  recalculate_log_X();\n\n/*  if(created_level)\n    save_levels();\n\n  if(count_mcmc_steps >= (count_saves + 1)*options.save_interval)\n  {\n\n    //save_particle();\n\n    if(!created_level)\n      save_levels();\n  }*/\n\n}\n\nvoid recalculate_log_X()\n{\n  int i;\n\n  levels_combine[0].log_X = 0.0;\n  for(i=1; i<size_levels_combine; i++)\n  {\n    levels_combine[i].log_X = levels_combine[i-1].log_X \n    + log( (double)( (levels_combine[i-1].exceeds + 1.0/compression * regularisation)\n                    /(levels_combine[i-1].visits + regularisation)  ) );\n  }\n}\n\nvoid renormalise_visits()\n{\n  size_t i;\n\n  for(i=0; i<size_levels_combine; i++)\n  {\n    if(levels_combine[i].tries >= regularisation)\n    {\n      levels_combine[i].accepts = ((double)(levels_combine[i].accepts+1) / (double)(levels_combine[i].tries+1)) * regularisation;\n      levels_combine[i].tries = regularisation;\n    }\n\n    if(levels_combine[i].visits >= regularisation)\n    {\n      levels_combine[i].exceeds = ( (double) (levels_combine[i].exceeds+1) / (double)(levels_combine[i].visits + 1) ) * regularisation;\n      levels_combine[i].visits = regularisation;\n    }\n  }\n}\n\nvoid kill_lagging_particles()\n{\n  static unsigned int deletions = 0;\n\n  bool *good;\n  good = (bool *)malloc(options.num_particles * sizeof(bool));\n\n  double max_log_push = -DBL_MAX;\n\n  double kill_probability = 0.0;\n  unsigned int num_bad = 0;\n  size_t i;\n\n  for(i=0; i<options.num_particles; i++)good[i] = true;\n\n  for(i=0; i<options.num_particles; i++)\n  {\n    if( log_push(level_assignments[i]) > max_log_push)\n      max_log_push = log_push(level_assignments[i]);\n\n    kill_probability = pow(1.0 - 1.0/(1.0 + exp(-log_push(level_assignments[i]) - 4.0)), 3);\n    if(gsl_rng_uniform(dnest_gsl_r) <= kill_probability)\n    {\n      good[i] = false;\n      ++num_bad;\n    }\n  }\n\n  if(num_bad < options.num_particles)\n  {\n    for(i=0; i< options.num_particles; i++)\n    {\n      if(!good[i])\n      {\n        int i_copy;\n        do\n        {\n          i_copy = gsl_rng_uniform_int(dnest_gsl_r, options.num_particles);\n        }while(!good[i_copy] || gsl_rng_uniform(dnest_gsl_r) >= exp(log_push(level_assignments[i_copy]) - max_log_push));\n\n        memcpy(particles+i*particle_offset_size, particles + i_copy*particle_offset_size, dnest_size_of_modeltype);\n        log_likelihoods[i] = log_likelihoods[i_copy];\n        level_assignments[i] = level_assignments[i_copy];\n         \n        kill_action(i, i_copy);\n\n        deletions++;\n\n        printf(\"# Replacing lagging particle.\\n\");\n        printf(\"# This has happened %d times.\\n\", deletions);\n      }\n    }\n  }\n  else\n    printf(\"# Warning: all particles lagging!.\\n\");\n\n  free(good);\n}\n\n/* save levels */\nvoid save_levels()\n{\n  if(!save_to_disk)\n    return;\n  \n  int i;\n  FILE *fp;\n\n  fp = fopen(options.levels_file, \"w\");\n  fprintf(fp, \"# log_X, log_likelihood, tiebreaker, accepts, tries, exceeds, visits\\n\");\n  for(i=0; i<size_levels_combine; i++)\n  {\n    fprintf(fp, \"%14.12g %14.12g %f %llu %llu %llu %llu\\n\", levels_combine[i].log_X, levels_combine[i].log_likelihood.value, \n      levels_combine[i].log_likelihood.tiebreaker, levels_combine[i].accepts,\n      levels_combine[i].tries, levels[i].exceeds, levels_combine[i].visits);\n  }\n  fclose(fp);\n\n  /* update state of sampler */\n  fp = fopen(options.sampler_state_file, \"w\");\n  fprintf(fp, \"%d %d\\n\", size_levels, count_saves);\n  fclose(fp);\n}\n\nvoid save_limits()\n{\n  int i, j;\n  FILE *fp;\n\n  fp = fopen(options.limits_file, \"w\");\n  for(i=0; i<size_levels_combine; i++)\n  {\n    fprintf(fp, \"%d  \", i);\n    for(j=0; j<particle_offset_double; j++)\n      fprintf(fp, \"%f  %f  \", limits[i*2*particle_offset_double+j*2], limits[i*2*particle_offset_double+j*2+1]);\n\n    fprintf(fp, \"\\n\");\n  }\n  fclose(fp);\n}\n\n/* save particle */\nvoid save_particle()\n{\n  count_saves++;\n\n  if(!save_to_disk)\n    return;\n  \n  int whichparticle, whichtask;\n  void *particle_message;\n  \n  if(dnest_thistask == dnest_root)\n  {\n    if(count_saves%1 == 0)\n      printf(\"#[%.1f%%] Saving particle to disk. N= %d.\\n\", 100.0*count_saves/options.max_num_saves, count_saves);\n\n    whichtask = gsl_rng_uniform_int(dnest_gsl_r,dnest_totaltask);\n  }\n\n  MPI_Bcast(&whichtask, 1, MPI_INT, dnest_root, MPI_COMM_WORLD);\n\n  if(whichtask != dnest_root)\n  {\n    if(dnest_thistask == whichtask)\n    {\n      int size_message = dnest_size_of_modeltype + 2*sizeof(int) + 2*sizeof(double);\n      particle_message = (void *)malloc(size_message);\n      whichparticle = gsl_rng_uniform_int(dnest_gsl_r,options.num_particles);\n      memcpy(particle_message, particles + whichparticle * particle_offset_size, dnest_size_of_modeltype);\n      memcpy(particle_message + dnest_size_of_modeltype, &log_likelihoods[whichparticle].value, 2*sizeof(double));\n      memcpy(particle_message + dnest_size_of_modeltype + 2*sizeof(double), &level_assignments[whichparticle], sizeof(int));\n      memcpy(particle_message + dnest_size_of_modeltype + 2*sizeof(double) + sizeof(int), &whichparticle, sizeof(int));\n\n      MPI_Send(particle_message, size_message, MPI_BYTE, dnest_root, 1, MPI_COMM_WORLD);\n\n      //printf(\"%f %f\\n\", log_likelihoods[whichparticle].value, log_likelihoods[whichparticle].tiebreaker);\n\n      free(particle_message);\n    }\n    if(dnest_thistask == dnest_root)\n    {\n      MPI_Status status;\n      int size_message = dnest_size_of_modeltype + 2*sizeof(int) + 2*sizeof(double);\n      int whichlevel;\n      LikelihoodType logl;\n\n      particle_message = (void *)malloc(size_message);\n\n      MPI_Recv(particle_message, size_message, MPI_BYTE, whichtask, 1, MPI_COMM_WORLD, &status);\n\n      memcpy(&logl, particle_message + dnest_size_of_modeltype, 2*sizeof(double) );\n      memcpy(&whichlevel, particle_message + dnest_size_of_modeltype + 2*sizeof(double), sizeof(int) );\n      memcpy(&whichparticle, particle_message + dnest_size_of_modeltype + 2*sizeof(double) + sizeof(int), sizeof(int) );\n      \n      //printf(\"%f %f\\n\", logl.value, logl.tiebreaker);\n\n      print_particle(fsample, particle_message);\n\n      fprintf(fsample_info, \"%d %e %f %d\\n\", whichlevel, \n        logl.value,\n        logl.tiebreaker,\n        whichtask * options.num_particles + whichparticle);\n\n      free(particle_message);\n    }\n  }\n  else\n  {\n    if(dnest_thistask == dnest_root)\n    {\n      whichparticle =  gsl_rng_uniform_int(dnest_gsl_r,options.num_particles);\n\n      print_particle(fsample, particles + whichparticle * particle_offset_size);\n\n      fprintf(fsample_info, \"%d %e %f %d\\n\", level_assignments[whichparticle], \n        log_likelihoods[whichparticle].value,\n        log_likelihoods[whichparticle].tiebreaker,\n        whichtask * options.num_particles + whichparticle);\n    }\n  }\n}\n\nvoid dnest_mcmc_run()\n{\n  unsigned int which;\n  unsigned int i;\n  \n  for(i = 0; i<options.thread_steps; i++)\n  {\n\n    /* randomly select out one particle to update */\n    which = gsl_rng_uniform_int(dnest_gsl_r, options.num_particles);\n\n    dnest_which_particle_update = which;\n\n    //if(count_mcmc_steps >= 10000)printf(\"FFFF\\n\");\n    //printf(\"%d\\n\", which);\n    //printf(\"%f %f %f\\n\", particles[which].param[0], particles[which].param[1], particles[which].param[2]);\n    //printf(\"level:%d\\n\", level_assignments[which]);\n    //printf(\"%e\\n\", log_likelihoods[which].value);\n\n    if(gsl_rng_uniform(dnest_gsl_r) <= 0.5)\n    {\n      update_particle(which);\n      update_level_assignment(which);\n    }\n    else\n    {\n      update_level_assignment(which);\n      update_particle(which);\n    }\n        \n    if( !enough_levels(levels, size_levels)  && levels[size_levels-1].log_likelihood.value <= log_likelihoods[which].value)\n    {\n      above[size_above] = log_likelihoods[which];\n      size_above++;\n    }\n  }\n}\n\n\nvoid update_particle(unsigned int which)\n{\n  void *particle = particles+ which*particle_offset_size;\n  LikelihoodType *logl = &(log_likelihoods[which]);\n  \n  Level *level = &(levels[level_assignments[which]]);\n\n  void *proposal = (void *)malloc(dnest_size_of_modeltype);\n  LikelihoodType logl_proposal;\n  double log_H;\n\n  memcpy(proposal, particle, dnest_size_of_modeltype);\n  dnest_which_level_update = level_assignments[which];\n  \n  log_H = perturb(proposal);\n  \n  logl_proposal.value = log_likelihoods_cal(proposal);\n  logl_proposal.tiebreaker =  (*logl).tiebreaker + gsl_rng_uniform(dnest_gsl_r);\n  dnest_wrap(&logl_proposal.tiebreaker, 0.0, 1.0);\n  \n  if(log_H > 0.0)\n    log_H = 0.0;\n\n  dnest_perturb_accept[which] = 0;\n  if( gsl_rng_uniform(dnest_gsl_r) <= exp(log_H) && level->log_likelihood.value <= logl_proposal.value)\n  {\n    memcpy(particle, proposal, dnest_size_of_modeltype);\n    memcpy(logl, &logl_proposal, sizeof(LikelihoodType));\n    level->accepts++;\n\n    dnest_perturb_accept[which] = 1;\n    accept_action();\n    account_unaccepts[which] = 0; /* reset the number of unaccepted perturb */\n  }\n  else \n  {\n    account_unaccepts[which] += 1; /* number of unaccepted perturb */\n  }\n  level->tries++;\n  \n  unsigned int current_level = level_assignments[which];\n  for(; current_level < size_levels-1; ++current_level)\n  {\n    levels[current_level].visits++;\n    if(levels[current_level+1].log_likelihood.value <= log_likelihoods[which].value)\n      levels[current_level].exceeds++;\n    else\n      break; // exit the loop if it does not satify higher levels\n  }\n  free(proposal);\n}\n\nvoid update_level_assignment(unsigned int which)\n{\n  int i;\n\n  int proposal = level_assignments[which] \n                 + (int)( pow(10.0, 2*gsl_rng_uniform(dnest_gsl_r))*gsl_ran_ugaussian(dnest_gsl_r));\n\n  if(proposal == level_assignments[which])\n    proposal =  ((gsl_rng_uniform(dnest_gsl_r) < 0.5)?(proposal-1):(proposal+1));\n\n  proposal=mod_int(proposal, size_levels);\n\n  double log_A = -levels[proposal].log_X + levels[level_assignments[which]].log_X;\n\n  log_A += log_push(proposal) - log_push(level_assignments[which]);\n\n  // enforce uniform exploration if levels are enough\n  if(enough_levels(levels, size_levels))\n    log_A += options.beta*log( (double)(levels[level_assignments[which]].tries +1)/ (levels[proposal].tries +1) );\n\n  if(log_A > 0.0)\n    log_A = 0.0;\n\n  if( gsl_rng_uniform(dnest_gsl_r) <= exp(log_A) && levels[proposal].log_likelihood.value <= log_likelihoods[which].value)\n  {\n    level_assignments[which] = proposal;\n\n// update the limits of the level\n    if(dnest_flag_limits == 1)\n    {\n      double *particle = (double *) (particles+ which*particle_offset_size);\n      for(i=0; i<particle_offset_double; i++)\n      {\n        limits[proposal * 2 * particle_offset_double +  i*2] = \n            fmin(limits[proposal * 2* particle_offset_double +  i*2], particle[i]);\n        limits[proposal * 2 * particle_offset_double +  i*2+1] = \n            fmax(limits[proposal * 2 * particle_offset_double +  i*2+1], particle[i]);\n      }\n    }\n\n  }\n\n}\n\ndouble log_push(unsigned int which_level)\n{\n  if(which_level > size_levels)\n  {\n    printf(\"level overflow %d %d.\\n\", which_level, size_levels);\n    exit(0);\n  }\n  if(enough_levels(levels, size_levels))\n    return 0.0;\n\n  int i = which_level - (size_levels - 1);\n  return ((double)i)/options.lam;\n}\n\nbool enough_levels(Level *l, int size_l)\n{\n  int i;\n\n  if(options.max_num_levels == 0)\n  {\n    if(size_l >= LEVEL_NUM_MAX)\n      return true;\n\n    if(size_l < 10)\n      return false;\n\n    int num_levels_to_check = 20;\n    if(size_l > 80)\n      num_levels_to_check = (int)(sqrt(20) * sqrt(0.25*size_l));\n\n    int k = size_l - 1, kc = 0;\n    double tot = 0.0;\n    double max = -DBL_MAX;\n    double diff;\n\n    for(i= 0; i<num_levels_to_check; i++)\n    {\n      diff = l[k].log_likelihood.value - l[k-1].log_likelihood.value;\n      tot += diff;\n      if(diff > max)\n        max = diff;\n\n      k--;\n      kc++;\n      if( k < 1 )\n        break;\n    }\n    if(tot/kc < options.max_ptol && max < options.max_ptol*1.1)\n      return true;\n    else\n      return false;\n  }\n  return (size_l >= options.max_num_levels);\n}\n\nvoid initialize_output_file()\n{\n  if(dnest_thistask != dnest_root)\n    return;\n\n  if(dnest_flag_restart !=1)\n    fsample = fopen(options.sample_file, \"w\");\n  else\n    fsample = fopen(options.sample_file, \"a\");\n  \n  if(fsample==NULL)\n  {\n    fprintf(stderr, \"# Cannot open file sample.txt.\\n\");\n    exit(0);\n  }\n  if(dnest_flag_restart != 1)\n    fprintf(fsample, \"# \\n\");\n\n  if(dnest_flag_restart != 1)\n    fsample_info = fopen(options.sample_info_file, \"w\");\n  else\n    fsample_info = fopen(options.sample_info_file, \"a\");\n\n  if(fsample_info==NULL)\n  {\n    fprintf(stderr, \"# Cannot open file %s.\\n\", options.sample_info_file);\n    exit(0);\n  }\n  if(dnest_flag_restart != 1)\n    fprintf(fsample_info, \"# level assignment, log likelihood, tiebreaker, ID.\\n\");\n}\n\nvoid close_output_file()\n{\n  if(dnest_thistask != dnest_root )\n    return;\n\n  fclose(fsample);\n  fclose(fsample_info);\n}\n\nvoid setup(int argc, char** argv, DNestFptrSet *fptrset, int num_params, \n           double *param_range, int *prior_type, double *prior_info,\n           char *sample_dir, char *optfile, DNestOptions *opts, void *args)\n{\n  int i, j;\n\n  // root task.\n  dnest_root = 0;\n\n  if(dnest_thistask == dnest_root)\n  {\n    dnest_check_directory(sample_dir);\n  }\n  MPI_Barrier(MPI_COMM_WORLD);\n\n  // setup function pointers\n  from_prior = fptrset->from_prior;\n  log_likelihoods_cal = fptrset->log_likelihoods_cal;\n  log_likelihoods_cal_initial = fptrset->log_likelihoods_cal_initial;\n  log_likelihoods_cal_restart = fptrset->log_likelihoods_cal_restart;\n  perturb = fptrset->perturb;\n  print_particle = fptrset->print_particle;\n  read_particle = fptrset->read_particle;\n  restart_action = fptrset->restart_action;\n  accept_action = fptrset->accept_action;\n  kill_action = fptrset->kill_action;\n  strcpy(options_file, optfile);\n  strcpy(dnest_sample_dir, sample_dir);\n\n  // random number generator\n  dnest_gsl_T = (gsl_rng_type *) gsl_rng_default;\n  dnest_gsl_r = gsl_rng_alloc (dnest_gsl_T);\n#ifndef Debug\n  gsl_rng_set(dnest_gsl_r, time(NULL) + dnest_thistask);\n#else\n  gsl_rng_set(dnest_gsl_r, 9999 + dnest_thistask);\n  printf(\"# debugging, task %d dnest random seed %d\\n\", dnest_thistask, 9999 + dnest_thistask);\n#endif  \n  \n  dnest_num_params = num_params;\n  dnest_size_of_modeltype = dnest_num_params * sizeof(double);\n\n  if(param_range != NULL)\n  {\n    dnest_param_range = malloc(num_params*2*sizeof(double));\n    memcpy(dnest_param_range, param_range, num_params*2*sizeof(double));\n  }\n  if(prior_type != NULL)\n  {\n    dnest_prior_type = malloc(num_params*sizeof(int));\n    memcpy(dnest_prior_type, prior_type, num_params*sizeof(int));\n  }\n  if(prior_info != NULL)\n  {\n    dnest_prior_info = malloc(num_params*2*sizeof(double));\n    memcpy(dnest_prior_info, prior_info, num_params*2*sizeof(double));\n  }\n  if(args != NULL)\n  {\n    dnest_args = args;\n  }\n\n  // read options\n  if(dnest_thistask == dnest_root)\n    options_load(optfile, opts);\n  MPI_Bcast(&options, sizeof(DNestOptions), MPI_BYTE, dnest_root, MPI_COMM_WORLD);\n\n  //dnest_post_temp = 1.0;\n  compression = exp(1.0);\n  regularisation = options.new_level_interval*sqrt(options.lam);\n  save_to_disk = true;\n\n  // particles\n  particle_offset_size = dnest_size_of_modeltype/sizeof(void);\n  particle_offset_double = dnest_size_of_modeltype/sizeof(double);\n  particles = (void *)malloc(options.num_particles*dnest_size_of_modeltype);\n  \n  // initialise sampler\n  if(dnest_thistask == dnest_root)\n    all_above = (LikelihoodType *)malloc(2*options.new_level_interval * sizeof(LikelihoodType));\n\n  above = (LikelihoodType *)malloc(2*options.new_level_interval * sizeof(LikelihoodType));\n\n  log_likelihoods = (LikelihoodType *)malloc(2*options.num_particles * sizeof(LikelihoodType));\n  level_assignments = (unsigned int*)malloc(options.num_particles * sizeof(unsigned int));\n\n  account_unaccepts = (unsigned int *)malloc(options.num_particles * sizeof(unsigned int));\n  for(i=0; i<options.num_particles; i++)\n  {\n    account_unaccepts[i] = 0;\n  }\n\n  if(options.max_num_levels != 0)\n  {\n    levels = (Level *)malloc(options.max_num_levels * sizeof(Level));\n    if(dnest_thistask == dnest_root)\n    {\n      levels_combine = (Level *)malloc(options.max_num_levels * sizeof(Level));\n      copies_of_levels = (Level *)malloc(dnest_totaltask * options.max_num_levels * sizeof(Level));\n    }\n\n    if(dnest_flag_limits == 1)\n    {\n      limits = malloc(options.max_num_levels * particle_offset_double * 2 * sizeof(double));\n      if(limits == NULL)\n      {\n        printf(\"Cannot allocate memory for limits.\\n\"\n               \"This usually happens when both the numbers of parameters and levels are extremely large.\\n\"\n               \"Please do not switch on '-l' option in argv passed to dnest.\\n\");\n        exit(EXIT_FAILURE);\n      }\n      for(i=0; i<options.max_num_levels; i++)\n      {\n        for(j=0; j<particle_offset_double; j++)\n        {\n          limits[i*2*particle_offset_double+ j*2] = DBL_MAX;\n          limits[i*2*particle_offset_double + j*2 + 1] = -DBL_MAX;\n        }\n      }\n\n      if(dnest_thistask == dnest_root)\n      {\n        copies_of_limits = malloc( dnest_totaltask * options.max_num_levels * particle_offset_double * 2 * sizeof(double));\n        if(copies_of_limits == NULL)\n        {\n          printf(\"Cannot allocate memory for limits.\\n\"\n                 \"This usually happens when both the numbers of parameters and levels are extremely large.\\n\"\n                 \"Please do not switch on '-l' option in argv passed to dnest.\\n\");\n          exit(EXIT_FAILURE);\n        }\n      }\n    }\n  }\n  else\n  {\n    levels = (Level *)malloc(LEVEL_NUM_MAX * sizeof(Level));\n    if(dnest_thistask == dnest_root)\n    {\n      levels_combine = (Level *)malloc(LEVEL_NUM_MAX * sizeof(Level));\n      copies_of_levels = (Level *)malloc(dnest_totaltask * LEVEL_NUM_MAX * sizeof(Level));\n    }\n\n    if(dnest_flag_limits == 1)\n    {\n      limits = malloc(LEVEL_NUM_MAX * particle_offset_double * 2 * sizeof(double));\n      if(limits == NULL)\n      {\n        printf(\"Cannot allocate memory for limits.\\n\"\n               \"This usually happens when both the numbers of parameters and levels are extremely large.\\n\"\n               \"Please do not switch on '-l' option in argv passed to dnest.\\n\");\n        exit(EXIT_FAILURE);\n      }\n      for(i=0; i<LEVEL_NUM_MAX; i++)\n      {\n        for(j=0; j<particle_offset_double; j++)\n        {\n          limits[i*2*particle_offset_double + j*2] = DBL_MAX;\n          limits[i*2*particle_offset_double + j*2 + 1] = -DBL_MAX;\n        }\n      }\n\n      if(dnest_thistask == dnest_root)\n      {\n        copies_of_limits = malloc(dnest_totaltask * LEVEL_NUM_MAX * particle_offset_double * 2 * sizeof(double));\n        if(copies_of_limits == NULL)\n        {\n          printf(\"Cannot allocate memory for limits.\\n\"\n                 \"This usually happens when both the numbers of parameters and levels are extremely large.\\n\"\n                 \"Please do not switch on '-l' option in argv passed to dnest.\\n\");\n          exit(EXIT_FAILURE);\n        }\n      }\n    }\n  }\n  \n  dnest_perturb_accept = malloc(options.num_particles * sizeof(int));\n  for(i=0; i<options.num_particles; i++)\n  {\n    dnest_perturb_accept[i] = 0;\n  }\n\n  count_mcmc_steps = 0;\n  count_saves = 0;\n  num_saves = (int)fmax(0.02*options.max_num_saves, 1.0);\n  num_saves_restart = (int)fmax(0.2 * options.max_num_saves, 1.0);\n\n// first level\n  size_levels = 0;\n  size_above = 0;\n  size_all_above = 0;\n  LikelihoodType like_tmp = {-DBL_MAX, gsl_rng_uniform(dnest_gsl_r)};\n  Level level_tmp = {like_tmp, 0.0, 0, 0, 0, 0};\n  levels[size_levels] = level_tmp;\n  size_levels++;\n\n  if(dnest_thistask == dnest_root)\n  {\n    size_levels_combine = 0;\n    levels_combine[size_levels_combine] = level_tmp;\n    size_levels_combine++;\n  }\n  \n  for(i=0; i<options.num_particles; i++)\n  {\n    dnest_which_particle_update = i;\n    dnest_which_level_update = 0;\n    from_prior(particles+i*particle_offset_size);\n    log_likelihoods[i].value = log_likelihoods_cal_initial(particles+i*particle_offset_size);\n    log_likelihoods[i].tiebreaker = dnest_rand();\n    level_assignments[i] = 0;\n  }\n\n  /*ModelType proposal;\n  printf(\"%f %f %f \\n\", particles[0].param[0], particles[0].param[1], particles[0].param[2] );\n  proposal = particles[0];\n  printf(\"%f %f %f \\n\", proposal.param[0], proposal.param[1], proposal.param[2] );*/\n}\n\nvoid finalise()\n{\n  free(particles);\n  free(above);\n  free(log_likelihoods);\n  free(level_assignments);\n  free(levels);\n\n  free(account_unaccepts);\n\n  if(dnest_flag_limits == 1)\n    free(limits);\n\n\n  if(dnest_thistask == dnest_root)\n  {\n    free(all_above);\n    free(levels_combine);\n    free(copies_of_levels);\n    if(dnest_flag_limits == 1)\n      free(copies_of_limits);\n  }\n  gsl_rng_free(dnest_gsl_r);\n\n  free(dnest_perturb_accept);\n\n  if(dnest_param_range != NULL)\n  {\n    free(dnest_param_range);\n  }\n  if(dnest_prior_type != NULL)\n  {\n    free(dnest_prior_type);\n  }\n  if(dnest_prior_info != NULL)\n  {\n    free(dnest_prior_info);\n  }\n\n  if(dnest_thistask == dnest_root)\n  {\n    printf(\"# Finalizing CDNest.\\n\");\n    printf(\"#=======================================================\\n\");\n  }\n}\n\nint dnest_search_pardict(DNestPARDICT *pardict, int num_pardict, char *tag)\n{\n  int i;\n  for(i=0; i<num_pardict; i++)\n  {\n    if(strcmp(pardict[i].tag, tag) == 0)\n    {\n      return i;\n    }\n  }\n\n  fprintf(stderr, \"# cdnest no match of tag %s.\\n\", tag);\n  return num_pardict+1;\n}\n\nvoid options_load(char *optfile, DNestOptions *opts)\n{\n  if(strlen(optfile) > 0)\n  {\n    DNestPARDICT *pardict;\n    int num_pardict;\n    pardict = malloc(10 * sizeof(DNestPARDICT));\n    enum TYPE {INT, DOUBLE, STRING};\n  \n    FILE *fp;\n    char str[BUF_MAX_LENGTH], buf1[BUF_MAX_LENGTH], buf2[BUF_MAX_LENGTH], buf3[BUF_MAX_LENGTH];\n  \n    int i, j, nt, idx;\n    nt = 0;\n    strcpy(pardict[nt].tag, \"NumberParticles\");\n    pardict[nt].addr = &options.num_particles;\n    pardict[nt].isset = 0;\n    pardict[nt++].id = INT;\n  \n    strcpy(pardict[nt].tag, \"NewLevelIntervalFactor\");\n    pardict[nt].addr = &options.new_level_interval_factor;\n    pardict[nt].isset = 0;\n    pardict[nt++].id = DOUBLE;\n  \n    strcpy(pardict[nt].tag, \"SaveIntervalFactor\");\n    pardict[nt].addr = &options.save_interval_factor;\n    pardict[nt].isset = 0;\n    pardict[nt++].id = DOUBLE;\n  \n    strcpy(pardict[nt].tag, \"ThreadStepsFactor\");\n    pardict[nt].addr = &options.thread_steps_factor;\n    pardict[nt].isset = 0;\n    pardict[nt++].id = DOUBLE;\n  \n    strcpy(pardict[nt].tag, \"MaxNumberLevels\");\n    pardict[nt].addr = &options.max_num_levels;\n    pardict[nt].isset = 0;\n    pardict[nt++].id = INT;\n  \n    strcpy(pardict[nt].tag, \"BacktrackingLength\");\n    pardict[nt].addr = &options.lam;\n    pardict[nt].isset = 0;\n    pardict[nt++].id = DOUBLE;\n   \n    strcpy(pardict[nt].tag, \"StrengthEqualPush\");\n    pardict[nt].addr = &options.beta;\n    pardict[nt].isset = 0;\n    pardict[nt++].id = DOUBLE;\n  \n    strcpy(pardict[nt].tag, \"MaxNumberSaves\");\n    pardict[nt].addr = &options.max_num_saves;\n    pardict[nt].isset = 0;\n    pardict[nt++].id = INT;\n  \n    strcpy(pardict[nt].tag, \"PTol\");\n    pardict[nt].addr = &options.max_ptol;\n    pardict[nt].isset = 0;\n    pardict[nt++].id = DOUBLE;\n    \n    num_pardict = nt;\n  \n    /* default values */\n    options.new_level_interval_factor = 2;\n    options.save_interval_factor = options.new_level_interval_factor;\n    options.thread_steps_factor = 10;\n    options.num_particles = 1;\n    options.max_num_levels = 0;\n    options.lam = 10.0;\n    options.beta = 100.0;\n    options.max_ptol = 0.1;\n    options.max_num_saves = 10000;\n     \n    fp = fopen(options_file, \"r\");\n    if(fp == NULL)\n    {\n      fprintf(stderr, \"# ERROR: Cannot open options file %s.\\n\", options_file);\n      exit(0);\n    }\n    \n    while(!feof(fp))\n    {\n      sprintf(str,\"empty\");\n      fgets(str, 200, fp);\n      if(sscanf(str, \"%s%s%s\", buf1, buf2, buf3)<2)\n        continue;\n      if(buf1[0]=='%' || buf1[0] == '#')\n        continue;\n      for(i=0, j=-1; i<nt; i++)\n        if(strcmp(buf1, pardict[i].tag) == 0 && pardict[i].isset == 0)\n        {\n          j = i;\n          pardict[i].isset = 1;\n          //printf(\"%s %s\\n\", buf1, buf2);\n          break;\n        }\n      if(j >=0)\n      {\n        switch(pardict[j].id)\n        {\n          case DOUBLE:\n            *((double *) pardict[j].addr) = atof(buf2);\n            break;\n          case STRING:\n            strcpy(pardict[j].addr, buf2);\n            break;\n          case INT:\n            *((unsigned int *)pardict[j].addr) = (unsigned int) atof(buf2);\n            break;\n        }\n      }\n      else\n      {\n        fprintf(stderr, \"# Error in file %s: Tag '%s' is not allowed or multiple defined.\\n\",\n                      options_file, buf1);\n        exit(0);\n      }\n    }\n    fclose(fp);\n  \n    /* check options */\n    idx = dnest_search_pardict(pardict, num_pardict, \"SaveIntervalFactor\");\n    if(pardict[idx].isset == 0)  /* if not set */\n    {\n      options.save_interval_factor = options.new_level_interval_factor;\n    }\n\n    free(pardict);\n  }\n  else \n  {\n    options.new_level_interval_factor = opts->new_level_interval_factor;\n    options.save_interval_factor = opts->save_interval_factor;\n    options.thread_steps_factor = opts->thread_steps_factor;\n    options.num_particles = opts->num_particles;\n    options.max_num_levels = opts->max_num_levels;\n    options.lam = opts->lam;\n    options.beta = opts->beta;\n    options.max_ptol = opts->max_ptol;\n    options.max_num_saves = opts->max_num_saves;\n  }\n  \n  options.thread_steps = dnest_num_params * options.thread_steps_factor * options.num_particles;\n  options.new_level_interval =  dnest_totaltask * options.thread_steps * options.new_level_interval_factor;\n  options.save_interval =  dnest_totaltask * options.thread_steps * options.save_interval_factor;\n  \n  //fgets(buf, BUF_MAX_LENGTH, fp);\n  //sscanf(buf, \"%s\", options.sample_file);\n  strcpy(options.sample_file, dnest_sample_dir);\n  strcat(options.sample_file,\"/sample\");\n  strcat(options.sample_file, dnest_sample_tag);\n  strcat(options.sample_file, \".txt\");\n  strcat(options.sample_file, dnest_sample_postfix);\n  \n  //fgets(buf, BUF_MAX_LENGTH, fp);\n  //sscanf(buf, \"%s\", options.sample_info_file);\n  strcpy(options.sample_info_file, dnest_sample_dir);\n  strcat(options.sample_info_file,\"/sample_info\");\n  strcat(options.sample_info_file, dnest_sample_tag);\n  strcat(options.sample_info_file, \".txt\");\n  strcat(options.sample_info_file, dnest_sample_postfix);\n  \n  //fgets(buf, BUF_MAX_LENGTH, fp);\n  //sscanf(buf, \"%s\", options.levels_file);\n  strcpy(options.levels_file, dnest_sample_dir);\n  strcat(options.levels_file,\"/levels\");\n  strcat(options.levels_file, dnest_sample_tag);\n  strcat(options.levels_file, \".txt\");\n  strcat(options.levels_file, dnest_sample_postfix);\n  \n  //fgets(buf, BUF_MAX_LENGTH, fp);\n  //sscanf(buf, \"%s\", options.sampler_state_file);\n  strcpy(options.sampler_state_file, dnest_sample_dir);\n  strcat(options.sampler_state_file,\"/sampler_state\");\n  strcat(options.sampler_state_file, dnest_sample_tag);\n  strcat(options.sampler_state_file, \".txt\");\n  strcat(options.sampler_state_file, dnest_sample_postfix);\n  \n  //fgets(buf, BUF_MAX_LENGTH, fp);\n  //sscanf(buf, \"%s\", options.posterior_sample_file);\n  strcpy(options.posterior_sample_file, dnest_sample_dir);\n  strcat(options.posterior_sample_file,\"/posterior_sample\");\n  strcat(options.posterior_sample_file, dnest_sample_tag);\n  strcat(options.posterior_sample_file, \".txt\");\n  strcat(options.posterior_sample_file, dnest_sample_postfix);\n\n  //fgets(buf, BUF_MAX_LENGTH, fp);\n  //sscanf(buf, \"%s\", options.posterior_sample_info_file);\n  strcpy(options.posterior_sample_info_file, dnest_sample_dir);\n  strcat(options.posterior_sample_info_file,\"/posterior_sample_info\");\n  strcat(options.posterior_sample_info_file, dnest_sample_tag);\n  strcat(options.posterior_sample_info_file, \".txt\");\n  strcat(options.posterior_sample_info_file, dnest_sample_postfix);\n\n  //fgets(buf, BUF_MAX_LENGTH, fp);\n  //sscanf(buf, \"%s\", options.limits_file);\n  strcpy(options.limits_file, dnest_sample_dir);\n  strcat(options.limits_file,\"/limits\");\n  strcat(options.limits_file, dnest_sample_tag);\n  strcat(options.limits_file, \".txt\");\n  strcat(options.limits_file, dnest_sample_postfix);\n\n  // check options.\n  \n  if(options.new_level_interval < dnest_totaltask * options.thread_steps)\n  {\n    printf(\"# incorrect options:\\n\");\n    printf(\"# new level interval should be equal to or larger than\"); \n    printf(\"  totaltask * thread step.\\n\");\n    exit(0);\n  }\n\n  char fname[STR_MAX_LENGTH];\n  strcpy(fname, dnest_sample_dir);\n  strcat(fname, \"/DNEST_OPTIONS\");\n  FILE *fp = fopen(fname, \"w\");\n  if(fp == NULL)\n  {\n    fprintf(stderr, \"# ERROR: Cannot write file %s.\\n\", fname);\n    exit(0);\n  }\n  fprintf(fp, \"NumberParticles          %d  # Number of particles\\n\", options.num_particles);\n  fprintf(fp, \"NewLevelIntervalFactor   %.2f  # New level interval factor\\n\", options.new_level_interval_factor);\n  fprintf(fp, \"SaveIntervalFactor       %.2f  # Save interval factor\\n\", options.save_interval_factor);\n  fprintf(fp, \"ThreadStepsFactor        %.2f  # ThreadSteps factor\\n\", options.thread_steps_factor);\n  fprintf(fp, \"MaxNumberLevels          %d  # Maximum number of levels\\n\", options.max_num_levels);\n  fprintf(fp, \"BacktrackingLength       %.1f  # Backtracking scale length\\n\", options.lam);\n  fprintf(fp, \"StrengthEqualPush        %.1f  # Strength of effect to force histogram to equal push\\n\", options.beta);\n  fprintf(fp, \"MaxNumberSaves           %d    # Maximum number of saves\\n\", options.max_num_saves);\n  fprintf(fp, \"PTol                     %.1e  # Likelihood tolerance in loge\\n\", options.max_ptol);\n  fprintf(fp, \"ThreadSteps              %d   #\\n\", options.thread_steps);\n  fprintf(fp, \"SaveInterval             %d   #\\n\", options.save_interval);\n  fprintf(fp, \"NewLevelInterval         %d  #\\n\", options.new_level_interval);\n  fprintf(fp, \"SampleFile               %s  #\\n\", options.sample_file);\n  fprintf(fp, \"SampleInfoFile           %s  #\\n\", options.sample_info_file);\n  fprintf(fp, \"SamplerStateFile         %s  #\\n\", options.sampler_state_file);\n  fprintf(fp, \"PosteriorSampleFile      %s  #\\n\", options.posterior_sample_file);\n  fprintf(fp, \"PosteriorSampleInfoFile  %s  #\\n\", options.posterior_sample_info_file);\n  fprintf(fp, \"LevelsFile               %s  #\\n\", options.levels_file);\n  if(dnest_flag_limits == 1)\n    fprintf(fp, \"LimitsFile               %s  #\\n\", options.limits_file);\n  fprintf(fp, \"NumberCores              %d   # Number of cores\\n\", dnest_totaltask);\n  fprintf(fp, \"NumberParameters         %d   # Number of parameters\\n\", dnest_num_params);\n  fclose(fp);\n}\n\n\ndouble mod(double y, double x)\n{\n  if(x > 0.0)\n  {\n    return (y/x - floor(y/x))*x;\n  }\n  else if(x == 0.0)\n  {\n    return 0.0;\n  }\n  else\n  {\n    printf(\"Warning in mod(double, double) %e\\n\", x);\n    exit(0);\n  }\n  \n}\n\ninline void dnest_wrap(double *x, double min, double max)\n{\n  *x = mod(*x - min, max - min) + min;\n}\n\ninline void wrap_limit(double *x, double min, double max)\n{\n\n  *x = fmax(fmin(*x, max), min);\n}\n\ninline int mod_int(int y, int x)\n{\n  if(y >= 0)\n    return y - (y/x)*x;\n  else\n    return (x-1) - mod_int(-y-1, x);\n}\n\ninline double dnest_randh()\n{\n  return pow(10.0, 1.5 - 3.0*fabs(gsl_ran_tdist(dnest_gsl_r, 2))) * gsl_ran_ugaussian(dnest_gsl_r);\n}\n\ninline double dnest_rand()\n{\n  return gsl_rng_uniform(dnest_gsl_r);\n}\n\ninline int dnest_rand_int(int size)\n{\n  return gsl_rng_uniform_int(dnest_gsl_r, size);\n}\n\ninline double dnest_randn()\n{\n  return gsl_ran_ugaussian(dnest_gsl_r);\n}\n\nint dnest_cmp(const void *pa, const void *pb)\n{\n  LikelihoodType *a = (LikelihoodType *)pa;\n  LikelihoodType *b = (LikelihoodType *)pb;\n\n  // in decesending order\n  if(a->value > b->value)\n    return false;\n  if( a->value == b->value && a->tiebreaker > b->tiebreaker)\n    return false;\n  \n  return true;\n}\n\n\ninline int dnest_get_size_levels()\n{\n  return size_levels;\n}\n\ninline int dnest_get_which_level_update()\n{\n  return dnest_which_level_update;\n}\n\ninline int dnest_get_which_particle_update()\n{\n  return dnest_which_particle_update;\n}\n\ninline unsigned int dnest_get_which_num_saves()\n{\n  return num_saves;\n}\nunsigned int dnest_get_count_saves()\n{\n  return count_saves;\n}\n\ninline unsigned long long int dnest_get_count_mcmc_steps()\n{\n  return count_mcmc_steps;\n}\n\ninline void dnest_get_posterior_sample_file(char *fname)\n{\n  strcpy(fname, options.posterior_sample_file);\n  return;\n}\n\ninline void dnest_get_limit(int ilevel, int jparam, double *limit1, double *limit2)\n{\n  *limit1 = limits[ilevel*dnest_num_params*2 + jparam * 2 + 0];\n  *limit2 = limits[ilevel*dnest_num_params*2 + jparam * 2 + 1];\n  return;\n}\n/* \n * version check\n * \n *  1: greater\n *  0: equal\n * -1: lower\n */\nint dnest_check_version(char *version_str)\n{\n  int major, minor, patch;\n\n  sscanf(version_str, \"%d.%d.%d\", &major, &minor, &patch);\n  \n  if(major > DNEST_MAJOR_VERSION)\n    return 1;\n  if(major < DNEST_MAJOR_VERSION)\n    return -1;\n\n  if(minor > DNEST_MINOR_VERSION)\n    return 1;\n  if(minor < DNEST_MINOR_VERSION)\n    return -1;\n\n  if(patch > DNEST_PATCH_VERSION)\n    return 1;\n  if(patch > DNEST_PATCH_VERSION)\n    return -1;\n\n  return 0;\n}\n\nvoid dnest_check_fptrset(DNestFptrSet *fptrset)\n{\n  if(fptrset->from_prior == NULL)\n  {\n    printf(\"\\\"from_prior\\\" function is not defined at task %d.\\\n      \\nSet to the default function in dnest.\\n\", dnest_thistask);\n    fptrset->from_prior = dnest_from_prior;\n  }\n\n  if(fptrset->print_particle == NULL)\n  {\n    printf(\"\\\"print_particle\\\" function is not defined at task %d. \\\n      \\nSet to be default function in dnest.\\n\", dnest_thistask);\n    fptrset->print_particle = dnest_print_particle;\n  }\n\n  if(fptrset->read_particle == NULL)\n  {\n    printf(\"\\\"read_particle\\\" function is not defined at task %d. \\\n      \\nSet to be default function in dnest.\\n\", dnest_thistask);\n    fptrset->read_particle = dnest_read_particle;\n  }\n\n  if(fptrset->log_likelihoods_cal == NULL)\n  {\n    printf(\"\\\"log_likelihoods_cal\\\" function is not defined at task %d.\\n\", dnest_thistask);\n    exit(0);\n  }\n\n  if(fptrset->log_likelihoods_cal_initial == NULL)\n  {\n    printf(\"\\\"log_likelihoods_cal_initial\\\" function is not defined at task %d. \\\n      \\nSet to the same as \\\"log_likelihoods_cal\\\" function.\\n\", dnest_thistask);\n    fptrset->log_likelihoods_cal_initial = fptrset->log_likelihoods_cal;\n  }\n\n  if(fptrset->log_likelihoods_cal_restart == NULL)\n  {\n    printf(\"\\\"log_likelihoods_cal_restart\\\" function is not defined at task %d. \\\n      \\nSet to the same as \\\"log_likelihoods_cal\\\" function.\\n\", dnest_thistask);\n    fptrset->log_likelihoods_cal_restart = fptrset->log_likelihoods_cal;\n  }\n\n  if(fptrset->perturb == NULL)\n  {\n    printf(\"\\\"perturb\\\" function is not defined at task %d.\\\n      \\nSet to the default function in dnest.\\n\", dnest_thistask);\n    fptrset->perturb = dnest_perturb;\n  }\n\n  if(fptrset->restart_action == NULL)\n  {\n    printf(\"\\\"restart_action\\\" function is not defined at task %d.\\\n      \\nSet to the default function in dnest.\\n\", dnest_thistask);\n    fptrset->restart_action = dnest_restart_action;\n  }\n\n  if(fptrset->accept_action == NULL)\n  {\n    printf(\"\\\"accept_action\\\" function is not defined at task %d.\\\n      \\nSet to the default function in dnest.\\n\", dnest_thistask);\n    fptrset->accept_action = dnest_accept_action;\n  }\n\n  if(fptrset->kill_action == NULL)\n  {\n    printf(\"\\\"kill_action\\\" function is not defined at task %d.\\\n      \\nSet to the default function in dnest.\\n\", dnest_thistask);\n    fptrset->kill_action = dnest_kill_action;\n  }\n\n  return;\n}\n\nDNestFptrSet * dnest_malloc_fptrset()\n{\n  DNestFptrSet * fptrset;\n  fptrset = (DNestFptrSet *)malloc(sizeof(DNestFptrSet));\n\n  fptrset->from_prior = NULL;\n  fptrset->log_likelihoods_cal = NULL;\n  fptrset->log_likelihoods_cal_initial = NULL;\n  fptrset->log_likelihoods_cal_restart = NULL;\n  fptrset->perturb = NULL;\n  fptrset->print_particle = NULL;\n  fptrset->read_particle = NULL;\n  fptrset->restart_action = NULL;\n  fptrset->accept_action = NULL;\n  fptrset->kill_action = NULL;\n  return fptrset;\n}\n\ninline void dnest_free_fptrset(DNestFptrSet * fptrset)\n{\n  free(fptrset);\n  return;\n}\n\nvoid dnest_check_directory(char *sample_dir)\n{\n  /* check if sample_dir exists\n   * if not, create it;\n   * if exists, check if it is a directory;\n   * if not, throw an error.*/\n  struct stat st;\n  int status;\n  status = stat(sample_dir, &st);\n  if(status != 0)\n  {\n    printf(\"================================\\n\"\n           \"Directory %s not exist! create it.\\n\", sample_dir);\n    status = mkdir(sample_dir, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);\n    if(status!=0)\n    {\n      printf(\"Cannot create %s\\n\"\n             \"================================\\n\", sample_dir);\n    }\n  }\n  else\n  {\n    if(!S_ISDIR(st.st_mode))\n    {\n      printf(\"================================\\n\"\n             \"%s is not a direcotry!\\n\"\n             \"================================\\n\", sample_dir);\n      exit(-1);\n    }\n  }\n  return;\n}\n\n/*!\n *  Save sampler state for later restart. \n */\nvoid dnest_save_restart()\n{\n  FILE *fp;\n  int i, j;\n  void *particles_all;\n  LikelihoodType *log_likelihoods_all;\n  unsigned int *level_assignments_all;\n  char str[200];\n\n  if(dnest_thistask == dnest_root)\n  {\n    sprintf(str, \"%s_%d\", file_save_restart, count_saves);\n    fp = fopen(str, \"wb\");\n    if(fp == NULL)\n    {\n      fprintf(stderr, \"# Error: Cannot open file %s. \\n\", file_save_restart);\n      exit(0);\n    }\n\n    particles_all = (void *)malloc( options.num_particles *  dnest_totaltask * dnest_size_of_modeltype );\n\n\n    log_likelihoods_all = (LikelihoodType *)malloc(dnest_totaltask * options.num_particles * sizeof(LikelihoodType));\n    level_assignments_all = (unsigned int*)malloc(dnest_totaltask * options.num_particles * sizeof(unsigned int));\n  }\n\n  MPI_Gather(particles, options.num_particles * dnest_size_of_modeltype, MPI_BYTE, \n    particles_all, options.num_particles * dnest_size_of_modeltype, MPI_BYTE, dnest_root, MPI_COMM_WORLD);\n\n  MPI_Gather(level_assignments, options.num_particles * sizeof(unsigned int), MPI_BYTE, \n    level_assignments_all, options.num_particles * sizeof(unsigned int), MPI_BYTE, dnest_root, MPI_COMM_WORLD);\n\n  MPI_Gather(log_likelihoods, options.num_particles * sizeof(LikelihoodType), MPI_BYTE, \n    log_likelihoods_all, options.num_particles * sizeof(LikelihoodType), MPI_BYTE, dnest_root, MPI_COMM_WORLD);\n\n\n  if(dnest_thistask == dnest_root )\n  {\n    printf(\"# Save restart data to file %s.\\n\", str);\n\n    //fprintf(fp, \"%d %d\\n\", count_saves, count_mcmc_steps);\n    //fprintf(fp, \"%d\\n\", size_levels_combine);\n\n    fwrite(&count_saves, sizeof(int), 1, fp);\n    fwrite(&count_mcmc_steps, sizeof(int), 1, fp);\n    fwrite(&size_levels_combine, sizeof(int), 1, fp);\n\n    for(i=0; i<size_levels_combine; i++)\n    {\n      //fprintf(fp, \"%14.12g %14.12g %f %llu %llu %llu %llu\\n\", levels_combine[i].log_X, levels_combine[i].log_likelihood.value, \n      //  levels_combine[i].log_likelihood.tiebreaker, levels_combine[i].accepts,\n      //  levels_combine[i].tries, levels[i].exceeds, levels_combine[i].visits);\n\n      fwrite(&levels_combine[i], sizeof(Level), 1, fp);\n    }\n\n    for(j=0; j<dnest_totaltask; j++)\n    {\n      for(i=0; i<options.num_particles; i++)\n      {\n        //fprintf(fp, \"%d %e %f\\n\", level_assignments_all[j*options.num_particles + i], \n        //  log_likelihoods_all[j*options.num_particles + i].value,\n        //  log_likelihoods_all[j*options.num_particles + i].tiebreaker);  \n\n        fwrite(&level_assignments_all[j*options.num_particles + i], sizeof(int), 1, fp);\n        fwrite(&log_likelihoods_all[j*options.num_particles + i], sizeof(LikelihoodType), 1, fp);    \n      }\n    }\n    \n    if(dnest_flag_limits == 1)\n    {\n      for(i=0; i<size_levels_combine; i++)\n      {\n        //fprintf(fp, \"%d  \", i);\n        for(j=0; j<particle_offset_double; j++)\n        {\n          //fprintf(fp, \"%f  %f  \", limits[i*2*particle_offset_double+j*2], limits[i*2*particle_offset_double+j*2+1]);\n          fwrite(&limits[i*2*particle_offset_double+j*2], sizeof(double), 2, fp);\n        }\n  \n          //fprintf(fp, \"\\n\");\n      }\n    }\n    \n    for(j=0; j<dnest_totaltask; j++)\n    {\n      for(i=0; i<options.num_particles; i++)\n      {\n        //print_particle(fp, particles_all + (j * options.num_particles + i) * particle_offset_size);\n        fwrite(particles_all + (j * options.num_particles + i) * particle_offset_size, dnest_size_of_modeltype, 1, fp);\n      } \n    }\n    \n    fclose(fp);\n    free(particles_all);\n    free(log_likelihoods_all);\n    free(level_assignments_all);\n  }\n\n  restart_action(0);\n}\n\nvoid dnest_restart()\n{\n  FILE *fp;\n  int i, j;\n  void *particles_all;\n  unsigned int *level_assignments_all;\n  LikelihoodType *log_likelihoods_all;\n  void *particle;\n\n  if(dnest_thistask == dnest_root)\n  {\n    fp = fopen(file_restart, \"rb\");\n    if(fp == NULL)\n    {\n      fprintf(stderr, \"# Error: Cannot open file %s. \\n\", file_restart);\n      exit(0);\n    }\n\n    printf(\"# Reading %s\\n\", file_restart);\n\n    particles_all = (void *)malloc( options.num_particles *  dnest_totaltask * dnest_size_of_modeltype );\n    log_likelihoods_all = (LikelihoodType *)malloc(dnest_totaltask * options.num_particles * sizeof(LikelihoodType));\n    level_assignments_all = (unsigned int*)malloc(dnest_totaltask * options.num_particles * sizeof(unsigned int));\n\n    fread(&count_saves, sizeof(int), 1, fp);\n    fread(&count_mcmc_steps, sizeof(int), 1, fp);\n    fread(&size_levels_combine, sizeof(int), 1, fp);\n    \n    /* consider that the newly input max_num_levels may be different from the saved size of levels */\n    if(options.max_num_levels != 0)\n    {\n      if(size_levels_combine > options.max_num_levels)\n      {\n        printf(\"# input max_num_levels %d smaller than the one in restart data %d.\\n\", options.max_num_levels, size_levels_combine);\n        size_levels = options.max_num_levels;\n      }\n      else\n      {\n        size_levels = size_levels_combine;\n      }\n        \n    }\n    else  /* not input max_num_levels, directly use the saved size of levels */\n    {\n      if(size_levels_combine > LEVEL_NUM_MAX)\n      {\n        printf(\"# the saved size of levels %d exceeds LEVEL_NUM_MAX %d. \\n\", size_levels_combine, LEVEL_NUM_MAX);\n        exit(EXIT_FAILURE);\n      }\n      else\n      {\n        size_levels = size_levels_combine;\n      }\n    }\n    // read levels\n    for(i=0; i<size_levels_combine; i++)\n    {     \n      if(i<size_levels) // not read all the levels\n        fread(&levels_combine[i], sizeof(Level), 1, fp);\n      else\n        fseek(fp, sizeof(Level), SEEK_CUR); /* offset the file point */\n    }\n    memcpy(levels, levels_combine, size_levels * sizeof(Level));\n\n    // read level assignment\n    for(j=0; j<dnest_totaltask; j++)\n    {\n      for(i=0; i<options.num_particles; i++)\n      {\n        fread(&level_assignments_all[j*options.num_particles + i], sizeof(int), 1, fp);\n        fread(&log_likelihoods_all[j*options.num_particles + i], sizeof(LikelihoodType), 1, fp); \n        \n        /* reset the level assignment that exceeds the present maximum level */\n        if(level_assignments_all[j*options.num_particles + i] > size_levels -1)\n        {\n          level_assignments_all[j*options.num_particles + i] = size_levels - 1;\n        }\n      }\n    }\n\n    // read limits\n    if(dnest_flag_limits == 1)\n    {\n      for(i=0; i<size_levels_combine; i++)\n      {\n        if(i < size_levels)\n        {\n          for(j=0; j<particle_offset_double; j++)\n          {\n            fread(&limits[i*2*particle_offset_double+j*2], sizeof(double), 2, fp);      \n          }\n        }\n        else \n        {\n          fseek(fp, sizeof(double) * 2 * particle_offset_double, SEEK_CUR); /* offset the file point */\n        }\n      }\n    }\n\n    // read particles\n    for(j=0; j<dnest_totaltask; j++)\n    {\n      for(i=0; i<options.num_particles; i++)\n      {\n        particle = (particles_all + (j * options.num_particles + i) * dnest_size_of_modeltype);\n        fread(particle, dnest_size_of_modeltype, 1, fp);\n      }\n    }\n\n    fclose(fp);\n  }\n\n  MPI_Bcast(&count_saves, 1, MPI_INT, dnest_root, MPI_COMM_WORLD);\n  MPI_Bcast(&count_mcmc_steps, 1, MPI_INT, dnest_root, MPI_COMM_WORLD);\n  MPI_Bcast(&size_levels, 1, MPI_INT, dnest_root, MPI_COMM_WORLD);\n  MPI_Bcast(levels, size_levels * sizeof(Level), MPI_BYTE, dnest_root,  MPI_COMM_WORLD); \n  \n  if(count_saves > options.max_num_saves)\n  {\n    if(dnest_thistask == dnest_root)\n    {\n      printf(\"# Number of samples already larger than the input number, exit!\\n\");\n    }\n    MPI_Barrier(MPI_COMM_WORLD);\n    exit(0);\n  }\n  size_levels_combine = size_levels; /* reset szie_levels_combine */\n  \n  num_saves = (int)fmax(0.02*(options.max_num_saves-count_saves), 1.0); /* reset num_saves */\n  num_saves_restart = (int)fmax(0.2 * (options.max_num_saves-count_saves), 1.0); /* reset num_saves_restart */\n\n  if(dnest_flag_limits == 1)\n    MPI_Bcast(limits, size_levels * particle_offset_double * 2, MPI_DOUBLE, dnest_root, MPI_COMM_WORLD);\n\n  MPI_Scatter(level_assignments_all, options.num_particles * sizeof(unsigned int), MPI_BYTE,\n      level_assignments, options.num_particles * sizeof(unsigned int), MPI_BYTE, dnest_root, MPI_COMM_WORLD);\n\n  MPI_Scatter(log_likelihoods_all, options.num_particles * sizeof(LikelihoodType), MPI_BYTE, \n      log_likelihoods, options.num_particles * sizeof(LikelihoodType), MPI_BYTE, dnest_root, MPI_COMM_WORLD);\n\n  MPI_Scatter(particles_all, options.num_particles * dnest_size_of_modeltype, MPI_BYTE, \n    particles, options.num_particles * dnest_size_of_modeltype, MPI_BYTE, dnest_root, MPI_COMM_WORLD);\n\n  \n  restart_action(1);\n\n  for(i=0; i<options.num_particles; i++)\n  {\n    dnest_which_particle_update = i;\n    dnest_which_level_update = level_assignments[i];\n    //printf(\"%d %d %f\\n\", thistask, i, log_likelihoods[i].value);\n    log_likelihoods[i].value = log_likelihoods_cal_restart(particles+i*particle_offset_size);\n    //printf(\"%d %d %f\\n\", thistask, i, log_likelihoods[i].value);\n    //due to randomness, the original level assignment may be incorrect. re-asign the level\n    while(log_likelihoods[i].value < levels[level_assignments[i]].log_likelihood.value)\n    {\n      printf(\"# level assignment decrease %d %f %f %d.\\n\", i, log_likelihoods[i].value, \n        levels[level_assignments[i]].log_likelihood.value, level_assignments[i]);\n      level_assignments[i]--;\n    }\n    \n  }\n\n  if(dnest_thistask == dnest_root)\n  {\n    free(particles_all);\n    free(log_likelihoods_all);\n    free(level_assignments_all);\n  }\n  return;\n}\n\nvoid dnest_from_prior(void *model)\n{\n  int i;\n  double *pm = (double *)model;\n\n  for(i=0; i<dnest_num_params; i++)\n  {\n    if(dnest_prior_type[i] == GAUSSIAN )\n    {\n      pm[i] = dnest_randn() * dnest_prior_info[i*2+1] + dnest_prior_info[i*2+0];\n      dnest_wrap(&pm[i], dnest_param_range[i*2+0], dnest_param_range[i*2+1]);\n    }\n    else if(dnest_prior_type[i] == LOG)\n    {\n      pm[i] = log(dnest_param_range[i*2+0]) + dnest_rand()*(log(dnest_param_range[i*2+1]) - log(dnest_param_range[i*2+0]));\n      pm[i] = exp(pm[i]);\n    }\n    else \n    {\n      pm[i] = dnest_param_range[i*2+0] + dnest_rand()*(dnest_param_range[i*2+1] - dnest_param_range[i*2+0]);\n    }\n  }\n}\n\ndouble dnest_perturb(void *model)\n{\n  double *pm = (double *)model;\n  double logH = 0.0, width;\n  int which;\n\n  which = dnest_rand_int(dnest_num_params);\n\n  width = ( dnest_param_range[which*2+1] - dnest_param_range[which*2+0] );\n\n  if(dnest_prior_type[which] == UNIFORM)\n  {\n    pm[which] += dnest_randh() * width;\n    dnest_wrap(&(pm[which]), dnest_param_range[which*2+0], dnest_param_range[which*2+1]);\n  }\n  else if(dnest_prior_type[which] == LOG)\n  {\n    logH -= (-log(pm[which]));\n    pm[which] += dnest_randh() * width;\n    dnest_wrap(&(pm[which]), dnest_param_range[which*2+0], dnest_param_range[which*2+1]);\n    logH += (-log(pm[which]));\n  }\n  else\n  {\n    logH -= (-0.5*pow((pm[which] - dnest_prior_info[which*2+0])/dnest_prior_info[which*2+1], 2.0) );\n    pm[which] += dnest_randh() * width;\n    dnest_wrap(&pm[which], dnest_param_range[which*2+0], dnest_param_range[which*2+1]);\n    logH += (-0.5*pow((pm[which] - dnest_prior_info[which*2+0])/dnest_prior_info[which*2+1], 2.0) );\n  }\n  \n  return logH;\n}\n\ninline void dnest_print_particle(FILE *fp, const void *model)\n{\n  int i;\n  double *pm = (double *)model;\n\n  for(i=0; i<dnest_num_params; i++)\n  {\n    fprintf(fp, \"%e \", pm[i] );\n  }\n  fprintf(fp, \"\\n\");\n  return;\n}\n\nvoid dnest_read_particle(FILE *fp, void *model)\n{\n  int j;\n  double *psample = (double *)model;\n\n  for(j=0; j < dnest_num_params; j++)\n  {\n    if(fscanf(fp, \"%lf\", psample+j) < 1)\n    {\n      printf(\"%f\\n\", *psample);\n      fprintf(stderr, \"#Error: Cannot read file %s.\\n\", options.sample_file);\n      exit(0);\n    }\n  }\n  return;\n}\n\ninline void dnest_restart_action(int iflag)\n{\n  return;\n}\n\ninline void dnest_accept_action()\n{\n  return;\n}\n\ninline void dnest_kill_action(int i, int i_copy)\n{\n  return;\n}", "meta": {"hexsha": "06c24b3da622218366a3b15222e9111a0c3f7eed", "size": 61608, "ext": "c", "lang": "C", "max_stars_repo_path": "src/dnest.c", "max_stars_repo_name": "LiyrAstroph/CDNest", "max_stars_repo_head_hexsha": "afb6b869ce1c4ebd76662b20310f1d9d3db4e26e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2019-09-11T03:34:45.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-16T12:14:05.000Z", "max_issues_repo_path": "src/dnest.c", "max_issues_repo_name": "LiyrAstroph/DNest_C", "max_issues_repo_head_hexsha": "afb6b869ce1c4ebd76662b20310f1d9d3db4e26e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2020-05-14T10:04:48.000Z", "max_issues_repo_issues_event_max_datetime": "2021-01-06T02:04:19.000Z", "max_forks_repo_path": "src/dnest.c", "max_forks_repo_name": "LiyrAstroph/DNest_C", "max_forks_repo_head_hexsha": "afb6b869ce1c4ebd76662b20310f1d9d3db4e26e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.8777885548, "max_line_length": 135, "alphanum_fraction": 0.6487144527, "num_tokens": 16972, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4765796510636759, "lm_q2_score": 0.048857781911394844, "lm_q1q2_score": 0.023284624655077732}}
{"text": "#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION\n\n#include <Python.h>\n#include <numpy/arrayobject.h>\n\n\n#include <gsl/gsl_rng.h>\n#include <gsl/gsl_randist.h>\n\n#include <math.h>\n\n// Forward function declaration.\nstatic PyObject *zsampler_sample_region(PyObject *self, PyObject *args);\nstatic PyObject *zsampler_sample_categorical(PyObject *self, PyObject *args);\n\n\n// Boilerplate: method list.\nstatic PyMethodDef methods[] = {\n  { \"sample_region\", zsampler_sample_region, METH_VARARGS, \"Doc string.\"},\n  { \"sample_bulk_categorical\", zsampler_sample_categorical, METH_VARARGS, \"Doc string.\"},\n  { NULL, NULL, 0, NULL } /* Sentinel */\n};\n\nstatic struct PyModuleDef sampler_module =\n{\n    PyModuleDef_HEAD_INIT,\n    \"zsampler\", /* name of module */\n    \"\",          /* module documentation, may be NULL */\n    -1,          /* size of per-interpreter state of the module, or -1 if the module keeps state in global variables. */\n    methods\n};\n\nPyMODINIT_FUNC PyInit_zsampler(void)\n{   \n    import_array(); // crucial command if NumPy API is used\n    return PyModule_Create(&sampler_module);\n}\n\n/*****************************************************************************\n * Helper methods                                                            *\n *****************************************************************************/\nvoid print_int_array(npy_int64* array, int length) {\n  for(int i = 0; i < length; i++) {\n    printf(\"%ld \", array[i]);\n  }\n  printf(\"\\n\");\n}\n\nvoid print_f_array(npy_float64* array, int length) {\n  for(int i = 0; i < length; i++) {\n    printf(\"%lf \", array[i]);\n  }\n  printf(\"\\n\");\n}\n\nstatic PyObject* zsampler_sample_categorical(PyObject *self, PyObject *args) {\n\n\n    PyArrayObject *py_Z, *py_prob;\n    if (!PyArg_ParseTuple(args, \"O!O!\",\n                            &PyArray_Type, &py_Z,\n                            &PyArray_Type, &py_prob)) {\n        return NULL;\n    }\n\n    npy_int64 C_N, C_K;\n    C_N = PyArray_SHAPE(py_prob)[0];\n    C_K = PyArray_SHAPE(py_prob)[1];\n\n    const gsl_rng_type * C_T;\n    gsl_rng * C_r;\n    gsl_rng_env_setup();\n    C_T = gsl_rng_taus;\n    C_r = gsl_rng_alloc (C_T);\n\n    double *_prob; // probabilities for sampling from multinomial\n    _prob = (double*)malloc(C_K * sizeof(double));\n\n    unsigned int *_new_sample;\n    _new_sample = (unsigned int*)malloc(C_K * sizeof(unsigned int));\n\n    PyArrayObject* out_Z = (PyArrayObject*)PyArray_NewCopy(py_Z, NPY_ANYORDER);\n    for (int i=0; i < C_N; i++) {\n\n        for (int k=0; k < C_K; k++) {\n            _prob[k] = (*(npy_float64*)PyArray_GETPTR2(py_prob, i, k));\n         }\n\n        gsl_ran_multinomial(C_r, (size_t)C_K, 1, _prob, _new_sample);\n\n        for (int k = 0; k < C_K; k++) {\n            npy_int64* Zk = (npy_int64*)PyArray_GETPTR2(out_Z, i, k);\n            Zk[0] = (npy_int64)_new_sample[k];\n         }\n    }\n\n    free(_prob);\n    free(_new_sample);\n    gsl_rng_free(C_r);\n    return (PyObject*)out_Z;  // no need to IncRef out_Z\n}\n\n\n//      Mixture weight priors is block-specific\nstatic PyObject* zsampler_sample_region(PyObject *self, PyObject *args) {\n\n  // Input variables\n  PyArrayObject *py_Z, *py_counts, *py_covariates, *py_beta, *py_alpha;\n  PyArrayObject *py_region_alloc, *py_region_label_counts;\n\n  /*  parse single numpy array argument */\n    if (!PyArg_ParseTuple(args, \"O!O!O!O!O!O!O!\",\n                            &PyArray_Type, &py_Z,\n                            &PyArray_Type, &py_counts,\n                            &PyArray_Type, &py_covariates,\n                            &PyArray_Type, &py_beta,\n                            &PyArray_Type, &py_alpha,\n                            &PyArray_Type, &py_region_alloc,\n                            &PyArray_Type, &py_region_label_counts)) {\n        return NULL;\n    }\n\n    Py_INCREF(py_region_alloc);\n    Py_INCREF(py_region_label_counts);\n\n    const gsl_rng_type * C_T;\n    gsl_rng * C_r;\n    gsl_rng_env_setup();\n    C_T = gsl_rng_taus;\n    C_r = gsl_rng_alloc (C_T);\n\n    // Temporary variables\n    npy_int64 C_N, C_K, C_J;\n    C_N = PyArray_SHAPE(py_Z)[0];\n    C_K = PyArray_SHAPE(py_Z)[1];\n    C_J = PyArray_SHAPE(py_beta)[0];\n\n    PyArrayObject* out_Z = (PyArrayObject*)PyArray_NewCopy(py_Z, NPY_ANYORDER);\n\n    npy_int64 *C_counts = (npy_int64 *) PyArray_DATA(py_counts);\n    npy_float64 *C_alpha = (npy_float64 *) PyArray_DATA(py_alpha);\n    npy_int64 *C_region_alloc = (npy_int64 *) PyArray_DATA(py_region_alloc);\n\n    npy_int64 C_labelsum;\n    npy_int64 *C_label_counts;\n    C_label_counts = (npy_int64*)malloc(C_K * sizeof(npy_int64));\n    double *_mu;\n    _mu = (double*)malloc(C_K * sizeof(double));\n    double *_logpoi;\n    _logpoi = (double*)malloc(C_K * sizeof(double));\n    double *_logcat;\n    _logcat =(double*)malloc(C_K * sizeof(double)); \n    double *_lik;\n    _lik =(double*)malloc(C_K * sizeof(double)); \n    double *_prob; // probabilities for sampling from multinomial\n    _prob = (double*)malloc(C_K * sizeof(double)); \n    unsigned int *_new_sample;\n    _new_sample = (unsigned int*)malloc(C_K * sizeof(unsigned int));\n\n    \n\n    npy_float64 C_alpha_sum = 0.0;\n    for(int k=0; k < C_K; k++) {\n      C_alpha_sum = C_alpha_sum + C_alpha[k];\n    }\n    \n    for (int i=0; i < C_N; i++) {\n\n      C_labelsum = 0;\n      for (int k = 0; k < C_K; k++) {\n        // subtract current cell counts from the region counts\n        npy_int64* accessor = (npy_int64*)PyArray_GETPTR2(py_region_label_counts, C_region_alloc[i], k);\n        accessor[0] = accessor[0] - (*(npy_int64*)PyArray_GETPTR2(out_Z, i, k));  // TODO: make this simpler\n\n        C_label_counts[k] = accessor[0];\n        C_labelsum = C_labelsum + C_label_counts[k];\n      }\n\n      // computation of likelihood and interim calculations\n      for (int k=0; k < C_K; k++) {\n        _mu[k] = 0;\n        for (int j=0; j < C_J; j++) {\n            _mu[k] = _mu[k] + ((*(npy_float64*)PyArray_GETPTR2(py_covariates, i, j)) * (*(npy_float64*)PyArray_GETPTR2(py_beta, j, k)));\n        }\n\n        _logpoi[k] = ((double)C_counts[i])*_mu[k] - exp(_mu[k]);\n        _logcat[k] = log(((double)C_label_counts[k] + C_alpha[k])  / ((double)C_labelsum + C_alpha_sum));\n\n        _lik[k] = (_logpoi[k] + _logcat[k]);\n      }\n\n      double maxval = _lik[0];\n      for (int k=0; k < C_K; k++) {\n        if(_lik[k] > maxval) {\n          maxval = _lik[k];\n        }\n      }\n\n      double sumexp = 0;\n      for (int k=0; k < C_K; k++) {\n        sumexp = sumexp + exp((double)_lik[k] - maxval);\n      }\n\n      double logsumexp = maxval + log(sumexp);\n\n      for (int k=0; k < C_K; k++) {\n        _prob[k] = exp((double)_lik[k] - logsumexp);\n      }\n\n      gsl_ran_multinomial(C_r, (size_t)C_K, 1, _prob, _new_sample);\n      for (int k = 0; k < C_K; k++) {\n        npy_int64* Zk = (npy_int64*)PyArray_GETPTR2(out_Z, i, k);\n        Zk[0] = (npy_int64)_new_sample[k];\n\n        // update the region label counts\n        npy_int64* accessor = (npy_int64*)PyArray_GETPTR2(py_region_label_counts, C_region_alloc[i], k);\n        accessor[0] = accessor[0] + Zk[0];\n      }\n    }\n\n    free(C_label_counts);\n    free(_mu);\n    free(_logpoi);\n    free(_logcat);\n    free(_lik);\n    free(_prob);\n    free(_new_sample);\n\n    gsl_rng_free(C_r);\n    Py_DECREF(py_region_alloc);\n    Py_DECREF(py_region_label_counts);\n    return (PyObject*)out_Z;  // no need to IncRef out_Z\n}\n", "meta": {"hexsha": "7390950efe690954cd7fbddd6a7a981d6a5ea640", "size": 7298, "ext": "c", "lang": "C", "max_stars_repo_path": "src/z_sampler/src/sampler.c", "max_stars_repo_name": "jp2011/spatial-poisson-mixtures", "max_stars_repo_head_hexsha": "9e535a636e710a9fa146cbbd4613ece70ec90791", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2020-06-18T10:57:47.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-07T12:13:04.000Z", "max_issues_repo_path": "src/z_sampler/src/sampler.c", "max_issues_repo_name": "jp2011/spatial-poisson-mixtures", "max_issues_repo_head_hexsha": "9e535a636e710a9fa146cbbd4613ece70ec90791", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/z_sampler/src/sampler.c", "max_forks_repo_name": "jp2011/spatial-poisson-mixtures", "max_forks_repo_head_hexsha": "9e535a636e710a9fa146cbbd4613ece70ec90791", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.188034188, "max_line_length": 136, "alphanum_fraction": 0.5907097835, "num_tokens": 2076, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.45326183324442865, "lm_q2_score": 0.05108274183263388, "lm_q1q2_score": 0.023153857210211497}}
{"text": "#ifndef GSL_INTERFACE_H\n#define GSL_INTERFACE_H\n\n\n#include <gsl/gsl_odeiv2.h>\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_matrix.h>\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/*****************************\n * Structure definitions\n *****************************\n */\n\n/**\n * Encapsulation of the integrator;\n*/\ntypedef struct cgsl_integrator{\n\n  const gsl_odeiv2_step_type * step_type; /* time step allocation */\n  gsl_odeiv2_step      * step;\t\t  /* time step control */\n  gsl_odeiv2_control   * control;\t  /* definition of the system */\n  gsl_odeiv2_system      system;\t  /* definition of the driver */\n  gsl_odeiv2_evolve    * evolution;\t  /* emove forward in time*/\n  gsl_odeiv2_driver    * driver;\t  /* high level interface */\n\n} cgsl_integrator;\n\n\n//see <gsl/gsl_odeiv2.h> for an explanation of these\ntypedef int (* ode_function_ptr ) (double t, const double y[], double dydt[], void * params);\ntypedef int (* ode_jacobian_ptr ) (double t, const double y[], double * dfdy, double dfdt[], void * params);\n\n/** Pre/post step callbacks\n *      t: Start of the current time step (communicationPoint)\n *     dt: Length of the current time step (communicationStepSize)\n *      n: Size of system\n *      y: For pre, the values of the variables before stepping. For post, after.\n * params: Opaque pointer\n */\ntypedef int (* pre_post_step_ptr ) (double t, double dt, int n, const double y[], void * params);\n\nenum cgsl_callback_actions{\n  CGSL_RESTART = 1                     // multistep integrators need a reset when\n                                // used with the epce filter.\n};\n  \n/**\n *\n *  This is intended to contain everything needed to integrate only one\n *  little bit at a time *and* to be able to backtrack when needed, and to\n *  have multiple instances of the model.\n *\n *  Here we use this for inheritance by aggregation so that each model is\n *  declared as\n *  typedef struct my_model{\n *     cgs_model   m;\n *         .\n *         .\n *     extra stuff\n *         .\n *         .\n *  }  my_model ;\n*/\n\ntypedef struct cgsl_model{\n  int n_variables;\n  double *x;  \t        /** state variables */\n  double *x_backup;     /** for get/set FMU state */\n  void * parameters;\n\n  /** Definition of the dynamical system: this assumes an *explicit* ODE */\n  ode_function_ptr function;\n  /** Jacobian */\n  ode_jacobian_ptr jacobian;\n\n  /** Pre/post step functions */\n  pre_post_step_ptr pre_step;\n  pre_post_step_ptr post_step;\n\n  /** Get/set FMU state\n   * Used to copy/retreive internal state to/from temporary storage inside the model\n   * params: Opaque pointer\n   */\n  void (* get_state) (struct cgsl_model *model);\n  void (* set_state) (struct cgsl_model *model);\n\n  /** Destructor */\n  void (* free) (struct cgsl_model * model);\n\n  /** Needed by ModelExchange to store content from parameters */\n  void* (*get_model_parameters)(const struct cgsl_model *model);\n} cgsl_model;\n\n/**\n * Useful function for allocating the most common type of model\n */\ncgsl_model* cgsl_model_default_alloc(\n        int n_variables,            /** Number of variables */\n        const double *x0,           /** Initial values. If NULL, initialize model->x to all zeroes instead */\n        void *parameters,           /** User pointer */\n        ode_function_ptr function,  /** ODE function */\n        ode_jacobian_ptr jacobian,  /** Jacobian */\n        pre_post_step_ptr pre_step, /** Pre-step function */\n        pre_post_step_ptr post_step,/** Post-step function */\n        size_t sz                   /** If sz > sizeof(cgsl_model) then allocate sz bytes instead.\n                                        Useful for the my_model case described earlier in this file */\n);\n\n\n/** Default destructor. Frees model->x and the model itself */\nvoid cgsl_model_default_free(cgsl_model *model);\n\n/**\n * Finally we can put everything in a bag.  The spefic model only has to\n * fill in these fields.\n */\ntypedef struct cgsl_simulation {\n\n  cgsl_model * model;         /** this contains the state variables */\n  cgsl_integrator i;\n  double t;\t\t      /** current time */\n  double t1;\t\t      /** stop time */\n  double h;\t\t      /** first stepsize and current value */\n\n  int   fixed_step;\t      /** whether or not we move at fixed step */\n  FILE * file;\n  int store_data;\t      /** whether or not we save the data in an array */\n  double * data;              /** store variables as integration proceeds */\n  int buffer_size;            /** size of data storage */\n  int n;\t\t      /** number of time steps taken */\n  int save;\t\t      /** persistence to file */\n  int print;\t\t      /** verbose on stderr */\n\n  int iterations;             /** Number of iterations done by last call to cgsl_step_to() */\n} cgsl_simulation;\n\n/*****************************\n * Enum  definitions\n *****************************\n */\n\n/**\n * List of available time integration methods in the gsl_odeiv2 library\n */\nenum cgsl_integrator_ids\n{\n  rk2,\t\t/* 0 */\n  rk4,\t\t/* 1 */\n  rkf45,\t/* 2 */\n  rkck,\t\t/* 3 */\n  rk8pd,\t/* 4 */\n  rk1imp,\t/* 5 */\n  rk2imp,\t/* 6 */\n  rk4imp,\t/* 7 */\n  bsimp,\t/* 8 */\n  msadams,\t/* 9 */\n  msbdf\t\t/*10 */\n};\n  \n/* this will flag integrators which need restart */\n  extern int restart_integrator;\n  \n  \n/**************\n * Function declarations.\n **************\n */\n\n/**\n * Essentially the constructor for the cgsl_simulation object.\n * The dynamical model is defined by a function, its Jacobian, an\n * opaque parameter struct, and a set of initial values.\n * All variables are assumed to be continuous.\n *\n *  \\TODO: fix semantics for saving.  Use a filename\n *   instead of descriptor?  Open and close file automatically?\n */\ncgsl_simulation cgsl_init_simulation_tolerance(\n  cgsl_model * model, /** the model we work on */\n        enum cgsl_integrator_ids integrator, /** Integrator ID   */\n        double h,                    /** Initial time-step: must be non-zero, even  with variable step*/\n        int fixed_step,\t\t     /** Boolean */\n        int save,\t\t     /** Boolean */\n        int print,\t\t     /** Boolean  */\n  FILE *f,\t\t             /** File descriptor if 'save' is enabled  */\n  double reltol, double abstol\n  );\n\n  \ncgsl_simulation cgsl_init_simulation(\n  cgsl_model * model, /** the model we work on */\n        enum cgsl_integrator_ids integrator, /** Integrator ID   */\n        double h,                    /** Initial time-step: must be non-zero, even  with variable step*/\n        int fixed_step,\t\t     /** Boolean */\n        int save,\t\t     /** Boolean */\n        int print,\t\t     /** Boolean  */\n        FILE *f\t\t             /** File descriptor if 'save' is enabled  */\n  );\n\n/**\n *  Memory deallocation.\n */\nvoid  cgsl_free_simulation( cgsl_simulation sim );\n\n/**  Step from current time to next communication point. */\nint cgsl_step_to(void * _s,  double comm_point, double comm_step ) ;\n\n/** Accessor */\nconst gsl_odeiv2_step_type * cgsl_get_integrator( int  i ) ;\n\n/**  Commit to file. */\nvoid cgsl_save_data( struct cgsl_simulation * sim );\n\n\n/** Mutators for fixed step*/\n/** \\TODO: make this a toggle */\nvoid cgsl_simulation_set_fixed_step( cgsl_simulation * s, double h );\nvoid cgsl_simulation_set_variable_step( cgsl_simulation * s );\n\n/** Get/set FMU state */\nvoid cgsl_simulation_get( cgsl_simulation *s );\nvoid cgsl_simulation_set( cgsl_simulation *s );\n\n#ifdef __cplusplus\n}\n#endif\n\n#endif\n", "meta": {"hexsha": "d1f70786672ec2e4e7c5cde9358372d6a32c5b66", "size": 7298, "ext": "h", "lang": "C", "max_stars_repo_path": "tools/cgsl/include/gsl-interface.h", "max_stars_repo_name": "Tjoppen/fmigo", "max_stars_repo_head_hexsha": "0ad5e82b49a973cf710f85daa9dffc45261b36ae", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7.0, "max_stars_repo_stars_event_min_datetime": "2018-12-18T16:35:21.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-14T07:38:05.000Z", "max_issues_repo_path": "tools/cgsl/include/gsl-interface.h", "max_issues_repo_name": "Tjoppen/fmigo", "max_issues_repo_head_hexsha": "0ad5e82b49a973cf710f85daa9dffc45261b36ae", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "tools/cgsl/include/gsl-interface.h", "max_forks_repo_name": "Tjoppen/fmigo", "max_forks_repo_head_hexsha": "0ad5e82b49a973cf710f85daa9dffc45261b36ae", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2022-02-20T15:50:01.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-20T15:50:01.000Z", "avg_line_length": 31.321888412, "max_line_length": 109, "alphanum_fraction": 0.6245546725, "num_tokens": 1769, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4960938294709195, "lm_q2_score": 0.04603390059969197, "lm_q1q2_score": 0.022837134033984848}}
{"text": "/* ******************************************************************************\n *\n *\n * This program and the accompanying materials are made available under the\n * terms of the Apache License, Version 2.0 which is available at\n * https://www.apache.org/licenses/LICENSE-2.0.\n *\n *  See the NOTICE file distributed with this work for additional\n *  information regarding copyright ownership.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\n * License for the specific language governing permissions and limitations\n * under the License.\n *\n * SPDX-License-Identifier: Apache-2.0\n ******************************************************************************/\n\n//\n// Created by agibsonccc on 1/26/16.\n//\n\n#ifndef NATIVEOPERATIONS_CBLAS_H\n#define NATIVEOPERATIONS_CBLAS_H\n\n#ifndef __STANDALONE_BUILD__\n#include \"config.h\"\n#endif\n\n#ifdef __MKL_CBLAS_H__\n// CBLAS from MKL is already included\n#define CBLAS_H\n#endif\n\n#ifdef HAVE_OPENBLAS\n// include CBLAS from OpenBLAS\n#ifdef __GNUC__\n#include_next <cblas.h>\n#else\n#include <cblas.h>\n#endif\n#define CBLAS_H\n#endif\n\n#ifndef CBLAS_H\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n#ifndef CBLAS_ENUM_DEFINED_H\n#define CBLAS_ENUM_DEFINED_H\nenum CBLAS_ORDER { CblasRowMajor = 101, CblasColMajor = 102 };\nenum CBLAS_TRANSPOSE { CblasNoTrans = 111, CblasTrans = 112, CblasConjTrans = 113, AtlasConj = 114 };\nenum CBLAS_UPLO { CblasUpper = 121, CblasLower = 122 };\nenum CBLAS_DIAG { CblasNonUnit = 131, CblasUnit = 132 };\nenum CBLAS_SIDE { CblasLeft = 141, CblasRight = 142 };\n#endif\n\n#ifndef CBLAS_ENUM_ONLY\n#define CBLAS_H\n#define CBLAS_INDEX int\n\nint cblas_errprn(int ierr, int info, char *form, ...);\nvoid cblas_xerbla(int p, char *rout, char *form, ...);\n\n#ifdef __MKL\nvoid MKL_Set_Num_Threads(int num);\nint MKL_Domain_Set_Num_Threads(int num, int domain);\nint MKL_Set_Num_Threads_Local(int num);\n#elif __OPENBLAS\nvoid openblas_set_num_threads(int num);\n#else\n// do nothing\n#endif\n\n/*\n * ===========================================================================\n * Prototypes for level 1 BLAS functions (complex are recast as routines)\n * ===========================================================================\n */\nfloat cblas_sdsdot(int N, float alpha, float *X, int incX, float *Y, int incY);\ndouble cblas_dsdot(int N, float *X, int incX, float *Y, int incY);\nfloat cblas_sdot(int N, float *X, int incX, float *Y, int incY);\ndouble cblas_ddot(int N, double *X, int incX, double *Y, int incY);\n/*\n * Functions having prefixes Z and C only\n */\nvoid cblas_cdotu_sub(int N, void *X, int incX, void *Y, int incY, void *dotu);\nvoid cblas_cdotc_sub(int N, void *X, int incX, void *Y, int incY, void *dotc);\n\nvoid cblas_zdotu_sub(int N, void *X, int incX, void *Y, int incY, void *dotu);\nvoid cblas_zdotc_sub(int N, void *X, int incX, void *Y, int incY, void *dotc);\n\n/*\n * Functions having prefixes S D SC DZ\n */\nfloat cblas_snrm2(int N, float *X, int incX);\nfloat cblas_sasum(int N, float *X, int incX);\n\ndouble cblas_dnrm2(int N, double *X, int incX);\ndouble cblas_dasum(int N, double *X, int incX);\n\nfloat cblas_scnrm2(int N, void *X, int incX);\nfloat cblas_scasum(int N, void *X, int incX);\n\ndouble cblas_dznrm2(int N, void *X, int incX);\ndouble cblas_dzasum(int N, void *X, int incX);\n\n/*\n * Functions having standard 4 prefixes (S D C Z)\n */\nCBLAS_INDEX cblas_isamax(int N, float *X, int incX);\nCBLAS_INDEX cblas_idamax(int N, double *X, int incX);\nCBLAS_INDEX cblas_icamax(int N, void *X, int incX);\nCBLAS_INDEX cblas_izamax(int N, void *X, int incX);\n\n/*\n * ===========================================================================\n * Prototypes for level 1 BLAS routines\n * ===========================================================================\n */\n\n/*\n * Routines with standard 4 prefixes (s, d, c, z)\n */\nvoid cblas_sswap(int N, float *X, int incX, float *Y, int incY);\nvoid cblas_scopy(int N, float *X, int incX, float *Y, int incY);\nvoid cblas_saxpy(int N, float alpha, float *X, int incX, float *Y, int incY);\nvoid catlas_saxpby(int N, float alpha, float *X, int incX, float beta, float *Y, int incY);\nvoid catlas_sset(int N, float alpha, float *X, int incX);\n\nvoid cblas_dswap(int N, double *X, int incX, double *Y, int incY);\nvoid cblas_dcopy(int N, double *X, int incX, double *Y, int incY);\nvoid cblas_daxpy(int N, double alpha, double *X, int incX, double *Y, int incY);\nvoid catlas_daxpby(int N, double alpha, double *X, int incX, double beta, double *Y, int incY);\nvoid catlas_dset(int N, double alpha, double *X, int incX);\n\nvoid cblas_cswap(int N, void *X, int incX, void *Y, int incY);\nvoid cblas_ccopy(int N, void *X, int incX, void *Y, int incY);\nvoid cblas_caxpy(int N, void *alpha, void *X, int incX, void *Y, int incY);\nvoid catlas_caxpby(int N, void *alpha, void *X, int incX, void *beta, void *Y, int incY);\nvoid catlas_cset(int N, void *alpha, void *X, int incX);\n\nvoid cblas_zswap(int N, void *X, int incX, void *Y, int incY);\nvoid cblas_zcopy(int N, void *X, int incX, void *Y, int incY);\nvoid cblas_zaxpy(int N, void *alpha, void *X, int incX, void *Y, int incY);\nvoid catlas_zaxpby(int N, void *alpha, void *X, int incX, void *beta, void *Y, int incY);\nvoid catlas_zset(int N, void *alpha, void *X, int incX);\n\n/*\n * Routines with S and D prefix only\n */\nvoid cblas_srotg(float *a, float *b, float *c, float *s);\nvoid cblas_srotmg(float *d1, float *d2, float *b1, float b2, float *P);\nvoid cblas_srot(int N, float *X, int incX, float *Y, int incY, float c, float s);\nvoid cblas_srotm(int N, float *X, int incX, float *Y, int incY, float *P);\n\nvoid cblas_drotg(double *a, double *b, double *c, double *s);\nvoid cblas_drotmg(double *d1, double *d2, double *b1, double b2, double *P);\nvoid cblas_drot(int N, double *X, int incX, double *Y, int incY, double c, double s);\nvoid cblas_drotm(int N, double *X, int incX, double *Y, int incY, double *P);\n\n/*\n * Routines with S D C Z CS and ZD prefixes\n */\nvoid cblas_sscal(int N, float alpha, float *X, int incX);\nvoid cblas_dscal(int N, double alpha, double *X, int incX);\nvoid cblas_cscal(int N, void *alpha, void *X, int incX);\nvoid cblas_zscal(int N, void *alpha, void *X, int incX);\nvoid cblas_csscal(int N, float alpha, void *X, int incX);\nvoid cblas_zdscal(int N, double alpha, void *X, int incX);\n\n/*\n * Extra reference routines provided by ATLAS, but not mandated by the standard\n */\nvoid cblas_crotg(void *a, void *b, void *c, void *s);\nvoid cblas_zrotg(void *a, void *b, void *c, void *s);\nvoid cblas_csrot(int N, void *X, int incX, void *Y, int incY, float c, float s);\nvoid cblas_zdrot(int N, void *X, int incX, void *Y, int incY, double c, double s);\n\n/*\n * ===========================================================================\n * Prototypes for level 2 BLAS\n * ===========================================================================\n */\n\n/*\n * Routines with standard 4 prefixes (S, D, C, Z)\n */\nvoid cblas_sgemv(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, int M, int N, float alpha, float *A, int lda,\n                 float *X, int incX, float beta, float *Y, int incY);\nvoid cblas_sgbmv(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, int M, int N, int KL, int KU, float alpha,\n                 float *A, int lda, float *X, int incX, float beta, float *Y, int incY);\nvoid cblas_strmv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 float *A, int lda, float *X, int incX);\nvoid cblas_stbmv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 int K, float *A, int lda, float *X, int incX);\nvoid cblas_stpmv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 float *Ap, float *X, int incX);\nvoid cblas_strsv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 float *A, int lda, float *X, int incX);\nvoid cblas_stbsv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 int K, float *A, int lda, float *X, int incX);\nvoid cblas_stpsv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 float *Ap, float *X, int incX);\n\nvoid cblas_dgemv(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, int M, int N, double alpha, double *A, int lda,\n                 double *X, int incX, double beta, double *Y, int incY);\nvoid cblas_dgbmv(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, int M, int N, int KL, int KU, double alpha,\n                 double *A, int lda, double *X, int incX, double beta, double *Y, int incY);\nvoid cblas_dtrmv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 double *A, int lda, double *X, int incX);\nvoid cblas_dtbmv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 int K, double *A, int lda, double *X, int incX);\nvoid cblas_dtpmv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 double *Ap, double *X, int incX);\nvoid cblas_dtrsv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 double *A, int lda, double *X, int incX);\nvoid cblas_dtbsv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 int K, double *A, int lda, double *X, int incX);\nvoid cblas_dtpsv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 double *Ap, double *X, int incX);\n\nvoid cblas_cgemv(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, int M, int N, void *alpha, void *A, int lda,\n                 void *X, int incX, void *beta, void *Y, int incY);\nvoid cblas_cgbmv(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, int M, int N, int KL, int KU, void *alpha,\n                 void *A, int lda, void *X, int incX, void *beta, void *Y, int incY);\nvoid cblas_ctrmv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 void *A, int lda, void *X, int incX);\nvoid cblas_ctbmv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 int K, void *A, int lda, void *X, int incX);\nvoid cblas_ctpmv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 void *Ap, void *X, int incX);\nvoid cblas_ctrsv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 void *A, int lda, void *X, int incX);\nvoid cblas_ctbsv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 int K, void *A, int lda, void *X, int incX);\nvoid cblas_ctpsv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 void *Ap, void *X, int incX);\n\nvoid cblas_zgemv(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, int M, int N, void *alpha, void *A, int lda,\n                 void *X, int incX, void *beta, void *Y, int incY);\nvoid cblas_zgbmv(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, int M, int N, int KL, int KU, void *alpha,\n                 void *A, int lda, void *X, int incX, void *beta, void *Y, int incY);\nvoid cblas_ztrmv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 void *A, int lda, void *X, int incX);\nvoid cblas_ztbmv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 int K, void *A, int lda, void *X, int incX);\nvoid cblas_ztpmv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 void *Ap, void *X, int incX);\nvoid cblas_ztrsv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 void *A, int lda, void *X, int incX);\nvoid cblas_ztbsv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 int K, void *A, int lda, void *X, int incX);\nvoid cblas_ztpsv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N,\n                 void *Ap, void *X, int incX);\n\n/*\n * Routines with S and D prefixes only\n */\nvoid cblas_ssymv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, float alpha, float *A, int lda, float *X,\n                 int incX, float beta, float *Y, int incY);\nvoid cblas_ssbmv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, int K, float alpha, float *A, int lda, float *X,\n                 int incX, float beta, float *Y, int incY);\nvoid cblas_sspmv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, float alpha, float *Ap, float *X, int incX,\n                 float beta, float *Y, int incY);\nvoid cblas_sger(enum CBLAS_ORDER Order, int M, int N, float alpha, float *X, int incX, float *Y, int incY, float *A,\n                int lda);\nvoid cblas_ssyr(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, float alpha, float *X, int incX, float *A,\n                int lda);\nvoid cblas_sspr(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, float alpha, float *X, int incX, float *Ap);\nvoid cblas_ssyr2(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, float alpha, float *X, int incX, float *Y,\n                 int incY, float *A, int lda);\nvoid cblas_sspr2(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, float alpha, float *X, int incX, float *Y,\n                 int incY, float *A);\n\nvoid cblas_dsymv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, double alpha, double *A, int lda, double *X,\n                 int incX, double beta, double *Y, int incY);\nvoid cblas_dsbmv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, int K, double alpha, double *A, int lda,\n                 double *X, int incX, double beta, double *Y, int incY);\nvoid cblas_dspmv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, double alpha, double *Ap, double *X, int incX,\n                 double beta, double *Y, int incY);\nvoid cblas_dger(enum CBLAS_ORDER Order, int M, int N, double alpha, double *X, int incX, double *Y, int incY, double *A,\n                int lda);\nvoid cblas_dsyr(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, double alpha, double *X, int incX, double *A,\n                int lda);\nvoid cblas_dspr(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, double alpha, double *X, int incX, double *Ap);\nvoid cblas_dsyr2(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, double alpha, double *X, int incX, double *Y,\n                 int incY, double *A, int lda);\nvoid cblas_dspr2(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, double alpha, double *X, int incX, double *Y,\n                 int incY, double *A);\n\n/*\n * Routines with C and Z prefixes only\n */\nvoid cblas_chemv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, void *alpha, void *A, int lda, void *X, int incX,\n                 void *beta, void *Y, int incY);\nvoid cblas_chbmv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, int K, void *alpha, void *A, int lda, void *X,\n                 int incX, void *beta, void *Y, int incY);\nvoid cblas_chpmv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, void *alpha, void *Ap, void *X, int incX,\n                 void *beta, void *Y, int incY);\nvoid cblas_cgeru(enum CBLAS_ORDER Order, int M, int N, void *alpha, void *X, int incX, void *Y, int incY, void *A,\n                 int lda);\nvoid cblas_cgerc(enum CBLAS_ORDER Order, int M, int N, void *alpha, void *X, int incX, void *Y, int incY, void *A,\n                 int lda);\nvoid cblas_cher(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, float alpha, void *X, int incX, void *A, int lda);\nvoid cblas_chpr(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, float alpha, void *X, int incX, void *A);\nvoid cblas_cher2(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, void *alpha, void *X, int incX, void *Y, int incY,\n                 void *A, int lda);\nvoid cblas_chpr2(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, void *alpha, void *X, int incX, void *Y, int incY,\n                 void *Ap);\n\nvoid cblas_zhemv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, void *alpha, void *A, int lda, void *X, int incX,\n                 void *beta, void *Y, int incY);\nvoid cblas_zhbmv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, int K, void *alpha, void *A, int lda, void *X,\n                 int incX, void *beta, void *Y, int incY);\nvoid cblas_zhpmv(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, void *alpha, void *Ap, void *X, int incX,\n                 void *beta, void *Y, int incY);\nvoid cblas_zgeru(enum CBLAS_ORDER Order, int M, int N, void *alpha, void *X, int incX, void *Y, int incY, void *A,\n                 int lda);\nvoid cblas_zgerc(enum CBLAS_ORDER Order, int M, int N, void *alpha, void *X, int incX, void *Y, int incY, void *A,\n                 int lda);\nvoid cblas_zher(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, double alpha, void *X, int incX, void *A, int lda);\nvoid cblas_zhpr(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, double alpha, void *X, int incX, void *A);\nvoid cblas_zher2(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, void *alpha, void *X, int incX, void *Y, int incY,\n                 void *A, int lda);\nvoid cblas_zhpr2(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, int N, void *alpha, void *X, int incX, void *Y, int incY,\n                 void *Ap);\n\n/*\n * ===========================================================================\n * Prototypes for level 3 BLAS\n * ===========================================================================\n */\n\n/*\n * Routines with standard 4 prefixes (S, D, C, Z)\n */\nvoid cblas_sgemm(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, enum CBLAS_TRANSPOSE TransB, int M, int N, int K,\n                 float alpha, float *A, int lda, float *B, int ldb, float beta, float *C, int ldc);\nvoid cblas_ssymm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, int M, int N, float alpha,\n                 float *A, int lda, float *B, int ldb, float beta, float *C, int ldc);\nvoid cblas_ssyrk(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, int N, int K, float alpha,\n                 float *A, int lda, float beta, float *C, int ldc);\nvoid cblas_ssyr2k(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, int N, int K, float alpha,\n                  float *A, int lda, float *B, int ldb, float beta, float *C, int ldc);\nvoid cblas_strmm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA,\n                 enum CBLAS_DIAG Diag, int M, int N, float alpha, float *A, int lda, float *B, int ldb);\nvoid cblas_strsm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA,\n                 enum CBLAS_DIAG Diag, int M, int N, float alpha, float *A, int lda, float *B, int ldb);\n\nvoid cblas_dgemm(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, enum CBLAS_TRANSPOSE TransB, int M, int N, int K,\n                 double alpha, double *A, int lda, double *B, int ldb, double beta, double *C, int ldc);\nvoid cblas_dsymm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, int M, int N, double alpha,\n                 double *A, int lda, double *B, int ldb, double beta, double *C, int ldc);\nvoid cblas_dsyrk(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, int N, int K, double alpha,\n                 double *A, int lda, double beta, double *C, int ldc);\nvoid cblas_dsyr2k(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, int N, int K, double alpha,\n                  double *A, int lda, double *B, int ldb, double beta, double *C, int ldc);\nvoid cblas_dtrmm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA,\n                 enum CBLAS_DIAG Diag, int M, int N, double alpha, double *A, int lda, double *B, int ldb);\nvoid cblas_dtrsm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA,\n                 enum CBLAS_DIAG Diag, int M, int N, double alpha, double *A, int lda, double *B, int ldb);\n\nvoid cblas_cgemm(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, enum CBLAS_TRANSPOSE TransB, int M, int N, int K,\n                 void *alpha, void *A, int lda, void *B, int ldb, void *beta, void *C, int ldc);\nvoid cblas_csymm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, int M, int N, void *alpha, void *A,\n                 int lda, void *B, int ldb, void *beta, void *C, int ldc);\nvoid cblas_csyrk(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, int N, int K, void *alpha,\n                 void *A, int lda, void *beta, void *C, int ldc);\nvoid cblas_csyr2k(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, int N, int K, void *alpha,\n                  void *A, int lda, void *B, int ldb, void *beta, void *C, int ldc);\nvoid cblas_ctrmm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA,\n                 enum CBLAS_DIAG Diag, int M, int N, void *alpha, void *A, int lda, void *B, int ldb);\nvoid cblas_ctrsm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA,\n                 enum CBLAS_DIAG Diag, int M, int N, void *alpha, void *A, int lda, void *B, int ldb);\n\nvoid cblas_zgemm(enum CBLAS_ORDER Order, enum CBLAS_TRANSPOSE TransA, enum CBLAS_TRANSPOSE TransB, int M, int N, int K,\n                 void *alpha, void *A, int lda, void *B, int ldb, void *beta, void *C, int ldc);\nvoid cblas_zsymm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, int M, int N, void *alpha, void *A,\n                 int lda, void *B, int ldb, void *beta, void *C, int ldc);\nvoid cblas_zsyrk(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, int N, int K, void *alpha,\n                 void *A, int lda, void *beta, void *C, int ldc);\nvoid cblas_zsyr2k(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, int N, int K, void *alpha,\n                  void *A, int lda, void *B, int ldb, void *beta, void *C, int ldc);\nvoid cblas_ztrmm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA,\n                 enum CBLAS_DIAG Diag, int M, int N, void *alpha, void *A, int lda, void *B, int ldb);\nvoid cblas_ztrsm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA,\n                 enum CBLAS_DIAG Diag, int M, int N, void *alpha, void *A, int lda, void *B, int ldb);\n\n/*\n * Routines with prefixes C and Z only\n */\nvoid cblas_chemm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, int M, int N, void *alpha, void *A,\n                 int lda, void *B, int ldb, void *beta, void *C, int ldc);\nvoid cblas_cherk(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, int N, int K, float alpha,\n                 void *A, int lda, float beta, void *C, int ldc);\nvoid cblas_cher2k(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, int N, int K, void *alpha,\n                  void *A, int lda, void *B, int ldb, float beta, void *C, int ldc);\nvoid cblas_zhemm(enum CBLAS_ORDER Order, enum CBLAS_SIDE Side, enum CBLAS_UPLO Uplo, int M, int N, void *alpha, void *A,\n                 int lda, void *B, int ldb, void *beta, void *C, int ldc);\nvoid cblas_zherk(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, int N, int K, double alpha,\n                 void *A, int lda, double beta, void *C, int ldc);\nvoid cblas_zher2k(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, int N, int K, void *alpha,\n                  void *A, int lda, void *B, int ldb, double beta, void *C, int ldc);\n\nint cblas_errprn(int ierr, int info, char *form, ...);\n#ifdef __cplusplus\n}\n#endif\n#endif /* end #ifdef CBLAS_ENUM_ONLY */\n#endif\n#endif  // NATIVEOPERATIONS_CBLAS_H\n", "meta": {"hexsha": "a98027c5fc5a25ed00e3f750fa685ef5bf79c778", "size": 24691, "ext": "h", "lang": "C", "max_stars_repo_path": "libnd4j/include/cblas.h", "max_stars_repo_name": "steljord2/deeplearning4j", "max_stars_repo_head_hexsha": "4653c97a713cc59e41d4313ddbafc5ff527f8714", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2206.0, "max_stars_repo_stars_event_min_datetime": "2019-06-12T18:57:14.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T08:14:27.000Z", "max_issues_repo_path": "libnd4j/include/cblas.h", "max_issues_repo_name": "steljord2/deeplearning4j", "max_issues_repo_head_hexsha": "4653c97a713cc59e41d4313ddbafc5ff527f8714", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1685.0, "max_issues_repo_issues_event_min_datetime": "2019-06-12T17:41:33.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-29T21:45:15.000Z", "max_forks_repo_path": "libnd4j/include/cblas.h", "max_forks_repo_name": "steljord2/deeplearning4j", "max_forks_repo_head_hexsha": "4653c97a713cc59e41d4313ddbafc5ff527f8714", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 572.0, "max_forks_repo_forks_event_min_datetime": "2019-06-12T22:13:57.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T16:46:46.000Z", "avg_line_length": 59.6400966184, "max_line_length": 120, "alphanum_fraction": 0.6667206674, "num_tokens": 7796, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47657965106367595, "lm_q2_score": 0.04468086868252906, "lm_q1q2_score": 0.021293992805941627}}
{"text": "#include <stdio.h>\n#include <string.h>\n#include <stdlib.h>\n\n#include <gsl/gsl_matrix.h>\n#include <gsl/gsl_vector.h>\n#include <gsl/gsl_blas.h>\n#include <gsl/gsl_linalg.h>\n\n#include \"norm.h\"\n#include \"constants.h\"\n\nint readFileVector( gsl_vector *vector, char *filePath, char *fileName )                //read file vals into vector\n{\n\tchar tmpFilepath[120] = \"\\0\";\n\tchar tmpReading[20];\n\tchar *tmp2;\n\tdouble reading;                                 //WARNING this is similar to global var $readings, consider renaming\n\t\n\tstrcat( tmpFilepath, filePath );                //TODO replace this and the first instance of strcat into strcpy, that should work\n\tstrcat( tmpFilepath, fileName );        //combines the filepath and name into one searchable /path/file\n\tFILE *file = fopen( tmpFilepath, \"rt\");\n\tprintf(\"%s\\n\", tmpFilepath);                    //TODO DELETE THIS\n\tif ( file == NULL ) {                   //check if file exists\n\t\tfprintf( stderr, \"Error, unable to locate the Mu data file\\n\");\n\t\texit(100);\n\t}\n\t\n\tfor ( int i = 0; i < skip; i++)         //move past header of read files\n\t{\n\t\tfgets( tmpReading, 19, file );\n\t}\n\t\n\tfor ( int i = 0; i < readings; i++ )\n\t{\n\t\tfgets( tmpReading, 19, file );\n\t\t\n\t\ttmp2 = strrchr( tmpReading, '\\t' );\n\t\ttmp2 = tmp2 + 1;\n\t\treading = atof(tmp2);\n\t\tgsl_vector_set( vector, i, reading);\n\t}\n\tfclose(file);\n\treturn 0;\n}\n\nint readFileMatrix( gsl_matrix *matrix, char *filePath, int argc, char *argv[] )\n{\n\tchar *tmp2;\n\tdouble reading;\n\tfor ( int j = 2; j < argc; j++ )\n\t{\n\t\tgsl_vector_view column;\n\t\tchar tmpFilepath[120] = \"\\0\";                           //TODO replace this and the first instance of strcat into strcpy, that should work\n\t\tchar tmpReading[20];\n\t\tstrcat( tmpFilepath, filePath );\n\t\tstrcat( tmpFilepath, argv[j] );         //combines the filepath and name into one searchable /path/file\n\t\tFILE *file = fopen( tmpFilepath, \"rt\");\n\t\tprintf(\"%s\\n\", tmpFilepath);                            //TODO DELETE THIS\n\t\tif ( file == NULL ) {                   //check if file exists\n\t\t\tfprintf( stderr, \"Error, unable to locate a reference data file\\n\");\n\t\t\texit(100);\n\t\t}\n\t\tfor ( int i = 0; i < skip; i++)         //move past header of read files\n\t\t{\n\t\t\tfgets( tmpReading, 20, file);\n\t\t}\n\t\tfor ( int i = 0; i < readings; i++ ) //fill the ith element of the jth column\n\t\t{\n\t\t\tfgets( tmpReading, 19, file );\n\t\t\t\n\t\t\ttmp2 = strrchr( tmpReading, '\\t' );\n\t\t\ttmp2 = tmp2 + 1;\n\t\t\treading = atof(tmp2);\n\t\t\tgsl_matrix_set( matrix, i, j-2, reading );\n\t\t}\n\t\tfclose(file);\n\t\tcolumn = gsl_matrix_column( matrix, j-2 );                              //NORMALISE EACH REFERENCE VECOTR.\n\t\tnormalizeVector( &column.vector );\n\t}\n\t\n\treturn 0;\n}\n\n", "meta": {"hexsha": "146256f83aa9091fa81125af48d17b08a629a1a6", "size": 2664, "ext": "c", "lang": "C", "max_stars_repo_path": "src/utils.c", "max_stars_repo_name": "jakeinater/spectralILU", "max_stars_repo_head_hexsha": "825dbd5c5495b0ce0a0d14a5bed865b9bfdda98d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/utils.c", "max_issues_repo_name": "jakeinater/spectralILU", "max_issues_repo_head_hexsha": "825dbd5c5495b0ce0a0d14a5bed865b9bfdda98d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/utils.c", "max_forks_repo_name": "jakeinater/spectralILU", "max_forks_repo_head_hexsha": "825dbd5c5495b0ce0a0d14a5bed865b9bfdda98d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.3411764706, "max_line_length": 140, "alphanum_fraction": 0.6028528529, "num_tokens": 748, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.43398146480389854, "lm_q2_score": 0.0488577737749038, "lm_q1q2_score": 0.02120336822989025}}
{"text": "/*\n#\n# * The source code in this file is developed independently by NEC Corporation.\n#\n# # NLCPy License #\n# \n#     Copyright (c) 2020-2021 NEC Corporation\n#     All rights reserved.\n#     \n#     Redistribution and use in source and binary forms, with or without\n#     modification, are permitted provided that the following conditions are met:\n#     * Redistributions of source code must retain the above copyright notice,\n#       this list of conditions and the following disclaimer.\n#     * Redistributions in binary form must reproduce the above copyright notice,\n#       this list of conditions and the following disclaimer in the documentation\n#       and/or other materials provided with the distribution.\n#     * Neither NEC Corporation nor the names of its contributors may be\n#       used to endorse or promote products derived from this software\n#       without specific prior written permission.\n#     \n#     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND\n#     ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n#     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n#     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n#     FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n#     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;\n#     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND\n#     ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n#     (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\n#     SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n#\n*/\n\n\n#include <cblas.h>\n#include \"nlcpy.h\"\n\n\nuint64_t wrapper_cblas_sdot(ve_arguments *args, int32_t *psw)\n{\n#ifdef _OPENMP\n#pragma omp single\n#endif /* _OPENMP */\n{\n    ve_array *x = &(args->binary.x);\n    ve_array *y = &(args->binary.y);\n    ve_array *z = &(args->binary.z);\n\n    float *px = (float *)x->ve_adr;\n    if (px == NULL) {\n        px = (float *)nlcpy__get_scalar(x);\n        if (px == NULL) {\n            return NLCPY_ERROR_MEMORY;\n        }\n    }\n    float *py = (float *)y->ve_adr;\n    if (py == NULL) {\n        py = (float *)nlcpy__get_scalar(y);\n        if (py == NULL) {\n            return NLCPY_ERROR_MEMORY;\n        }\n    }\n    float *pz = (float *)z->ve_adr;\n    if (pz == NULL) {\n       return (uint64_t)NLCPY_ERROR_MEMORY; \n    }\n    assert(x->ndim <= 1);\n    assert(y->ndim <= 1);\n    assert(z->ndim <= 1);\n    assert(x->size == y->size);\n\n    *pz = cblas_sdot(x->size, px, x->strides[0] / x->itemsize, \n                            py, y->strides[0] / y->itemsize);\n} /* omp single */\n    retrieve_fpe_flags(psw);\n    return (uint64_t)NLCPY_ERROR_OK;\n}\n\nuint64_t wrapper_cblas_ddot(ve_arguments *args, int32_t *psw)\n{\n#ifdef _OPENMP\n#pragma omp single\n#endif /* _OPENMP */\n{\n    ve_array *x = &(args->binary.x);\n    ve_array *y = &(args->binary.y);\n    ve_array *z = &(args->binary.z);\n\n    double *px = (double *)x->ve_adr;\n    if (px == NULL) {\n        px = (double *)nlcpy__get_scalar(x);\n        if (px == NULL) {\n            return NLCPY_ERROR_MEMORY;\n        }\n    }\n    double *py = (double *)y->ve_adr;\n    if (py == NULL) {\n        py = (double *)nlcpy__get_scalar(y);\n        if (py == NULL) {\n            return NLCPY_ERROR_MEMORY;\n        }\n    }\n    double *pz = (double *)z->ve_adr;\n    if (pz == NULL) {\n       return (uint64_t)NLCPY_ERROR_MEMORY; \n    }\n    assert(x->ndim <= 1);\n    assert(y->ndim <= 1);\n    assert(z->ndim <= 1);\n    assert(x->size == y->size);\n\n    *pz = cblas_ddot(x->size, px, x->strides[0] / x->itemsize, \n                            py, y->strides[0] / y->itemsize);\n} /* omp single */\n    retrieve_fpe_flags(psw);\n    return (uint64_t)NLCPY_ERROR_OK;\n}\n\nuint64_t wrapper_cblas_cdotu_sub(ve_arguments *args, int32_t *psw)\n{\n#ifdef _OPENMP\n#pragma omp single\n#endif /* _OPENMP */\n{\n    ve_array *x = &(args->binary.x);\n    ve_array *y = &(args->binary.y);\n    ve_array *z = &(args->binary.z);\n\n    float _Complex *px = (float _Complex *)x->ve_adr;\n    if (px == NULL) {\n        px = (float _Complex *)nlcpy__get_scalar(x);\n        if (px == NULL) {\n            return NLCPY_ERROR_MEMORY;\n        }\n    }\n    float _Complex *py = (float _Complex *)y->ve_adr;\n    if (py == NULL) {\n        py = (float _Complex *)nlcpy__get_scalar(y);\n        if (py == NULL) {\n            return NLCPY_ERROR_MEMORY;\n        }\n    }\n    float _Complex *pz = (float _Complex *)z->ve_adr;\n    if (pz == NULL) {\n       return (uint64_t)NLCPY_ERROR_MEMORY; \n    }\n    assert(x->ndim <= 1);\n    assert(y->ndim <= 1);\n    assert(z->ndim <= 1);\n    assert(x->size == y->size);\n\n\n    cblas_cdotu_sub(x->size, px, x->strides[0] / x->itemsize, \n                        py, y->strides[0] / y->itemsize, pz);\n} /* omp single */\n    retrieve_fpe_flags(psw);\n    return (uint64_t)NLCPY_ERROR_OK;\n}\n\nuint64_t wrapper_cblas_zdotu_sub(ve_arguments *args, int32_t *psw)\n{\n#ifdef _OPENMP\n#pragma omp single\n#endif /* _OPENMP */\n{\n    ve_array *x = &(args->binary.x);\n    ve_array *y = &(args->binary.y);\n    ve_array *z = &(args->binary.z);\n\n    double _Complex *px = (double _Complex *)x->ve_adr;\n    if (px == NULL) {\n        px = (double _Complex *)nlcpy__get_scalar(x);\n        if (px == NULL) {\n            return NLCPY_ERROR_MEMORY;\n        }\n    }\n    double _Complex *py = (double _Complex *)y->ve_adr;\n    if (py == NULL) {\n        py = (double _Complex *)nlcpy__get_scalar(y);\n        if (py == NULL) {\n            return NLCPY_ERROR_MEMORY;\n        }\n    }\n    double _Complex *pz = (double _Complex *)z->ve_adr;\n    if (pz == NULL) {\n       return (uint64_t)NLCPY_ERROR_MEMORY; \n    }\n    assert(x->ndim <= 1);\n    assert(y->ndim <= 1);\n    assert(z->ndim <= 1);\n    assert(x->size == y->size);\n\n\n    cblas_zdotu_sub(x->size, px, x->strides[0] / x->itemsize, \n                        py, y->strides[0] / y->itemsize, pz);\n} /* omp single */\n    retrieve_fpe_flags(psw);\n    return (uint64_t)NLCPY_ERROR_OK;\n}\n\n\n\n\nuint64_t wrapper_cblas_sgemm(ve_arguments *args, int32_t *psw)\n{\n    const int32_t order = args->gemm.order;\n    const int32_t transA = args->gemm.transA;\n    const int32_t transB = args->gemm.transB;\n    const int32_t m = args->gemm.m;\n    const int32_t n = args->gemm.n;\n    const int32_t k = args->gemm.k;\n    const float alpha = *((float *)nlcpy__get_scalar(&(args->gemm.alpha)));\n    float* const a = (float *)args->gemm.a.ve_adr;\n    const int32_t lda = args->gemm.lda;\n    float* const b = (float *)args->gemm.b.ve_adr;\n    const int32_t ldb = args->gemm.ldb;\n    const float beta = *((float *)nlcpy__get_scalar(&(args->gemm.beta)));\n    float* const c = (float *)args->gemm.c.ve_adr;\n    const int32_t ldc = args->gemm.ldc;\n\n    if (a == NULL || b == NULL || c == NULL) {\n        return NLCPY_ERROR_MEMORY;\n    }\n\n\n#ifdef _OPENMP\n    const int32_t nt = omp_get_num_threads();\n    const int32_t it = omp_get_thread_num();\n#else\n    const int32_t nt = 1;\n    const int32_t it = 0;\n#endif /* _OPENMP */\n\n    const int32_t m_s = m * it / nt;\n    const int32_t m_e = m * (it + 1) / nt;\n    const int32_t m_d = m_e - m_s;\n    const int32_t n_s = n * it / nt;\n    const int32_t n_e = n * (it + 1) / nt;\n    const int32_t n_d = n_e - n_s;\n    \n    int32_t mode = 1;\n    if ( n > nt ) { \n        mode = 2;\n    }\n    int32_t iar, iac, ibr, ibc, icr, icc;\n    if (transA == CblasNoTrans ) {\n        iar = 1;\n        iac = lda;\n    } else {\n        iar = lda;\n        iac = 1;\n    }\n    if (transB == CblasNoTrans ) {\n        ibr = 1;\n        ibc = ldb;\n    } else {\n        ibr = ldb;\n        ibc = 1;\n    }\n    if (order == CblasColMajor ) {\n        icr = 1;\n        icc = ldc;\n    } else {\n        icr = ldc;\n        icc = 1;\n    }\n\n    if (order == CblasColMajor) {\n        if ( mode == 1 ) { \n            // split 'm'\n            cblas_sgemm(order, transA, transB, m_d, n, k, alpha, a + m_s * iar, lda, b, ldb, beta, c + m_s * icr, ldc);  \n        } else {\n            // split 'n'\n            cblas_sgemm(order, transA, transB, m, n_d, k, alpha, a, lda, b + n_s * ibc, ldb, beta, c + n_s * icc, ldc);  \n        }\n    } else {\n        if ( mode == 1 ) { \n            // split 'm'\n            cblas_sgemm(order, transA, transB, m_d, n, k, alpha, a + m_s * iac, lda, b, ldb, beta, c + m_s * icr, ldc);  \n        } else {\n            // split 'n'\n            cblas_sgemm(order, transA, transB, m, n_d, k, alpha, a, lda, b + n_s * ibr, ldb, beta, c + n_s * icc, ldc);  \n        }\n    }\n\n    retrieve_fpe_flags(psw);\n    return (uint64_t)NLCPY_ERROR_OK;\n}\n\nuint64_t wrapper_cblas_dgemm(ve_arguments *args, int32_t *psw)\n{\n    const int32_t order = args->gemm.order;\n    const int32_t transA = args->gemm.transA;\n    const int32_t transB = args->gemm.transB;\n    const int32_t m = args->gemm.m;\n    const int32_t n = args->gemm.n;\n    const int32_t k = args->gemm.k;\n    const double alpha = *((double *)nlcpy__get_scalar(&(args->gemm.alpha)));\n    double* const a = (double *)args->gemm.a.ve_adr;\n    const int32_t lda = args->gemm.lda;\n    double* const b = (double *)args->gemm.b.ve_adr;\n    const int32_t ldb = args->gemm.ldb;\n    const double beta = *((double *)nlcpy__get_scalar(&(args->gemm.beta)));\n    double* const c = (double *)args->gemm.c.ve_adr;\n    const int32_t ldc = args->gemm.ldc;\n\n    if (a == NULL || b == NULL || c == NULL) {\n        return NLCPY_ERROR_MEMORY;\n    }\n\n\n#ifdef _OPENMP\n    const int32_t nt = omp_get_num_threads();\n    const int32_t it = omp_get_thread_num();\n#else\n    const int32_t nt = 1;\n    const int32_t it = 0;\n#endif /* _OPENMP */\n\n    const int32_t m_s = m * it / nt;\n    const int32_t m_e = m * (it + 1) / nt;\n    const int32_t m_d = m_e - m_s;\n    const int32_t n_s = n * it / nt;\n    const int32_t n_e = n * (it + 1) / nt;\n    const int32_t n_d = n_e - n_s;\n    \n    int32_t mode = 1;\n    if ( n > nt ) { \n        mode = 2;\n    }\n    int32_t iar, iac, ibr, ibc, icr, icc;\n    if (transA == CblasNoTrans ) {\n        iar = 1;\n        iac = lda;\n    } else {\n        iar = lda;\n        iac = 1;\n    }\n    if (transB == CblasNoTrans ) {\n        ibr = 1;\n        ibc = ldb;\n    } else {\n        ibr = ldb;\n        ibc = 1;\n    }\n    if (order == CblasColMajor ) {\n        icr = 1;\n        icc = ldc;\n    } else {\n        icr = ldc;\n        icc = 1;\n    }\n\n    if (order == CblasColMajor) {\n        if ( mode == 1 ) { \n            // split 'm'\n            cblas_dgemm(order, transA, transB, m_d, n, k, alpha, a + m_s * iar, lda, b, ldb, beta, c + m_s * icr, ldc);  \n        } else {\n            // split 'n'\n            cblas_dgemm(order, transA, transB, m, n_d, k, alpha, a, lda, b + n_s * ibc, ldb, beta, c + n_s * icc, ldc);  \n        }\n    } else {\n        if ( mode == 1 ) { \n            // split 'm'\n            cblas_dgemm(order, transA, transB, m_d, n, k, alpha, a + m_s * iac, lda, b, ldb, beta, c + m_s * icr, ldc);  \n        } else {\n            // split 'n'\n            cblas_dgemm(order, transA, transB, m, n_d, k, alpha, a, lda, b + n_s * ibr, ldb, beta, c + n_s * icc, ldc);  \n        }\n    }\n\n    retrieve_fpe_flags(psw);\n    return (uint64_t)NLCPY_ERROR_OK;\n}\n\nuint64_t wrapper_cblas_cgemm(ve_arguments *args, int32_t *psw)\n{\n    const int32_t order = args->gemm.order;\n    const int32_t transA = args->gemm.transA;\n    const int32_t transB = args->gemm.transB;\n    const int32_t m = args->gemm.m;\n    const int32_t n = args->gemm.n;\n    const int32_t k = args->gemm.k;\n    const void *alpha = (void *)nlcpy__get_scalar(&(args->gemm.alpha));\n    if (alpha == NULL) return (uint64_t)NLCPY_ERROR_MEMORY;\n    float  _Complex* const a = (float  _Complex *)args->gemm.a.ve_adr;\n    const int32_t lda = args->gemm.lda;\n    float  _Complex* const b = (float  _Complex *)args->gemm.b.ve_adr;\n    const int32_t ldb = args->gemm.ldb;\n    const void *beta = (void *)nlcpy__get_scalar(&(args->gemm.beta));\n    if (beta == NULL) return (uint64_t)NLCPY_ERROR_MEMORY;\n    float  _Complex* const c = (float  _Complex *)args->gemm.c.ve_adr;\n    const int32_t ldc = args->gemm.ldc;\n\n    if (a == NULL || b == NULL || c == NULL) {\n        return NLCPY_ERROR_MEMORY;\n    }\n\n\n#ifdef _OPENMP\n    const int32_t nt = omp_get_num_threads();\n    const int32_t it = omp_get_thread_num();\n#else\n    const int32_t nt = 1;\n    const int32_t it = 0;\n#endif /* _OPENMP */\n\n    const int32_t m_s = m * it / nt;\n    const int32_t m_e = m * (it + 1) / nt;\n    const int32_t m_d = m_e - m_s;\n    const int32_t n_s = n * it / nt;\n    const int32_t n_e = n * (it + 1) / nt;\n    const int32_t n_d = n_e - n_s;\n    \n    int32_t mode = 1;\n    if ( n > nt ) { \n        mode = 2;\n    }\n    int32_t iar, iac, ibr, ibc, icr, icc;\n    if (transA == CblasNoTrans ) {\n        iar = 1;\n        iac = lda;\n    } else {\n        iar = lda;\n        iac = 1;\n    }\n    if (transB == CblasNoTrans ) {\n        ibr = 1;\n        ibc = ldb;\n    } else {\n        ibr = ldb;\n        ibc = 1;\n    }\n    if (order == CblasColMajor ) {\n        icr = 1;\n        icc = ldc;\n    } else {\n        icr = ldc;\n        icc = 1;\n    }\n\n    if (order == CblasColMajor) {\n        if ( mode == 1 ) { \n            // split 'm'\n            cblas_cgemm(order, transA, transB, m_d, n, k, alpha, a + m_s * iar, lda, b, ldb, beta, c + m_s * icr, ldc);  \n        } else {\n            // split 'n'\n            cblas_cgemm(order, transA, transB, m, n_d, k, alpha, a, lda, b + n_s * ibc, ldb, beta, c + n_s * icc, ldc);  \n        }\n    } else {\n        if ( mode == 1 ) { \n            // split 'm'\n            cblas_cgemm(order, transA, transB, m_d, n, k, alpha, a + m_s * iac, lda, b, ldb, beta, c + m_s * icr, ldc);  \n        } else {\n            // split 'n'\n            cblas_cgemm(order, transA, transB, m, n_d, k, alpha, a, lda, b + n_s * ibr, ldb, beta, c + n_s * icc, ldc);  \n        }\n    }\n\n    retrieve_fpe_flags(psw);\n    return (uint64_t)NLCPY_ERROR_OK;\n}\n\nuint64_t wrapper_cblas_zgemm(ve_arguments *args, int32_t *psw)\n{\n    const int32_t order = args->gemm.order;\n    const int32_t transA = args->gemm.transA;\n    const int32_t transB = args->gemm.transB;\n    const int32_t m = args->gemm.m;\n    const int32_t n = args->gemm.n;\n    const int32_t k = args->gemm.k;\n    const void *alpha = (void *)nlcpy__get_scalar(&(args->gemm.alpha));\n    if (alpha == NULL) return (uint64_t)NLCPY_ERROR_MEMORY;\n    double _Complex* const a = (double _Complex *)args->gemm.a.ve_adr;\n    const int32_t lda = args->gemm.lda;\n    double _Complex* const b = (double _Complex *)args->gemm.b.ve_adr;\n    const int32_t ldb = args->gemm.ldb;\n    const void *beta = (void *)nlcpy__get_scalar(&(args->gemm.beta));\n    if (beta == NULL) return (uint64_t)NLCPY_ERROR_MEMORY;\n    double _Complex* const c = (double _Complex *)args->gemm.c.ve_adr;\n    const int32_t ldc = args->gemm.ldc;\n\n    if (a == NULL || b == NULL || c == NULL) {\n        return NLCPY_ERROR_MEMORY;\n    }\n\n\n#ifdef _OPENMP\n    const int32_t nt = omp_get_num_threads();\n    const int32_t it = omp_get_thread_num();\n#else\n    const int32_t nt = 1;\n    const int32_t it = 0;\n#endif /* _OPENMP */\n\n    const int32_t m_s = m * it / nt;\n    const int32_t m_e = m * (it + 1) / nt;\n    const int32_t m_d = m_e - m_s;\n    const int32_t n_s = n * it / nt;\n    const int32_t n_e = n * (it + 1) / nt;\n    const int32_t n_d = n_e - n_s;\n    \n    int32_t mode = 1;\n    if ( n > nt ) { \n        mode = 2;\n    }\n    int32_t iar, iac, ibr, ibc, icr, icc;\n    if (transA == CblasNoTrans ) {\n        iar = 1;\n        iac = lda;\n    } else {\n        iar = lda;\n        iac = 1;\n    }\n    if (transB == CblasNoTrans ) {\n        ibr = 1;\n        ibc = ldb;\n    } else {\n        ibr = ldb;\n        ibc = 1;\n    }\n    if (order == CblasColMajor ) {\n        icr = 1;\n        icc = ldc;\n    } else {\n        icr = ldc;\n        icc = 1;\n    }\n\n    if (order == CblasColMajor) {\n        if ( mode == 1 ) { \n            // split 'm'\n            cblas_zgemm(order, transA, transB, m_d, n, k, alpha, a + m_s * iar, lda, b, ldb, beta, c + m_s * icr, ldc);  \n        } else {\n            // split 'n'\n            cblas_zgemm(order, transA, transB, m, n_d, k, alpha, a, lda, b + n_s * ibc, ldb, beta, c + n_s * icc, ldc);  \n        }\n    } else {\n        if ( mode == 1 ) { \n            // split 'm'\n            cblas_zgemm(order, transA, transB, m_d, n, k, alpha, a + m_s * iac, lda, b, ldb, beta, c + m_s * icr, ldc);  \n        } else {\n            // split 'n'\n            cblas_zgemm(order, transA, transB, m, n_d, k, alpha, a, lda, b + n_s * ibr, ldb, beta, c + n_s * icc, ldc);  \n        }\n    }\n\n    retrieve_fpe_flags(psw);\n    return (uint64_t)NLCPY_ERROR_OK;\n}\n\n\n", "meta": {"hexsha": "8b952d2151ef859cfef0e26b4663f0a39c98ef23", "size": 16648, "ext": "c", "lang": "C", "max_stars_repo_path": "nlcpy/ve_kernel/cblas_wrapper.c", "max_stars_repo_name": "SX-Aurora/nlcpy", "max_stars_repo_head_hexsha": "0a53eec8778073bc48b12687b7ce37ab2bf2b7e0", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 11.0, "max_stars_repo_stars_event_min_datetime": "2020-07-31T02:21:55.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-10T03:12:11.000Z", "max_issues_repo_path": "nlcpy/ve_kernel/cblas_wrapper.c", "max_issues_repo_name": "SX-Aurora/nlcpy", "max_issues_repo_head_hexsha": "0a53eec8778073bc48b12687b7ce37ab2bf2b7e0", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "nlcpy/ve_kernel/cblas_wrapper.c", "max_forks_repo_name": "SX-Aurora/nlcpy", "max_forks_repo_head_hexsha": "0a53eec8778073bc48b12687b7ce37ab2bf2b7e0", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.1048824593, "max_line_length": 121, "alphanum_fraction": 0.555622297, "num_tokens": 5413, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4921881357207955, "lm_q2_score": 0.04272219419471941, "lm_q1q2_score": 0.02102735711460074}}
{"text": "// Copyright (c) 2017, Lawrence Livermore National Security, LLC. Produced at\n// the Lawrence Livermore National Laboratory. LLNL-CODE-734707. All Rights\n// reserved. See files LICENSE and NOTICE for details.\n//\n// This file is part of CEED, a collection of benchmarks, miniapps, software\n// libraries and APIs for efficient high-order finite element and spectral\n// element discretizations for exascale applications. For more information and\n// source code availability see http://github.com/ceed.\n//\n// The CEED research is supported by the Exascale Computing Project 17-SC-20-SC,\n// a collaborative effort of two U.S. Department of Energy organizations (Office\n// of Science and the National Nuclear Security Administration) responsible for\n// the planning and preparation of a capable exascale ecosystem, including\n// software, applications, hardware, advanced system engineering and early\n// testbed platforms, in support of the nation's exascale computing imperative.\n\n#ifndef setuparea_h\n#define setuparea_h\n\n#include <ceed.h>\n#include <petsc.h>\n#include <petscdmplex.h>\n#include <petscfe.h>\n#include <stdbool.h>\n#include <string.h>\n#include \"qfunctions/area/areacube.h\"\n#include \"qfunctions/area/areasphere.h\"\n\n#if PETSC_VERSION_LT(3,14,0)\n#  define DMPlexGetClosureIndices(a,b,c,d,e,f,g,h,i) DMPlexGetClosureIndices(a,b,c,d,f,g,i)\n#  define DMPlexRestoreClosureIndices(a,b,c,d,e,f,g,h,i) DMPlexRestoreClosureIndices(a,b,c,d,f,g,i)\n#endif\n\n#if PETSC_VERSION_LT(3,14,0)\n#  define DMPlexCreateSphereMesh(a,b,c,d,e) DMPlexCreateSphereMesh(a,b,c,e)\n#endif\n\n// -----------------------------------------------------------------------------\n// PETSc Operator Structs\n// -----------------------------------------------------------------------------\n\n// Data for PETSc\ntypedef struct User_ *User;\nstruct User_ {\n  MPI_Comm comm;\n  DM dm;\n  Vec Xloc, Yloc, diag;\n  CeedVector xceed, yceed;\n  CeedOperator op;\n  Ceed ceed;\n};\n\n// -----------------------------------------------------------------------------\n// libCEED Data Struct\n// -----------------------------------------------------------------------------\n\n// libCEED data struct for level\ntypedef struct CeedData_ *CeedData;\nstruct CeedData_ {\n  Ceed ceed;\n  CeedBasis basisx, basisu;\n  CeedElemRestriction Erestrictx, Erestrictu, Erestrictqdi;\n  CeedQFunction qf_apply;\n  CeedOperator op_apply, op_restrict, op_interp;\n  CeedVector qdata, uceed, vceed;\n};\n\n// -----------------------------------------------------------------------------\n// Problem Option Data\n// -----------------------------------------------------------------------------\n\n// Problem options\ntypedef enum {\n  CUBE = 0, SPHERE = 1\n} problemType;\nstatic const char *const problemTypes[] = {\"cube\", \"sphere\",\n                                           \"problemType\", \"AREA\", NULL\n                                          };\n\n// Problem specific data\ntypedef struct {\n  CeedInt ncompu, ncompx, qdatasize, qextra, topodim;\n  CeedQFunctionUser setupgeo, apply;\n  const char *setupgeofname, *applyfname;\n  CeedEvalMode inmode, outmode;\n  CeedQuadMode qmode;\n} problemData;\n\nstatic problemData problemOptions[6] = {\n  [CUBE] = {\n    .ncompx = 3,\n    .ncompu = 1,\n    .topodim = 2,\n    .qdatasize = 1,\n    .qextra = 1,\n    .setupgeo = SetupMassGeoCube,\n    .apply = Mass,\n    .setupgeofname = SetupMassGeoCube_loc,\n    .applyfname = Mass_loc,\n    .inmode = CEED_EVAL_INTERP,\n    .outmode = CEED_EVAL_INTERP,\n    .qmode = CEED_GAUSS\n  },\n  [SPHERE] = {\n    .ncompx = 3,\n    .ncompu = 1,\n    .topodim = 2,\n    .qdatasize = 1,\n    .qextra = 1,\n    .setupgeo = SetupMassGeoSphere,\n    .apply = Mass,\n    .setupgeofname = SetupMassGeoSphere_loc,\n    .applyfname = Mass_loc,\n    .inmode = CEED_EVAL_INTERP,\n    .outmode = CEED_EVAL_INTERP,\n    .qmode = CEED_GAUSS\n  }\n};\n\n// -----------------------------------------------------------------------------\n// PETSc sphere auxiliary functions\n// -----------------------------------------------------------------------------\n\n// Utility function taken from petsc/src/dm/impls/plex/examples/tutorials/ex7.c\nstatic PetscErrorCode ProjectToUnitSphere(DM dm) {\n  Vec            coordinates;\n  PetscScalar   *coords;\n  PetscInt       Nv, v, dim, d;\n  PetscErrorCode ierr;\n\n  PetscFunctionBeginUser;\n  ierr = DMGetCoordinatesLocal(dm, &coordinates); CHKERRQ(ierr);\n  ierr = VecGetLocalSize(coordinates, &Nv); CHKERRQ(ierr);\n  ierr = VecGetBlockSize(coordinates, &dim); CHKERRQ(ierr);\n  Nv  /= dim;\n  ierr = VecGetArray(coordinates, &coords); CHKERRQ(ierr);\n  for (v = 0; v < Nv; ++v) {\n    PetscReal r = 0.0;\n\n    for (d = 0; d < dim; ++d) r += PetscSqr(PetscRealPart(coords[v*dim+d]));\n    r = PetscSqrtReal(r);\n    for (d = 0; d < dim; ++d) coords[v*dim+d] /= r;\n  }\n  ierr = VecRestoreArray(coordinates, &coords); CHKERRQ(ierr);\n  PetscFunctionReturn(0);\n}\n\n// -----------------------------------------------------------------------------\n// PETSc Finite Element space setup\n// -----------------------------------------------------------------------------\n\n// Create FE by degree\nstatic int PetscFECreateByDegree(DM dm, PetscInt dim, PetscInt Nc,\n                                 PetscBool isSimplex, const char prefix[],\n                                 PetscInt order, PetscFE *fem) {\n  PetscQuadrature q, fq;\n  DM              K;\n  PetscSpace      P;\n  PetscDualSpace  Q;\n  PetscInt        quadPointsPerEdge;\n  PetscBool       tensor = isSimplex ? PETSC_FALSE : PETSC_TRUE;\n  PetscErrorCode  ierr;\n\n  PetscFunctionBeginUser;\n  /* Create space */\n  ierr = PetscSpaceCreate(PetscObjectComm((PetscObject) dm), &P); CHKERRQ(ierr);\n  ierr = PetscObjectSetOptionsPrefix((PetscObject) P, prefix); CHKERRQ(ierr);\n  ierr = PetscSpacePolynomialSetTensor(P, tensor); CHKERRQ(ierr);\n  ierr = PetscSpaceSetFromOptions(P); CHKERRQ(ierr);\n  ierr = PetscSpaceSetNumComponents(P, Nc); CHKERRQ(ierr);\n  ierr = PetscSpaceSetNumVariables(P, dim); CHKERRQ(ierr);\n  ierr = PetscSpaceSetDegree(P, order, order); CHKERRQ(ierr);\n  ierr = PetscSpaceSetUp(P); CHKERRQ(ierr);\n  ierr = PetscSpacePolynomialGetTensor(P, &tensor); CHKERRQ(ierr);\n  /* Create dual space */\n  ierr = PetscDualSpaceCreate(PetscObjectComm((PetscObject) dm), &Q);\n  CHKERRQ(ierr);\n  ierr = PetscDualSpaceSetType(Q,PETSCDUALSPACELAGRANGE); CHKERRQ(ierr);\n  ierr = PetscObjectSetOptionsPrefix((PetscObject) Q, prefix); CHKERRQ(ierr);\n  ierr = PetscDualSpaceCreateReferenceCell(Q, dim, isSimplex, &K); CHKERRQ(ierr);\n  ierr = PetscDualSpaceSetDM(Q, K); CHKERRQ(ierr);\n  ierr = DMDestroy(&K); CHKERRQ(ierr);\n  ierr = PetscDualSpaceSetNumComponents(Q, Nc); CHKERRQ(ierr);\n  ierr = PetscDualSpaceSetOrder(Q, order); CHKERRQ(ierr);\n  ierr = PetscDualSpaceLagrangeSetTensor(Q, tensor); CHKERRQ(ierr);\n  ierr = PetscDualSpaceSetFromOptions(Q); CHKERRQ(ierr);\n  ierr = PetscDualSpaceSetUp(Q); CHKERRQ(ierr);\n  /* Create element */\n  ierr = PetscFECreate(PetscObjectComm((PetscObject) dm), fem); CHKERRQ(ierr);\n  ierr = PetscObjectSetOptionsPrefix((PetscObject) *fem, prefix); CHKERRQ(ierr);\n  ierr = PetscFESetFromOptions(*fem); CHKERRQ(ierr);\n  ierr = PetscFESetBasisSpace(*fem, P); CHKERRQ(ierr);\n  ierr = PetscFESetDualSpace(*fem, Q); CHKERRQ(ierr);\n  ierr = PetscFESetNumComponents(*fem, Nc); CHKERRQ(ierr);\n  ierr = PetscFESetUp(*fem); CHKERRQ(ierr);\n  ierr = PetscSpaceDestroy(&P); CHKERRQ(ierr);\n  ierr = PetscDualSpaceDestroy(&Q); CHKERRQ(ierr);\n  /* Create quadrature */\n  quadPointsPerEdge = PetscMax(order + 1,1);\n  if (isSimplex) {\n    ierr = PetscDTStroudConicalQuadrature(dim,   1, quadPointsPerEdge, -1.0, 1.0,\n                                          &q); CHKERRQ(ierr);\n    ierr = PetscDTStroudConicalQuadrature(dim-1, 1, quadPointsPerEdge, -1.0, 1.0,\n                                          &fq); CHKERRQ(ierr);\n  } else {\n    ierr = PetscDTGaussTensorQuadrature(dim,   1, quadPointsPerEdge, -1.0, 1.0,\n                                        &q); CHKERRQ(ierr);\n    ierr = PetscDTGaussTensorQuadrature(dim-1, 1, quadPointsPerEdge, -1.0, 1.0,\n                                        &fq); CHKERRQ(ierr);\n  }\n  ierr = PetscFESetQuadrature(*fem, q); CHKERRQ(ierr);\n  ierr = PetscFESetFaceQuadrature(*fem, fq); CHKERRQ(ierr);\n  ierr = PetscQuadratureDestroy(&q); CHKERRQ(ierr);\n  ierr = PetscQuadratureDestroy(&fq); CHKERRQ(ierr);\n\n  PetscFunctionReturn(0);\n}\n\n// -----------------------------------------------------------------------------\n// PETSc Setup for Level\n// -----------------------------------------------------------------------------\n\n// This function sets up a DM for a given degree\nstatic int SetupDMByDegree(DM dm, PetscInt degree, PetscInt ncompu,\n                           PetscInt dim) {\n  PetscInt ierr;\n  PetscFE fe;\n\n  PetscFunctionBeginUser;\n\n  // Setup FE\n  ierr = PetscFECreateByDegree(dm, dim, ncompu, PETSC_FALSE, NULL, degree, &fe);\n  CHKERRQ(ierr);\n  ierr = DMAddField(dm, NULL, (PetscObject)fe); CHKERRQ(ierr);\n\n  // Setup DM\n  ierr = DMCreateDS(dm); CHKERRQ(ierr);\n  ierr = DMPlexSetClosurePermutationTensor(dm, PETSC_DETERMINE, NULL);\n  CHKERRQ(ierr);\n  ierr = PetscFEDestroy(&fe); CHKERRQ(ierr);\n\n  PetscFunctionReturn(0);\n}\n\n// -----------------------------------------------------------------------------\n// libCEED Setup for Level\n// -----------------------------------------------------------------------------\n\n// Destroy libCEED operator objects\nstatic PetscErrorCode CeedDataDestroy(CeedData data) {\n  PetscInt ierr;\n\n  CeedVectorDestroy(&data->qdata);\n  CeedVectorDestroy(&data->uceed);\n  CeedVectorDestroy(&data->vceed);\n  CeedBasisDestroy(&data->basisx);\n  CeedBasisDestroy(&data->basisu);\n  CeedElemRestrictionDestroy(&data->Erestrictu);\n  CeedElemRestrictionDestroy(&data->Erestrictx);\n  CeedElemRestrictionDestroy(&data->Erestrictqdi);\n  CeedQFunctionDestroy(&data->qf_apply);\n  CeedOperatorDestroy(&data->op_apply);\n  ierr = PetscFree(data); CHKERRQ(ierr);\n\n  PetscFunctionReturn(0);\n}\n\n// Auxiliary function to define CEED restrictions from DMPlex data\nstatic int CreateRestrictionPlex(Ceed ceed, CeedInt P, CeedInt ncomp,\n                                 CeedElemRestriction *Erestrict, DM dm) {\n  PetscInt ierr;\n  PetscInt c, cStart, cEnd, nelem, nnodes, *erestrict, eoffset;\n  PetscSection section;\n  Vec Uloc;\n\n  PetscFunctionBegin;\n\n  // Get Nelem\n  ierr = DMGetSection(dm, &section); CHKERRQ(ierr);\n  ierr = DMPlexGetHeightStratum(dm, 0, &cStart,& cEnd); CHKERRQ(ierr);\n  nelem = cEnd - cStart;\n\n  // Get indices\n  ierr = PetscMalloc1(nelem*P*P, &erestrict); CHKERRQ(ierr);\n  for (c=cStart, eoffset = 0; c<cEnd; c++) {\n    PetscInt numindices, *indices, i;\n    ierr = DMPlexGetClosureIndices(dm, section, section, c, PETSC_TRUE,\n                                   &numindices, &indices, NULL, NULL);\n    CHKERRQ(ierr);\n    for (i=0; i<numindices; i+=ncomp) {\n      for (PetscInt j=0; j<ncomp; j++) {\n        if (indices[i+j] != indices[i] + (PetscInt)(copysign(j, indices[i])))\n          SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_INCOMP,\n                   \"Cell %D closure indices not interlaced\", c);\n      }\n      // NO BC on closed surfaces\n      PetscInt loc = indices[i];\n      erestrict[eoffset++] = loc;\n    }\n    ierr = DMPlexRestoreClosureIndices(dm, section, section, c, PETSC_TRUE,\n                                       &numindices, &indices, NULL, NULL);\n    CHKERRQ(ierr);\n  }\n\n  // Setup CEED restriction\n  ierr = DMGetLocalVector(dm, &Uloc); CHKERRQ(ierr);\n  ierr = VecGetLocalSize(Uloc, &nnodes); CHKERRQ(ierr);\n\n  ierr = DMRestoreLocalVector(dm, &Uloc); CHKERRQ(ierr);\n  CeedElemRestrictionCreate(ceed, nelem, P*P, ncomp, 1, nnodes,\n                            CEED_MEM_HOST, CEED_COPY_VALUES, erestrict,\n                            Erestrict);\n  ierr = PetscFree(erestrict); CHKERRQ(ierr);\n\n  PetscFunctionReturn(0);\n}\n\n// Set up libCEED for a given degree\nstatic int SetupLibceedByDegree(DM dm, Ceed ceed, CeedInt degree,\n                                CeedInt topodim, CeedInt qextra,\n                                PetscInt ncompx, PetscInt ncompu,\n                                PetscInt xlsize, problemType problemChoice,\n                                CeedData data) {\n  int ierr;\n  DM dmcoord;\n  Vec coords;\n  const PetscScalar *coordArray;\n  CeedBasis basisx, basisu;\n  CeedElemRestriction Erestrictx, Erestrictu, Erestrictqdi;\n  CeedQFunction qf_setupgeo, qf_apply;\n  CeedOperator op_setupgeo, op_apply;\n  CeedVector xcoord, qdata, uceed, vceed;\n  CeedInt P, Q, cStart, cEnd, nelem,\n          qdatasize = problemOptions[problemChoice].qdatasize;\n\n  // CEED bases\n  P = degree + 1;\n  Q = P + qextra;\n  CeedBasisCreateTensorH1Lagrange(ceed, topodim, ncompu, P, Q,\n                                  problemOptions[problemChoice].qmode, &basisu);\n  CeedBasisCreateTensorH1Lagrange(ceed, topodim, ncompx, 2, Q,\n                                  problemOptions[problemChoice].qmode, &basisx);\n\n  // CEED restrictions\n  ierr = DMGetCoordinateDM(dm, &dmcoord); CHKERRQ(ierr);\n  ierr = DMPlexSetClosurePermutationTensor(dmcoord, PETSC_DETERMINE, NULL);\n  CHKERRQ(ierr);\n\n  ierr = CreateRestrictionPlex(ceed, 2, ncompx, &Erestrictx, dmcoord);\n  CHKERRQ(ierr);\n  ierr = CreateRestrictionPlex(ceed, P, ncompu, &Erestrictu, dm); CHKERRQ(ierr);\n\n  ierr = DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd); CHKERRQ(ierr);\n  nelem = cEnd - cStart;\n\n  CeedElemRestrictionCreateStrided(ceed, nelem, Q*Q, qdatasize,\n                                   qdatasize*nelem*Q*Q,\n                                   CEED_STRIDES_BACKEND, &Erestrictqdi);\n\n  // Element coordinates\n  ierr = DMGetCoordinatesLocal(dm, &coords); CHKERRQ(ierr);\n  ierr = VecGetArrayRead(coords, &coordArray); CHKERRQ(ierr);\n\n  CeedElemRestrictionCreateVector(Erestrictx, &xcoord, NULL);\n  CeedVectorSetArray(xcoord, CEED_MEM_HOST, CEED_COPY_VALUES,\n                     (PetscScalar *)coordArray);\n  ierr = VecRestoreArrayRead(coords, &coordArray);\n\n  // Create the vectors that will be needed in setup and apply\n  CeedInt nqpts;\n  CeedBasisGetNumQuadraturePoints(basisu, &nqpts);\n  CeedVectorCreate(ceed, qdatasize*nelem*nqpts, &qdata);\n  CeedVectorCreate(ceed, xlsize, &uceed);\n  CeedVectorCreate(ceed, xlsize, &vceed);\n\n  // Create the Q-function that builds the operator (i.e. computes its\n  // quadrature data) and set its context data\n  CeedQFunctionCreateInterior(ceed, 1, problemOptions[problemChoice].setupgeo,\n                              problemOptions[problemChoice].setupgeofname,\n                              &qf_setupgeo);\n  CeedQFunctionAddInput(qf_setupgeo, \"x\", ncompx, CEED_EVAL_INTERP);\n  CeedQFunctionAddInput(qf_setupgeo, \"dx\", ncompx*topodim, CEED_EVAL_GRAD);\n  CeedQFunctionAddInput(qf_setupgeo, \"weight\", 1, CEED_EVAL_WEIGHT);\n  CeedQFunctionAddOutput(qf_setupgeo, \"qdata\", qdatasize, CEED_EVAL_NONE);\n\n  // Set up the mass operator\n  CeedQFunctionCreateInterior(ceed, 1, problemOptions[problemChoice].apply,\n                              problemOptions[problemChoice].applyfname,\n                              &qf_apply);\n  CeedQFunctionAddInput(qf_apply, \"u\", ncompu,\n                        problemOptions[problemChoice].inmode);\n  CeedQFunctionAddInput(qf_apply, \"qdata\", qdatasize, CEED_EVAL_NONE);\n  CeedQFunctionAddOutput(qf_apply, \"v\", ncompu,\n                         problemOptions[problemChoice].outmode);\n\n  // Create the operator that builds the quadrature data for the operator\n  CeedOperatorCreate(ceed, qf_setupgeo, NULL, NULL, &op_setupgeo);\n  CeedOperatorSetField(op_setupgeo, \"x\", Erestrictx, basisx,\n                       CEED_VECTOR_ACTIVE);\n  CeedOperatorSetField(op_setupgeo, \"dx\", Erestrictx, basisx,\n                       CEED_VECTOR_ACTIVE);\n  CeedOperatorSetField(op_setupgeo, \"weight\", CEED_ELEMRESTRICTION_NONE, basisx,\n                       CEED_VECTOR_NONE);\n  CeedOperatorSetField(op_setupgeo, \"qdata\", Erestrictqdi,\n                       CEED_BASIS_COLLOCATED, CEED_VECTOR_ACTIVE);\n\n  // Create the mass or diff operator\n  CeedOperatorCreate(ceed, qf_apply, NULL, NULL, &op_apply);\n  CeedOperatorSetField(op_apply, \"u\", Erestrictu, basisu, CEED_VECTOR_ACTIVE);\n  CeedOperatorSetField(op_apply, \"qdata\", Erestrictqdi, CEED_BASIS_COLLOCATED,\n                       qdata);\n  CeedOperatorSetField(op_apply, \"v\", Erestrictu, basisu, CEED_VECTOR_ACTIVE);\n\n  // Setup qdata\n  CeedOperatorApply(op_setupgeo, xcoord, qdata, CEED_REQUEST_IMMEDIATE);\n\n  // Cleanup\n  CeedQFunctionDestroy(&qf_setupgeo);\n  CeedOperatorDestroy(&op_setupgeo);\n  CeedVectorDestroy(&xcoord);\n\n  // Save libCEED data\n  data->basisx = basisx;\n  data->basisu = basisu;\n  data->Erestrictx = Erestrictx;\n  data->Erestrictu = Erestrictu;\n  data->Erestrictqdi = Erestrictqdi;\n  data->qf_apply = qf_apply;\n  data->op_apply = op_apply;\n  data->qdata = qdata;\n  data->uceed = uceed;\n  data->vceed = vceed;\n\n  PetscFunctionReturn(0);\n}\n\n#endif // setuparea_h\n", "meta": {"hexsha": "df2a7ecae0b48bf7a5c8a18d701d5ef12827b9c7", "size": 16724, "ext": "h", "lang": "C", "max_stars_repo_path": "examples/petsc/setuparea.h", "max_stars_repo_name": "barker29/libCEED", "max_stars_repo_head_hexsha": "3d576824e8d990e1f48c6609089904bee9170514", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "examples/petsc/setuparea.h", "max_issues_repo_name": "barker29/libCEED", "max_issues_repo_head_hexsha": "3d576824e8d990e1f48c6609089904bee9170514", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "examples/petsc/setuparea.h", "max_forks_repo_name": "barker29/libCEED", "max_forks_repo_head_hexsha": "3d576824e8d990e1f48c6609089904bee9170514", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-03-30T23:13:18.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-30T23:13:18.000Z", "avg_line_length": 38.1826484018, "max_line_length": 99, "alphanum_fraction": 0.6334608945, "num_tokens": 4525, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3998116264369279, "lm_q2_score": 0.051845469213544056, "lm_q1q2_score": 0.020728421369652722}}
{"text": "/* spswap.c\n * \n * Copyright (C) 2014 Patrick Alken\n * Copyright (C) 2016 Alexis Tantet\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include <config.h>\n#include <stdlib.h>\n#include <math.h>\n\n#include <gsl/gsl_math.h>\n#include <gsl/gsl_matrix.h>\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_spmatrix.h>\n\n#include \"avl.c\"\n\n/*\ngsl_spmatrix_transpose()\n  Replace the sparse matrix src by its transpose,\nkeeping the matrix in the same storage format\n\nInputs: A - (input/output) sparse matrix to transpose.\n*/\n\nint\ngsl_spmatrix_transpose(gsl_spmatrix * m)\n{\n  if (GSL_SPMATRIX_ISTRIPLET(m))\n    {\n      size_t n;\n\n      /* swap row/column indices */\n      for (n = 0; n < m->nz; ++n)\n        {\n          size_t tmp = m->p[n];\n          m->p[n] = m->i[n];\n          m->i[n] = tmp;\n        }\n\n      /* need to rebuild AVL tree, or element searches won't\n       * work correctly with transposed indices */\n      gsl_spmatrix_tree_rebuild(m);\n    }\n  else\n    {\n      GSL_ERROR(\"unknown sparse matrix type\", GSL_EINVAL);\n    }\n  \n  /* swap dimensions */\n  if (m->size1 != m->size2)\n    {\n      size_t tmp = m->size1;\n      m->size1 = m->size2;\n      m->size2 = tmp;\n    }\n  \n  return GSL_SUCCESS;\n}\n\n/*\ngsl_spmatrix_transpose2()\n  Replace the sparse matrix src by its transpose either by\n  swapping its row and column indices if it is in triplet storage,\n  or by switching its major if it is in compressed storage.\n\nInputs: A - (input/output) sparse matrix to transpose.\n*/\n\nint\ngsl_spmatrix_transpose2(gsl_spmatrix * m)\n{\n  if (GSL_SPMATRIX_ISTRIPLET(m))\n    {\n      return gsl_spmatrix_transpose(m);\n    }\n  else if (GSL_SPMATRIX_ISCCS(m))\n    {\n      m->sptype = GSL_SPMATRIX_CRS;\n    }\n  else if (GSL_SPMATRIX_ISCRS(m))\n    {\n      m->sptype = GSL_SPMATRIX_CCS;\n    }\n  else\n    {\n      GSL_ERROR(\"unknown sparse matrix type\", GSL_EINVAL);\n    }\n  \n  /* swap dimensions */\n  if (m->size1 != m->size2)\n    {\n      size_t tmp = m->size1;\n      m->size1 = m->size2;\n      m->size2 = tmp;\n    }\n  \n  return GSL_SUCCESS;\n}\n\nint\ngsl_spmatrix_transpose_memcpy(gsl_spmatrix *dest, const gsl_spmatrix *src)\n{\n  const size_t M = src->size1;\n  const size_t N = src->size2;\n\n  if (M != dest->size2 || N != dest->size1)\n    {\n      GSL_ERROR(\"dimensions of dest must be transpose of src matrix\",\n                GSL_EBADLEN);\n    }\n  else if (dest->sptype != src->sptype)\n    {\n      GSL_ERROR(\"cannot copy matrices of different storage formats\",\n                GSL_EINVAL);\n    }\n  else\n    {\n      int s = GSL_SUCCESS;\n      const size_t nz = src->nz;\n\n      if (dest->nzmax < src->nz)\n        {\n          s = gsl_spmatrix_realloc(src->nz, dest);\n          if (s)\n            return s;\n        }\n\n      if (GSL_SPMATRIX_ISTRIPLET(src))\n        {\n          size_t n;\n          void *ptr;\n\n          for (n = 0; n < nz; ++n)\n            {\n              dest->i[n] = src->p[n];\n              dest->p[n] = src->i[n];\n              dest->data[n] = src->data[n];\n\n              /* copy binary tree data */\n              ptr = avl_insert(dest->tree_data->tree, &dest->data[n]);\n              if (ptr != NULL)\n                {\n                  GSL_ERROR(\"detected duplicate entry\", GSL_EINVAL);\n                }\n            }\n        }\n      else if (GSL_SPMATRIX_ISCCS(src))\n        {\n          size_t *Ai = src->i;\n          size_t *Ap = src->p;\n          double *Ad = src->data;\n          size_t *ATi = dest->i;\n          size_t *ATp = dest->p;\n          double *ATd = dest->data;\n          size_t *w = (size_t *) dest->work;\n          size_t p, j;\n\n          /* initialize to 0 */\n          for (p = 0; p < M + 1; ++p)\n            ATp[p] = 0;\n\n          /* compute row counts of A (= column counts for A^T) */\n          for (p = 0; p < nz; ++p)\n            ATp[Ai[p]]++;\n\n          /* compute row pointers for A (= column pointers for A^T) */\n          gsl_spmatrix_cumsum(M, ATp);\n\n          /* make copy of row pointers */\n          for (j = 0; j < M; ++j)\n            w[j] = ATp[j];\n\n          for (j = 0; j < N; ++j)\n            {\n              for (p = Ap[j]; p < Ap[j + 1]; ++p)\n                {\n                  size_t k = w[Ai[p]]++;\n                  ATi[k] = j;\n                  ATd[k] = Ad[p];\n                }\n            }\n        }\n      else if (GSL_SPMATRIX_ISCRS(src))\n        {\n          size_t *Aj = src->i;\n          size_t *Ap = src->p;\n          double *Ad = src->data;\n          size_t *ATj = dest->i;\n          size_t *ATp = dest->p;\n          double *ATd = dest->data;\n          size_t *w = (size_t *) dest->work;\n          size_t p, i;\n\n          /* initialize to 0 */\n          for (p = 0; p < N + 1; ++p)\n            ATp[p] = 0;\n\n          /* compute column counts of A (= row counts for A^T) */\n          for (p = 0; p < nz; ++p)\n            ATp[Aj[p]]++;\n\n          /* compute column pointers for A (= row pointers for A^T) */\n          gsl_spmatrix_cumsum(N, ATp);\n\n          /* make copy of column pointers */\n          for (i = 0; i < N; ++i)\n            w[i] = ATp[i];\n\n          for (i = 0; i < M; ++i)\n            {\n              for (p = Ap[i]; p < Ap[i + 1]; ++p)\n                {\n                  size_t k = w[Aj[p]]++;\n                  ATj[k] = i;\n                  ATd[k] = Ad[p];\n                }\n            }\n        }\n      else\n        {\n          GSL_ERROR(\"unknown sparse matrix type\", GSL_EINVAL);\n        }\n\n      dest->nz = nz;\n\n      return s;\n    }\n} /* gsl_spmatrix_transpose_memcpy() */\n", "meta": {"hexsha": "a54876f6cd87988203523ec58273684f50b9617e", "size": 6118, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.4/spmatrix/spswap.c", "max_stars_repo_name": "peterahrens/FillEstimationIPDPS2017", "max_stars_repo_head_hexsha": "857b6ee8866a2950aa5721d575d2d7d0797c4302", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-01-13T05:01:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-13T05:01:59.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/spmatrix/spswap.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/spmatrix/spswap.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.0737704918, "max_line_length": 81, "alphanum_fraction": 0.5125858124, "num_tokens": 1732, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.41869690935568665, "lm_q2_score": 0.048857774813604704, "lm_q1q2_score": 0.0204565993124524}}
{"text": "/***************************************************************************/\n/*                                                                         */\n/* vector.c - Vector class for mruby                                       */\n/* Copyright (C) 2015 Paolo Bosetti                                        */\n/* paolo[dot]bosetti[at]unitn.it                                           */\n/* Department of Industrial Engineering, University of Trento              */\n/*                                                                         */\n/* This library is free software.  You can redistribute it and/or          */\n/* modify it under the terms of the GNU GENERAL PUBLIC LICENSE 2.0.        */\n/*                                                                         */\n/* This library is distributed in the hope that it will be useful,         */\n/* but WITHOUT ANY WARRANTY; without even the implied warranty of          */\n/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           */\n/* Artistic License 2.0 for more details.                                  */\n/*                                                                         */\n/* See the file LICENSE                                                    */\n/*                                                                         */\n/***************************************************************************/\n\n#include <gsl/gsl_blas.h>\n#include <gsl/gsl_statistics_double.h>\n#include <gsl/gsl_sort_vector.h>\n#include <gsl/gsl_rng.h>\n#include \"vector.h\"\n\n#pragma mark -\n#pragma mark • Utilities\n\n// Garbage collector handler, for play_data struct\n// if play_data contains other dynamic data, free it too!\n// Check it with GC.start\nvoid vector_destructor(mrb_state *mrb, void *p_) {\n  gsl_vector *v = (gsl_vector *)p_;\n  gsl_vector_free(v);\n};\n\n// Creating data type and reference for GC, in a const struct\nconst struct mrb_data_type vector_data_type = {\"vector_data\",\n                                               vector_destructor};\n\n// Utility function for getting the struct out of the wrapping IV @data\nvoid mrb_vector_get_data(mrb_state *mrb, mrb_value self, gsl_vector **data) {\n  mrb_value data_value;\n  data_value = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, \"@data\"));\n\n  // Loading data from data_value into p_data:\n  Data_Get_Struct(mrb, data_value, &vector_data_type, *data);\n  if (!*data)\n    mrb_raise(mrb, E_RUNTIME_ERROR, \"Could not access @data\");\n}\n\n#pragma mark -\n#pragma mark • Init and accessing\n\n// Data Initializer C function (not exposed!)\nstatic void mrb_vector_init(mrb_state *mrb, mrb_value self, mrb_int n) {\n  mrb_value data_value; // this IV holds the data\n  gsl_vector *p_data;   // pointer to the C struct\n\n  data_value = mrb_iv_get(mrb, self, mrb_intern_lit(mrb, \"@data\"));\n\n  // if @data already exists, free its content:\n  if (!mrb_nil_p(data_value)) {\n    Data_Get_Struct(mrb, data_value, &vector_data_type, p_data);\n    free(p_data);\n  }\n  // Allocate and zero-out the data struct:\n  p_data = gsl_vector_calloc(n);\n  if (!p_data)\n    mrb_raise(mrb, E_RUNTIME_ERROR, \"Could not allocate @data\");\n\n  // Wrap struct into @data:\n  mrb_iv_set(\n      mrb, self, mrb_intern_lit(mrb, \"@data\"), // set @data\n      mrb_obj_value(                           // with value hold in struct\n          Data_Wrap_Struct(mrb, mrb->object_class, &vector_data_type, p_data)));\n}\n\nstatic mrb_value mrb_vector_initialize(mrb_state *mrb, mrb_value self) {\n  mrb_int n;\n  mrb_get_args(mrb, \"i\", &n);\n\n  // Call strcut initializer:\n  mrb_vector_init(mrb, self, n);\n  mrb_iv_set(mrb, self, mrb_intern_lit(mrb, \"@length\"), mrb_fixnum_value(n));\n  mrb_iv_set(mrb, self, mrb_intern_lit(mrb, \"@format\"),\n             mrb_str_new_cstr(mrb, \"%10.3f\"));\n  return mrb_nil_value();\n}\n\nstatic mrb_value mrb_vector_rnd_fill(mrb_state *mrb, mrb_value self) {\n  gsl_vector *p_vec = NULL;\n  const gsl_rng_type *T;\n  gsl_rng *r;\n  mrb_int h;\n\n  mrb_vector_get_data(mrb, self, &p_vec);\n\n  gsl_rng_env_setup();\n  T = gsl_rng_default;\n  r = gsl_rng_alloc(T);\n\n  for (h = 0; h < p_vec->size; h++) {\n    gsl_vector_set(p_vec, h, gsl_rng_uniform(r));\n  }\n  return self;\n}\n\n\nstatic mrb_value mrb_vector_dup(mrb_state *mrb, mrb_value self) {\n  mrb_value other;\n  gsl_vector *p_vec = NULL, *p_vec_other = NULL;\n  mrb_value args[1];\n\n  // call utility for unwrapping @data into p_data:\n  mrb_vector_get_data(mrb, self, &p_vec);\n  args[0] = mrb_fixnum_value(p_vec->size);\n  other = mrb_obj_new(mrb, mrb_class_get(mrb, \"Vector\"), 1, args);\n  mrb_vector_get_data(mrb, other, &p_vec_other);\n  gsl_vector_memcpy(p_vec_other, p_vec);\n  return other;\n}\n\nstatic mrb_value mrb_vector_all(mrb_state *mrb, mrb_value self) {\n  mrb_float v;\n  gsl_vector *p_vec = NULL;\n\n  mrb_get_args(mrb, \"f\", &v);\n  // call utility for unwrapping @data into p_data:\n  mrb_vector_get_data(mrb, self, &p_vec);\n  gsl_vector_set_all(p_vec, v);\n  return self;\n}\n\nstatic mrb_value mrb_vector_zero(mrb_state *mrb, mrb_value self) {\n  gsl_vector *p_vec = NULL;\n\n  // call utility for unwrapping @data into p_data:\n  mrb_vector_get_data(mrb, self, &p_vec);\n  gsl_vector_set_zero(p_vec);\n  return self;\n}\n\nstatic mrb_value mrb_vector_basis(mrb_state *mrb, mrb_value self) {\n  mrb_int i;\n  gsl_vector *p_vec = NULL;\n\n  mrb_get_args(mrb, \"i\", &i);\n  // call utility for unwrapping @data into p_data:\n  mrb_vector_get_data(mrb, self, &p_vec);\n  gsl_vector_set_basis(p_vec, i);\n  return self;\n}\n\n\n#pragma mark -\n#pragma mark • Tests\n\nstatic mrb_value mrb_vector_equal(mrb_state *mrb, mrb_value self) {\n  mrb_value other;\n  gsl_vector *p_vec, *p_vec_other;\n  mrb_get_args(mrb, \"o\", &other);\n\n  // call utility for unwrapping @data into p_data:\n  mrb_vector_get_data(mrb, self, &p_vec);\n  mrb_vector_get_data(mrb, other, &p_vec_other);\n  if (1 == gsl_vector_equal(p_vec, p_vec_other))\n    return mrb_true_value();\n  else\n    return mrb_false_value();\n}\n\n\n#pragma mark -\n#pragma mark • Accessors\n\nstatic mrb_value mrb_vector_get_i(mrb_state *mrb, mrb_value self) {\n  mrb_int i = 0;\n  gsl_vector *p_vec = NULL;\n\n  mrb_get_args(mrb, \"i\", &i);\n  // call utility for unwrapping @data into p_data:\n  mrb_vector_get_data(mrb, self, &p_vec);\n  if (i >= p_vec->size) {\n    mrb_raise(mrb, E_VECTOR_ERROR, \"Vector index out of range!\");\n  }\n  return mrb_float_value(mrb, gsl_vector_get(p_vec, (size_t)i));\n}\n\nstatic mrb_value mrb_vector_set_i(mrb_state *mrb, mrb_value self) {\n  mrb_int i = 0;\n  mrb_float f;\n  gsl_vector *p_vec = NULL;\n\n  mrb_get_args(mrb, \"if\", &i, &f);\n\n  // call utility for unwrapping @data into p_data:\n  mrb_vector_get_data(mrb, self, &p_vec);\n  if (i >= p_vec->size) {\n    mrb_raise(mrb, E_VECTOR_ERROR, \"Vector index out of range!\");\n  }\n  gsl_vector_set(p_vec, (size_t)i, (double)f);\n  return mrb_float_value(mrb, f);\n}\n\nstatic mrb_value mrb_vector_to_a(mrb_state *mrb, mrb_value self) {\n  int i;\n  mrb_value ary = mrb_nil_value();\n  gsl_vector *p_vec = NULL;\n  mrb_float e;\n  mrb_vector_get_data(mrb, self, &p_vec);\n  ary = mrb_ary_new_capa(mrb, p_vec->size);\n  for (i = 0; i < p_vec->size; i++) {\n    e = *(p_vec->data + i * p_vec->stride);\n    mrb_ary_set(mrb, ary, i, mrb_float_value(mrb, e));\n  }\n  return ary;\n}\n\n#pragma mark -\n#pragma mark • Properties\n\nstatic mrb_value mrb_vector_max(mrb_state *mrb, mrb_value self) {\n  gsl_vector *p_vec = NULL;\n  mrb_vector_get_data(mrb, self, &p_vec);\n  return mrb_float_value(mrb, gsl_vector_max(p_vec));\n}\n\nstatic mrb_value mrb_vector_min(mrb_state *mrb, mrb_value self) {\n  gsl_vector *p_vec = NULL;\n  mrb_vector_get_data(mrb, self, &p_vec);\n  return mrb_float_value(mrb, gsl_vector_min(p_vec));\n}\n\nstatic mrb_value mrb_vector_max_index(mrb_state *mrb, mrb_value self) {\n  gsl_vector *p_vec = NULL;\n  mrb_vector_get_data(mrb, self, &p_vec);\n  return mrb_fixnum_value(gsl_vector_max_index(p_vec));\n}\n\nstatic mrb_value mrb_vector_min_index(mrb_state *mrb, mrb_value self) {\n  gsl_vector *p_vec = NULL;\n  mrb_vector_get_data(mrb, self, &p_vec);\n  return mrb_fixnum_value(gsl_vector_min_index(p_vec));\n}\n\n#pragma mark -\n#pragma mark • Operations\n\nstatic mrb_value mrb_vector_add(mrb_state *mrb, mrb_value self) {\n  mrb_value other;\n  gsl_vector *p_vec, *p_vec_other;\n  mrb_get_args(mrb, \"o\", &other);\n\n  // call utility for unwrapping @data into p_data:\n  mrb_vector_get_data(mrb, self, &p_vec);\n\n  if (mrb_obj_is_kind_of(mrb, other, mrb_class_get(mrb, \"Vector\"))) {\n    mrb_vector_get_data(mrb, other, &p_vec_other);\n    if (p_vec->size != p_vec_other->size) {\n      mrb_raise(mrb, E_VECTOR_ERROR, \"Vector indexes don't match!\");\n    }\n    gsl_vector_add(p_vec, p_vec_other);\n  } else if (mrb_obj_is_kind_of(mrb, other, mrb_class_get(mrb, \"Numeric\"))) {\n    gsl_vector_add_constant(p_vec, mrb_to_flo(mrb, other));\n  }\n  return self;\n}\n\nstatic mrb_value mrb_vector_sub(mrb_state *mrb, mrb_value self) {\n  mrb_value other;\n  gsl_vector *p_vec, *p_vec_other;\n  mrb_get_args(mrb, \"o\", &other);\n\n  // call utility for unwrapping @data into p_data:\n  mrb_vector_get_data(mrb, self, &p_vec);\n  mrb_vector_get_data(mrb, other, &p_vec_other);\n  if (p_vec->size != p_vec_other->size) {\n    mrb_raise(mrb, E_VECTOR_ERROR, \"Vector dimensions don't match!\");\n  }\n  gsl_vector_sub(p_vec, p_vec_other);\n  return self;\n}\n\nstatic mrb_value mrb_vector_mul(mrb_state *mrb, mrb_value self) {\n  mrb_value other;\n  gsl_vector *p_vec, *p_vec_other;\n  mrb_get_args(mrb, \"o\", &other);\n\n  // call utility for unwrapping @data into p_data:\n  mrb_vector_get_data(mrb, self, &p_vec);\n  if (mrb_obj_is_kind_of(mrb, other, mrb_class_get(mrb, \"Vector\"))) {\n    mrb_vector_get_data(mrb, other, &p_vec_other);\n    if (p_vec->size != p_vec_other->size) {\n      mrb_raise(mrb, E_VECTOR_ERROR, \"Vector indexes don't match!\");\n    }\n    gsl_vector_mul(p_vec, p_vec_other);\n  } else if (mrb_obj_is_kind_of(mrb, other, mrb_class_get(mrb, \"Numeric\"))) {\n    gsl_vector_scale(p_vec, mrb_to_flo(mrb, other));\n  }\n  return self;\n}\n\nstatic mrb_value mrb_vector_div(mrb_state *mrb, mrb_value self) {\n  mrb_value other;\n  gsl_vector *p_vec, *p_vec_other;\n  mrb_get_args(mrb, \"o\", &other);\n\n  // call utility for unwrapping @data into p_data:\n  mrb_vector_get_data(mrb, self, &p_vec);\n  mrb_vector_get_data(mrb, other, &p_vec_other);\n  if (p_vec->size != p_vec_other->size) {\n    mrb_raise(mrb, E_VECTOR_ERROR, \"Vector indexes don't match!\");\n  }\n  gsl_vector_div(p_vec, p_vec_other);\n  return self;\n}\n\nstatic mrb_value mrb_vector_prod(mrb_state *mrb, mrb_value self) {\n  mrb_value other;\n  gsl_vector *p_vec, *p_vec_other;\n  mrb_float res;\n  mrb_get_args(mrb, \"o\", &other);\n\n  // call utility for unwrapping @data into p_data:\n  mrb_vector_get_data(mrb, self, &p_vec);\n  mrb_vector_get_data(mrb, other, &p_vec_other);\n  if (!mrb_obj_is_kind_of(mrb, other, mrb_class_get(mrb, \"Vector\"))) {\n    mrb_raise(mrb, E_ARGUMENT_ERROR, \"Need a Vector!\");\n  }\n  if (p_vec->size != p_vec_other->size) {\n    mrb_raise(mrb, E_VECTOR_ERROR, \"Vector indexes don't match!\");\n  }\n  if (gsl_blas_ddot(p_vec, p_vec_other, &res)) {\n    mrb_raise(mrb, E_VECTOR_ERROR, \"Cannot multiply\");\n  }\n  return mrb_float_value(mrb, res);\n}\n\nstatic mrb_value mrb_vector_norm(mrb_state *mrb, mrb_value self) {\n  gsl_vector *p_vec;\n\n  // call utility for unwrapping @data into p_data:\n  mrb_vector_get_data(mrb, self, &p_vec);\n  return mrb_float_value(mrb, gsl_blas_dnrm2(p_vec));\n}\n\nstatic mrb_value mrb_vector_sum(mrb_state *mrb, mrb_value self) {\n  gsl_vector *p_vec;\n\n  // call utility for unwrapping @data into p_data:\n  mrb_vector_get_data(mrb, self, &p_vec);\n  return mrb_float_value(mrb, gsl_blas_dasum(p_vec));\n}\n\nstatic mrb_value mrb_vector_swap(mrb_state *mrb, mrb_value self) {\n  gsl_vector *p_vec;\n  mrb_int i, j;\n  mrb_get_args(mrb, \"ii\", &i, &j);\n\n  // call utility for unwrapping @data into p_data:\n  mrb_vector_get_data(mrb, self, &p_vec);\n  if (gsl_vector_swap_elements(p_vec, i, j)) {\n    mrb_raise(mrb, E_VECTOR_ERROR, \"Cannot swap\");\n  }\n  return self;\n}\n\nstatic mrb_value mrb_vector_reverse(mrb_state *mrb, mrb_value self) {\n  gsl_vector *p_vec;\n\n  // call utility for unwrapping @data into p_data:\n  mrb_vector_get_data(mrb, self, &p_vec);\n  if (gsl_vector_reverse(p_vec)) {\n    mrb_raise(mrb, E_VECTOR_ERROR, \"Cannot reverse\");\n  }\n  return self;\n}\n\n\n#pragma mark -\n#pragma mark • Statistics\n\nstatic mrb_value mrb_vector_mean(mrb_state *mrb, mrb_value self) {\n  gsl_vector *p_vec;\n  mrb_float result;\n  // call utility for unwrapping @data into p_data:\n  mrb_vector_get_data(mrb, self, &p_vec);\n  result = gsl_stats_mean(p_vec->data, p_vec->stride, p_vec->size);\n  return mrb_float_value(mrb, result);\n}\n\nstatic mrb_value mrb_vector_variance(mrb_state *mrb, mrb_value self) {\n  gsl_vector *p_vec;\n  mrb_float result;\n  mrb_float m;\n  // call utility for unwrapping @data into p_data:\n  mrb_vector_get_data(mrb, self, &p_vec);\n  if (mrb_get_args(mrb, \"|f\", &m) == 1) {\n    result = gsl_stats_variance_m(p_vec->data, p_vec->stride, p_vec->size, m);\n  } else {\n    result = gsl_stats_variance(p_vec->data, p_vec->stride, p_vec->size);\n  }\n  return mrb_float_value(mrb, result);\n}\n\nstatic mrb_value mrb_vector_sd(mrb_state *mrb, mrb_value self) {\n  gsl_vector *p_vec;\n  mrb_float result;\n  mrb_float m;\n  // call utility for unwrapping @data into p_data:\n  mrb_vector_get_data(mrb, self, &p_vec);\n  if (mrb_get_args(mrb, \"|f\", &m) == 1) {\n    result = gsl_stats_sd_m(p_vec->data, p_vec->stride, p_vec->size, m);\n  } else {\n    result = gsl_stats_sd(p_vec->data, p_vec->stride, p_vec->size);\n  }\n  return mrb_float_value(mrb, result);\n}\n\nstatic mrb_value mrb_vector_absdev(mrb_state *mrb, mrb_value self) {\n  gsl_vector *p_vec;\n  mrb_float result;\n  mrb_float m;\n  // call utility for unwrapping @data into p_data:\n  mrb_vector_get_data(mrb, self, &p_vec);\n  if (mrb_get_args(mrb, \"|f\", &m) == 1) {\n    result = gsl_stats_absdev_m(p_vec->data, p_vec->stride, p_vec->size, m);\n  } else {\n    result = gsl_stats_absdev(p_vec->data, p_vec->stride, p_vec->size);\n  }\n  return mrb_float_value(mrb, result);\n}\n\nstatic mrb_value mrb_vector_quantile(mrb_state *mrb, mrb_value self) {\n  gsl_vector *p_vec = NULL, *p_sort_vec = NULL;\n  mrb_float result;\n  mrb_float f;\n  mrb_int n;\n  // call utility for unwrapping @data into p_data:\n  mrb_vector_get_data(mrb, self, &p_vec);\n  n = mrb_get_args(mrb, \"|f\", &f);\n  if (f < 0 || f > 1) {\n    mrb_raise(mrb, E_VECTOR_ERROR, \"Quantile must be in [0,1]\");\n  }\n  p_sort_vec = gsl_vector_calloc(p_vec->size);\n  if (gsl_vector_memcpy(p_sort_vec, p_vec)) {\n    mrb_raise(mrb, E_VECTOR_ERROR, \"Cannot copy vector\");\n  }\n  gsl_sort_vector(p_sort_vec);\n  if (n == 1) {\n    result = gsl_stats_quantile_from_sorted_data(\n        p_sort_vec->data, p_sort_vec->stride, p_sort_vec->size, f);\n  } else {\n    result = gsl_stats_quantile_from_sorted_data(\n        p_sort_vec->data, p_sort_vec->stride, p_sort_vec->size, 0.5);\n  }\n  return mrb_float_value(mrb, result);\n}\n\n\n#pragma mark -\n#pragma mark • Gem setup\n\nvoid mrb_gsl_vector_init(mrb_state *mrb) {\n  struct RClass *gsl;\n\n  mrb_load_string(mrb, \"class VectorError < Exception; end\");\n\n  gsl = mrb_define_class(mrb, \"Vector\", mrb->object_class);\n  mrb_define_method(mrb, gsl, \"all\", mrb_vector_all, MRB_ARGS_REQ(1));\n  mrb_define_method(mrb, gsl, \"zero\", mrb_vector_zero, MRB_ARGS_NONE());\n  mrb_define_method(mrb, gsl, \"basis\", mrb_vector_basis, MRB_ARGS_REQ(1));\n\n  mrb_define_method(mrb, gsl, \"initialize\", mrb_vector_initialize,\n                    MRB_ARGS_NONE());\n  mrb_define_method(mrb, gsl, \"rnd_fill\", mrb_vector_rnd_fill,\n                    MRB_ARGS_NONE());\n  mrb_define_method(mrb, gsl, \"dup\", mrb_vector_dup, MRB_ARGS_NONE());\n  mrb_define_method(mrb, gsl, \"===\", mrb_vector_equal, MRB_ARGS_REQ(1));\n  mrb_define_method(mrb, gsl, \"[]\", mrb_vector_get_i, MRB_ARGS_REQ(1));\n  mrb_define_method(mrb, gsl, \"[]=\", mrb_vector_set_i, MRB_ARGS_REQ(2));\n  mrb_define_method(mrb, gsl, \"to_a\", mrb_vector_to_a, MRB_ARGS_NONE());\n  mrb_define_method(mrb, gsl, \"max\", mrb_vector_max, MRB_ARGS_NONE());\n  mrb_define_method(mrb, gsl, \"min\", mrb_vector_min, MRB_ARGS_NONE());\n  mrb_define_method(mrb, gsl, \"max_index\", mrb_vector_max_index,\n                    MRB_ARGS_NONE());\n  mrb_define_method(mrb, gsl, \"min_index\", mrb_vector_min_index,\n                    MRB_ARGS_NONE());\n  mrb_define_method(mrb, gsl, \"add!\", mrb_vector_add, MRB_ARGS_REQ(1));\n  mrb_define_method(mrb, gsl, \"sub!\", mrb_vector_sub, MRB_ARGS_REQ(1));\n  mrb_define_method(mrb, gsl, \"mul!\", mrb_vector_mul, MRB_ARGS_REQ(1));\n  mrb_define_method(mrb, gsl, \"div!\", mrb_vector_div, MRB_ARGS_REQ(1));\n  mrb_define_method(mrb, gsl, \"^\", mrb_vector_prod, MRB_ARGS_REQ(1));\n  mrb_define_method(mrb, gsl, \"norm\", mrb_vector_norm, MRB_ARGS_NONE());\n  mrb_define_method(mrb, gsl, \"sum\", mrb_vector_sum, MRB_ARGS_NONE());\n  mrb_define_method(mrb, gsl, \"swap!\", mrb_vector_swap, MRB_ARGS_REQ(2));\n  mrb_define_method(mrb, gsl, \"reverse!\", mrb_vector_reverse, MRB_ARGS_NONE());\n\n  mrb_define_method(mrb, gsl, \"mean\", mrb_vector_mean, MRB_ARGS_OPT(1));\n  mrb_define_method(mrb, gsl, \"variance\", mrb_vector_variance, MRB_ARGS_OPT(1));\n  mrb_define_method(mrb, gsl, \"sd\", mrb_vector_sd, MRB_ARGS_OPT(1));\n  mrb_define_method(mrb, gsl, \"absdev\", mrb_vector_absdev, MRB_ARGS_OPT(1));\n  mrb_define_method(mrb, gsl, \"quantile\", mrb_vector_quantile, MRB_ARGS_OPT(1));\n}\n", "meta": {"hexsha": "a2233a87b80c8b57a91ef0b046997146946f0a61", "size": 17232, "ext": "c", "lang": "C", "max_stars_repo_path": "src/vector.c", "max_stars_repo_name": "UniTN-Mechatronics/mruby-gsl", "max_stars_repo_head_hexsha": "0961ef3b88bb8ed9e9223b2678ece281acaa0f4b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/vector.c", "max_issues_repo_name": "UniTN-Mechatronics/mruby-gsl", "max_issues_repo_head_hexsha": "0961ef3b88bb8ed9e9223b2678ece281acaa0f4b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/vector.c", "max_forks_repo_name": "UniTN-Mechatronics/mruby-gsl", "max_forks_repo_head_hexsha": "0961ef3b88bb8ed9e9223b2678ece281acaa0f4b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.0553359684, "max_line_length": 80, "alphanum_fraction": 0.6771703807, "num_tokens": 4882, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.37754066879814546, "lm_q2_score": 0.05261894926217173, "lm_q1q2_score": 0.019865793295895995}}
{"text": "/* interpolation/spline2d.c\n * \n * Copyright 2012 David Zaslavsky\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include <config.h>\n#include <string.h>\n#include <stdlib.h>\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_math.h>\n#include <gsl/gsl_interp.h>\n#include <gsl/gsl_interp2d.h>\n#include <gsl/gsl_spline2d.h>\n\ngsl_spline2d *\ngsl_spline2d_alloc(const gsl_interp2d_type * T, size_t xsize, size_t ysize)\n{\n  double * array_mem;\n  gsl_spline2d * interp;\n\n  if (xsize < T->min_size || ysize < T->min_size)\n    {\n      GSL_ERROR_NULL(\"insufficient number of points for interpolation type\", GSL_EINVAL);\n    }\n\n  interp = calloc(1, sizeof(gsl_spline2d));\n  if (interp == NULL)\n    {\n      GSL_ERROR_NULL(\"failed to allocate space for gsl_spline2d struct\", GSL_ENOMEM);\n    }\n\n  interp->interp_object.type = T;\n  interp->interp_object.xsize = xsize;\n  interp->interp_object.ysize = ysize;\n  if (interp->interp_object.type->alloc == NULL)\n    {\n      interp->interp_object.state = NULL;\n    }\n  else\n    {\n      interp->interp_object.state = interp->interp_object.type->alloc(xsize, ysize);\n      if (interp->interp_object.state == NULL)\n        {\n          gsl_spline2d_free(interp);\n          GSL_ERROR_NULL(\"failed to allocate space for gsl_spline2d state\", GSL_ENOMEM);\n        }\n    }\n\n  /*\n   * Use one contiguous block of memory for all three data arrays.\n   * That way the code fails immediately if there isn't sufficient space for everything,\n   * rather than allocating one or two and then having to free them.\n   */\n  array_mem = (double *)calloc(xsize + ysize + xsize * ysize, sizeof(double));\n  if (array_mem == NULL)\n    {\n      gsl_spline2d_free(interp);\n      GSL_ERROR_NULL(\"failed to allocate space for data arrays\", GSL_ENOMEM);\n    }\n\n  interp->xarr = array_mem;\n  interp->yarr = array_mem + xsize;\n  interp->zarr = array_mem + xsize + ysize;\n\n  return interp;\n} /* gsl_spline2d_alloc() */\n\nint\ngsl_spline2d_init(gsl_spline2d * interp, const double xarr[],\n                  const double yarr[], const double zarr[],\n                  size_t xsize, size_t ysize)\n{\n  int status = gsl_interp2d_init(&(interp->interp_object), xarr, yarr, zarr, xsize, ysize);\n\n  memcpy(interp->xarr, xarr, xsize * sizeof(double));\n  memcpy(interp->yarr, yarr, ysize * sizeof(double));\n  memcpy(interp->zarr, zarr, xsize * ysize * sizeof(double));\n\n  return status;\n} /* gsl_spline2d_init() */\n\nvoid\ngsl_spline2d_free(gsl_spline2d * interp)\n{\n  RETURN_IF_NULL(interp);\n\n  if (interp->interp_object.type->free)\n    interp->interp_object.type->free(interp->interp_object.state);\n\n  /*\n   * interp->xarr points to the beginning of one contiguous block of memory\n   * that holds interp->xarr, interp->yarr, and interp->zarr. So it all gets\n   * freed with one call. cf. gsl_spline2d_alloc() implementation\n   */\n  if (interp->xarr)\n    free(interp->xarr);\n\n  free(interp);\n} /* gsl_spline2d_free() */\n\ndouble\ngsl_spline2d_eval(const gsl_spline2d * interp, const double x,\n                  const double y, gsl_interp_accel * xa, gsl_interp_accel * ya)\n{\n  return gsl_interp2d_eval(&(interp->interp_object), interp->xarr, interp->yarr,\n                           interp->zarr, x, y, xa, ya);\n}\n\nint\ngsl_spline2d_eval_e(const gsl_spline2d * interp, const double x,\n                    const double y, gsl_interp_accel * xa, gsl_interp_accel * ya,\n                    double * z)\n{\n  return gsl_interp2d_eval_e(&(interp->interp_object), interp->xarr, interp->yarr,\n                             interp->zarr, x, y, xa, ya, z);\n}\n\ndouble\ngsl_spline2d_eval_extrap(const gsl_spline2d * interp, const double x,\n                         const double y, gsl_interp_accel * xa, gsl_interp_accel * ya)\n{\n  return gsl_interp2d_eval_extrap(&(interp->interp_object), interp->xarr, interp->yarr,\n                                  interp->zarr, x, y, xa, ya);\n}\n\nint\ngsl_spline2d_eval_extrap_e(const gsl_spline2d * interp, const double x,\n                           const double y, gsl_interp_accel * xa, gsl_interp_accel * ya,\n                           double * z)\n{\n  return gsl_interp2d_eval_extrap_e(&(interp->interp_object), interp->xarr, interp->yarr,\n                                    interp->zarr, x, y, xa, ya, z);\n}\n\ndouble\ngsl_spline2d_eval_deriv_x(const gsl_spline2d * interp, const double x,\n                          const double y, gsl_interp_accel * xa, gsl_interp_accel * ya)\n{\n  return gsl_interp2d_eval_deriv_x(&(interp->interp_object), interp->xarr, interp->yarr,\n                                   interp->zarr, x, y, xa, ya);\n}\n\nint\ngsl_spline2d_eval_deriv_x_e(const gsl_spline2d * interp, const double x,\n                            const double y, gsl_interp_accel * xa, gsl_interp_accel * ya,\n                            double * z)\n{\n  return gsl_interp2d_eval_deriv_x_e(&(interp->interp_object), interp->xarr, interp->yarr,\n                                     interp->zarr, x, y, xa, ya, z);\n}\n\ndouble\ngsl_spline2d_eval_deriv_y(const gsl_spline2d * interp, const double x,\n                          const double y, gsl_interp_accel * xa, gsl_interp_accel * ya)\n{\n  return gsl_interp2d_eval_deriv_y(&(interp->interp_object), interp->xarr, interp->yarr,\n                                   interp->zarr, x, y, xa, ya);\n}\n\nint\ngsl_spline2d_eval_deriv_y_e(const gsl_spline2d * interp, const double x,\n                            const double y, gsl_interp_accel * xa, gsl_interp_accel * ya,\n                            double * z)\n{\n  return gsl_interp2d_eval_deriv_y_e(&(interp->interp_object), interp->xarr, interp->yarr,\n                                     interp->zarr, x, y, xa, ya, z);\n}\n\ndouble\ngsl_spline2d_eval_deriv_xx(const gsl_spline2d * interp, const double x,\n                           const double y, gsl_interp_accel * xa, gsl_interp_accel * ya)\n{\n  return gsl_interp2d_eval_deriv_xx(&(interp->interp_object), interp->xarr, interp->yarr,\n                                    interp->zarr, x, y, xa, ya);\n}\n\nint\ngsl_spline2d_eval_deriv_xx_e(const gsl_spline2d * interp, const double x,\n                             const double y, gsl_interp_accel * xa, gsl_interp_accel * ya,\n                             double * z)\n{\n  return gsl_interp2d_eval_deriv_xx_e(&(interp->interp_object), interp->xarr, interp->yarr,\n                                      interp->zarr, x, y, xa, ya, z);\n}\n\ndouble\ngsl_spline2d_eval_deriv_yy(const gsl_spline2d * interp, const double x,\n                           const double y, gsl_interp_accel * xa, gsl_interp_accel * ya)\n{\n  return gsl_interp2d_eval_deriv_yy(&(interp->interp_object), interp->xarr, interp->yarr,\n                                    interp->zarr, x, y, xa, ya);\n}\n\nint\ngsl_spline2d_eval_deriv_yy_e(const gsl_spline2d * interp, const double x,\n                             const double y, gsl_interp_accel * xa, gsl_interp_accel * ya,\n                             double * z)\n{\n  return gsl_interp2d_eval_deriv_yy_e(&(interp->interp_object), interp->xarr, interp->yarr,\n                                      interp->zarr, x, y, xa, ya, z);\n}\n\ndouble\ngsl_spline2d_eval_deriv_xy(const gsl_spline2d * interp, const double x,\n                           const double y, gsl_interp_accel * xa, gsl_interp_accel * ya)\n{\n  return gsl_interp2d_eval_deriv_xy(&(interp->interp_object), interp->xarr, interp->yarr,\n                                    interp->zarr, x, y, xa, ya);\n}\n\nint\ngsl_spline2d_eval_deriv_xy_e(const gsl_spline2d * interp, const double x,\n                             const double y, gsl_interp_accel * xa, gsl_interp_accel * ya,\n                             double * z)\n{\n  return gsl_interp2d_eval_deriv_xy_e(&(interp->interp_object), interp->xarr, interp->yarr,\n                                      interp->zarr, x, y, xa, ya, z);\n}\n\nsize_t\ngsl_spline2d_min_size(const gsl_spline2d * interp)\n{\n  return gsl_interp2d_min_size(&(interp->interp_object));\n}\n\nconst char *\ngsl_spline2d_name(const gsl_spline2d * interp)\n{\n  return gsl_interp2d_name(&(interp->interp_object));\n}\n\nint\ngsl_spline2d_set(const gsl_spline2d * interp, double zarr[],\n                 const size_t i, const size_t j, const double z)\n{\n  return gsl_interp2d_set(&(interp->interp_object), zarr, i, j, z);\n} /* gsl_spline2d_set() */\n\ndouble\ngsl_spline2d_get(const gsl_spline2d * interp, const double zarr[],\n                 const size_t i, const size_t j)\n{\n  return gsl_interp2d_get(&(interp->interp_object), zarr, i, j);\n} /* gsl_spline2d_get() */\n", "meta": {"hexsha": "9d8f2d0e5082858be95972518e0f2ea3fbd63b18", "size": 9079, "ext": "c", "lang": "C", "max_stars_repo_path": "thirdparty/gsl-2.7/interpolation/spline2d.c", "max_stars_repo_name": "igormcoelho/optstats", "max_stars_repo_head_hexsha": "6d95cf06fbb96b1cc047fa570690c6eb3d21ece4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "thirdparty/gsl-2.7/interpolation/spline2d.c", "max_issues_repo_name": "igormcoelho/optstats", "max_issues_repo_head_hexsha": "6d95cf06fbb96b1cc047fa570690c6eb3d21ece4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "thirdparty/gsl-2.7/interpolation/spline2d.c", "max_forks_repo_name": "igormcoelho/optstats", "max_forks_repo_head_hexsha": "6d95cf06fbb96b1cc047fa570690c6eb3d21ece4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.0540540541, "max_line_length": 91, "alphanum_fraction": 0.6389470206, "num_tokens": 2376, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.43782349911420193, "lm_q2_score": 0.045352577167234585, "lm_q1q2_score": 0.019856424029205507}}
{"text": "#include \"readArray_MPI.h\"\n#include \"../include/paralleltt.h\"\n\n#include <mpi.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <lapacke.h>\n#include <time.h>\n#include <math.h>\n\nvoid* p_hilbert_init(int d, int* n){\n    p_hilbert* parameters = (p_hilbert*) malloc(sizeof(p_hilbert));\n    parameters->d = d;\n    parameters->n = (int*) malloc(d*sizeof(int));\n    for (int ii = 0; ii < d; ++ii){\n        parameters->n[ii] = n[ii];\n    }\n    parameters->n_stream = (int*) calloc(d, sizeof(int));\n    parameters->n_prod = (long*) malloc(d * sizeof(long));\n    return (void*) parameters;\n}\n\n\nvoid p_hilbert_free(void* parameters){\n    p_hilbert* p_casted = (p_hilbert*) parameters;\n    free(p_casted->n); p_casted->n = NULL;\n    free(p_casted->n_stream); p_casted->n_stream = NULL;\n    free(p_casted->n_prod); p_casted->n_prod = NULL;\n    free(p_casted);\n}\n\nvoid f_hilbert(double* restrict X, int* ind1, int* ind2, const void* parameters)\n{\n    p_hilbert* p_casted = (p_hilbert*) parameters;\n    int d = p_casted->d;\n    int* n = p_casted->n;\n    int* n_stream = p_casted->n_stream;\n    long* n_prod = p_casted->n_prod;\n\n\n    long N_stream = 1;\n    for (int ii = 0; ii < d; ++ii){\n        n_stream[ii] = ind2[ii] - ind1[ii];\n        N_stream = N_stream*n_stream[ii];\n    }\n\n    n_prod[0] = 1;\n    for (int ii = 1; ii < d; ++ii){\n        n_prod[ii] = (long) n_prod[ii-1] * n_stream[ii-1];\n    }\n\n    int bias = 1;\n    for (int jj = 0; jj < d; ++jj){\n        bias = bias + ind1[jj];\n    }\n\n    for (long ii = 0; ii < N_stream; ++ii){\n        int xinv = bias;\n\t\tlong tmp = ii;\n\t\tfor (int jj = d-1; jj >= 0; jj--){\n\t\t\txinv += tmp/n_prod[jj];\n\t\t\ttmp = tmp % n_prod[jj];\n\t\t}\n\n        X[ii] = (double) 1/xinv;\n    }\n}\n\nvoid* p_gaussian_bumps_init(int d, int* n, int M, double gamma, double* region, double* centers)\n{\n    p_gaussian_bumps* parameters = (p_gaussian_bumps*) malloc(sizeof(p_gaussian_bumps));\n    parameters->d = d;\n    parameters->n = (int*) calloc(d, sizeof(int));\n    for (int ii = 0; ii < d; ++ii){\n        parameters->n[ii] = n[ii];\n    }\n\n    parameters->M = M;\n    parameters->gamma = gamma;\n\n    parameters->region = (double*) calloc(2*d, sizeof(double));\n    for (int ii = 0; ii < 2*d; ++ii){\n        parameters->region[ii] = region[ii];\n    }\n    parameters->centers = (double*) calloc(d*M, sizeof(double));\n    for (int ii = 0; ii < d*M; ++ii){\n        parameters->centers[ii] = centers[ii];\n    }\n\n//    parameters->ten_ind_ii = (int*) calloc(d, sizeof(int));\n    parameters->x_ii = (double*) calloc(d, sizeof(double));\n    parameters->n_stream = (int*) calloc(d, sizeof(double));\n    parameters->n_prod = (long*) calloc(d, sizeof(long));\n\n    return (void*) parameters;\n}\n\nvoid* unit_random_p_gaussian_bumps_init(int d, int* n, int M, double gamma, int seed)\n{\n    p_gaussian_bumps* parameters = (p_gaussian_bumps*) malloc(sizeof(p_gaussian_bumps));\n    parameters->d = d;\n    parameters->n = (int*) calloc(d, sizeof(int));\n    for (int ii = 0; ii < d; ++ii){\n        parameters->n[ii] = n[ii];\n    }\n\n    parameters->M = M;\n    parameters->gamma = gamma;\n\n    parameters->region = (double*) calloc(2*d, sizeof(double));\n    for (int ii = 0; ii < d; ++ii){\n        parameters->region[2*ii] = -1.0;\n        parameters->region[2*ii+1] = 1.0;\n    }\n\n    parameters->centers = (double*) calloc(d*M, sizeof(double));\n    srand(seed);\n    int r1 = rand()%4096, r2 = rand()%4096, r3 = rand()%4096, r4 = rand()%4096;\n    int iseed[4] = {r1, r2, r3, r4+(r4%2 == 0?1:0)};\n    LAPACKE_dlarnv(2, iseed, d*M, parameters->centers);\n\n    parameters->x_ii = (double*) calloc(d, sizeof(double));\n    parameters->n_stream = (int*) calloc(d, sizeof(double));\n    parameters->n_prod = (long*) calloc(d, sizeof(long));\n\n    return (void*) parameters;\n}\n\nvoid p_gaussian_bumps_free(void* parameters)\n{\n    p_gaussian_bumps* p_casted = (p_gaussian_bumps*) parameters;\n\n    free(p_casted->n);          p_casted->n = NULL;\n    free(p_casted->region);     p_casted->region = NULL;\n    free(p_casted->centers);    p_casted->centers = NULL;\n    free(p_casted->x_ii);       p_casted->x_ii = NULL;\n    free(p_casted->n_stream);   p_casted->n_stream = NULL;\n    free(p_casted->n_prod);     p_casted->n_prod = NULL;\n    free(p_casted);\n}\n\nvoid f_gaussian_bumps(double* restrict X, int* ind1, int* ind2, const void* parameters)\n{\n    p_gaussian_bumps* p_casted = (p_gaussian_bumps*) parameters;\n    int d = p_casted->d;\n    int* n = p_casted->n;\n    int M = p_casted->M;\n    double gamma = p_casted->gamma;\n    double* region = p_casted->region;\n    double* centers = p_casted->centers;\n    double* x_ii = p_casted->x_ii;\n    int* n_stream = p_casted->n_stream;\n    long* n_prod = p_casted->n_prod;\n\n    long N_stream = 1;\n    for (int ii = 0; ii < d; ++ii){\n        n_stream[ii] = ind2[ii] - ind1[ii];\n        N_stream = N_stream*n_stream[ii];\n    }\n\n    n_prod[0] = 1;\n    for (int ii = 1; ii < d; ++ii){\n        n_prod[ii] = (long) n_prod[ii-1] * n_stream[ii-1];\n    }\n\n    for (long ii = 0; ii < N_stream; ++ii){\n        long tmp = ii;\n        for (int jj = d-1; jj >= 0; jj--){\n            int ind_jj = tmp/n_prod[jj];\n            x_ii[jj] = region[2*jj] + (ind_jj + ind1[jj]) * (region[2*jj + 1] - region[2*jj]) / (n[jj] - 1);\n\t\t\ttmp = tmp % n_prod[jj];\n\t\t}\n\n        X[ii] = 0;\n        for (int kk = 0; kk < M; ++kk){\n            double exponent = 0;\n            for (int jj = 0; jj < d; ++jj){\n                exponent += (x_ii[jj] - centers[kk*d + jj]) * (x_ii[jj] - centers[kk*d + jj]);\n            }\n            X[ii] += exp(-gamma * exponent);\n        }\n    }\n}\n\nvoid* p_arithmetic_init(int d, int* n)\n{\n    p_arithmetic* parameters = (p_arithmetic*) malloc(sizeof(p_arithmetic));\n    parameters->d = d;\n    parameters->n = (int*) malloc(d*sizeof(int));\n    for (int ii = 0; ii < d; ++ii){\n        parameters->n[ii] = n[ii];\n    }\n    return (void*) parameters;\n}\n\nvoid p_arithmetic_free(void* parameters)\n{\n    p_arithmetic* p_casted = (p_arithmetic*) parameters;\n    free(p_casted->n); p_casted->n = NULL;\n    free(p_casted);\n}\n\n\nvoid f_arithmetic(double* restrict X, int* ind1, int* ind2, const void* parameters)\n{\n    p_arithmetic* p_casted = (p_arithmetic*) parameters;\n    int d = p_casted->d;\n    int* n = p_casted->n;\n\n    int* n_stream = (int*) calloc(d, sizeof(int));\n    long N_stream = 1;\n    for (int ii = 0; ii < d; ++ii){\n        n_stream[ii] = ind2[ii] - ind1[ii];\n        N_stream = N_stream*n_stream[ii];\n    }\n\n    int* ind_ii = (int*) calloc(d, sizeof(int));\n    for (int ii = 0; ii < N_stream; ++ii){\n        to_tensor_ind(ind_ii, ii, n_stream, d);\n        for (int jj = 0; jj < d; ++jj){\n            ind_ii[jj] = ind_ii[jj] + ind1[jj];\n        }\n        X[ii] = 1 + to_vec_ind(ind_ii, n, d);\n//        X[ii] = X[ii] + (0.000000001 / X[ii]);\n    }\n\n    free(n_stream);\n    free(ind_ii);\n}\n\n\n\nvoid* p_tt_init(tensor_train* tt)\n{\n    p_tt* parameters = (p_tt*) malloc(sizeof(p_tt));\n    parameters->tt = tt;\n    return (void*) parameters;\n}\n\n// Doesn't actually free the tensor train. You gotta do that yourself\nvoid p_tt_free(void* parameters)\n{\n    p_tt* p_casted = (p_tt*) parameters;\n    p_casted->tt = NULL;\n    free(p_casted);\n}\n\nvoid f_tt(double* restrict X, int* ind1, int* ind2, const void* parameters)\n{\n    p_tt* p_casted = (p_tt*) parameters;\n    tensor_train* tt = p_casted->tt;\n    int d = tt->d;\n    int* n = tt->n;\n    int* r = tt->r;\n\n    matrix_tt** train_submats = (matrix_tt**) calloc(d, sizeof(matrix_tt*));\n    for (int ii = 0; ii < d; ++ii){\n        matrix_tt* train_mat_ii = matrix_tt_wrap(r[ii]*n[ii], r[ii+1], tt->trains[ii]);\n        train_submats[ii] = submatrix(train_mat_ii, ind1[ii]*r[ii], ind2[ii]*r[ii], 0, r[ii+1]);\n        free(train_mat_ii);\n    }\n\n    matrix_tt* mult = submatrix_copy(train_submats[d-1]);\n    matrix_tt_reshape(r[d-1], ind2[d-1] - ind1[d-1], mult);\n\n\n    for (int jj = d-2; jj >= 1; --jj){\n        matrix_tt* new_mult = matrix_tt_init(train_submats[jj]->m, mult->n);\n        matrix_tt_dgemm(train_submats[jj], mult, new_mult, 1.0, 0.0);\n        matrix_tt_reshape(r[jj], (new_mult->n) * (new_mult->m) / r[jj], new_mult);\n        matrix_tt_free(mult); mult = new_mult;\n    }\n\n    long X_m = 1;\n    for (int ii = 1; ii < d; ++ii){\n        X_m = X_m*(ind2[ii] - ind1[ii]);\n    }\n\n    matrix_tt* X_mat = matrix_tt_wrap(ind2[0] - ind1[0], X_m, X);\n    matrix_tt_dgemm(train_submats[0], mult, X_mat, 1.0, 0.0);\n\n    for (int ii = 0; ii < d; ++ii){\n        free(train_submats[ii]); train_submats[ii] = NULL;\n    }\n\n    free(train_submats); train_submats = NULL;\n    matrix_tt_free(mult);   mult = NULL;\n    free(X_mat);         X_mat = NULL;\n}\n\n\ndouble tt_error(tensor_train* tt, MPI_tensor* ten)\n{\n    MPI_Comm comm = ten->comm;\n    tt_broadcast(comm, tt);\n\n\n    void* parameters_tt = p_tt_init(tt);\n    MPI_tensor* ten_tt = MPI_tensor_init(ten->d, ten->n, ten->nps, ten->comm, &f_tt, parameters_tt);\n    int rank = ten_tt->rank;\n    int* schedule_rank = ten_tt->schedule[rank];\n\n    double true_norm_squared = 0;\n    double diff_norm_squared = 0;\n\n    flattening_info* fi = flattening_info_init(ten, 0, 1, 0);\n    for (int ii = 0; ii < ten->n_schedule; ++ii){\n        int block = schedule_rank[ii];\n\n        if (block != -1){\n            stream(ten, block);\n            stream(ten_tt, block);\n\n            flattening_info_update(fi, ten, block);\n            long N = fi->t_N;\n\n            for (int jj = 0; jj < N; ++jj){\n                ten_tt->X[jj] = ten_tt->X[jj] - ten->X[jj];\n            }\n\n            matrix_tt* mat_true = matrix_tt_wrap(N, 1, ten->X);\n            double tmp = frobenius_norm(mat_true);\n            true_norm_squared = true_norm_squared + tmp*tmp;\n\n            matrix_tt* mat_diff = matrix_tt_wrap(N, 1, ten_tt->X);\n            tmp = frobenius_norm(mat_diff);\n            diff_norm_squared = diff_norm_squared + tmp*tmp;\n//            printf(\"r%d ii%d true_norm_squared = %e, diff_norm_squared = %e\\n\", rank, ii, true_norm_squared, diff_norm_squared);\n\n            free(mat_true); mat_true = NULL;\n            free(mat_diff); mat_diff = NULL;\n        }\n    }\n    int head = 0;\n\n    double true_norm_reduced;\n    double diff_norm_reduced;\n    MPI_Reduce(&true_norm_squared, &true_norm_reduced, 1, MPI_DOUBLE, MPI_SUM, head, comm);\n    true_norm_reduced = sqrt(true_norm_reduced);\n\n    MPI_Reduce(&diff_norm_squared, &diff_norm_reduced, 1, MPI_DOUBLE, MPI_SUM, head, comm);\n    diff_norm_reduced = sqrt(diff_norm_reduced);\n\n    double rel_err = diff_norm_reduced/true_norm_reduced;\n\n\n\n    p_tt_free(parameters_tt); parameters_tt = NULL;\n    flattening_info_free(fi); fi = NULL;\n    MPI_tensor_free(ten_tt); ten_tt = NULL;\n\n    return rel_err;\n}", "meta": {"hexsha": "1d913068b63aaa2461d80cc31daa4883dcee991e", "size": 10623, "ext": "c", "lang": "C", "max_stars_repo_path": "test/readArray_MPI.c", "max_stars_repo_name": "SidShi/Parallel_TT_sketching", "max_stars_repo_head_hexsha": "e2c00c289d75d3ac1df32ed2b95af579a517fcbf", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "test/readArray_MPI.c", "max_issues_repo_name": "SidShi/Parallel_TT_sketching", "max_issues_repo_head_hexsha": "e2c00c289d75d3ac1df32ed2b95af579a517fcbf", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "test/readArray_MPI.c", "max_forks_repo_name": "SidShi/Parallel_TT_sketching", "max_forks_repo_head_hexsha": "e2c00c289d75d3ac1df32ed2b95af579a517fcbf", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.0934844193, "max_line_length": 130, "alphanum_fraction": 0.5875929587, "num_tokens": 3350, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.44167300566462553, "lm_q2_score": 0.04468087345289264, "lm_q1q2_score": 0.01973433567365987}}
{"text": "/*\n * Copyright (c) 1997-1999 Massachusetts Institute of Technology\n *\n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or\n * (at your option) any later version.\n *\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n *\n */\n\n#include <stdlib.h>\n#include <fftw.h>\n\n#include \"mex.h\"\n\n/**************************************************************************/\n\n/* MEX programs need to use special memory allocation routines,\n   so we use the hooks provided by FFTW to ensure that MEX\n   allocation is used: */\n\nvoid *fftw_mex_malloc_hook(size_t n)\n{\n     void *buf;\n\n     buf = mxMalloc(n);\n\n     /* Call this routine so that we can retain allocations and\n\tdata between calls to the FFTW MEX: */\n     mexMakeMemoryPersistent(buf);\n\n     return buf;\n}\n\nvoid fftw_mex_free_hook(void *buf)\n{\n     mxFree(buf);\n}\n\nvoid install_fftw_hooks(void)\n{\n     fftw_malloc_hook = fftw_mex_malloc_hook;\n     fftw_free_hook = fftw_mex_free_hook;\n}\n\n/**************************************************************************/\n\n/* We retain various information between calls to the FFTW MEX in\n   order to maximize performance.  (Reusing plans, data, and\n   allocated blocks where possible.)  This information is referenced\n   by the following variables, which are initialized in the function\n   initialize_fftw_mex_data. */\n\n#define MAX_RANK 10\n\nint first_call = 1; /* 1 if this is the first call to the FFTW MEX,\n\t\t       and nothing has been initialized yet.  0 otherwise. */\n\n/* Keep track of the array dimensions that stored data (below) is for.\n   When these dimensions changed, we have to recompute the plans,\n   work arrays, etc. */\nint  cur_rank = 0,         /* rank of the array */\n     cur_dims[MAX_RANK],   /* dimensions */\n     cur_N;                /* product of the dimensions */\n\n/* Work arrays.  MATLAB stores complex numbers as separate real/imag.\n   arrays, so we have to translate into our format before the FFT.\n   In case allocation is slow, we retain these work arrays between\n   calls so that they can be reused. */\nfftw_complex *input_work = 0, *output_work = 0;\n\n/* The number of floating point operations required for the FFT.\n   (Starting with FFTW 1.3, an exact count is computed by the planner.)\n   This is used to update MATLAB's flops count. */\nint fftw_mex_flops = 0, ifftw_mex_flops = 0;\n\n/* Plans.  These are computed once and then reused as long as the\n   dimensions of the array don't changed.  At any point in time,\n   at most two plans are cached: a forward and backwards plan,\n   either for one- or multi-dimensional transforms. */\nfftw_plan p = 0, ip = 0;\nfftwnd_plan pnd = 0, ipnd = 0;\n\n/**************************************************************************/\n\nint compute_fftw_mex_flops(fftw_direction dir)\n{\n#ifdef FFTW_HAS_COUNT_PLAN_OPS /* this feature will be in FFTW 1.3 */\n     fftw_op_count ops;\n\n     if (dir == FFTW_FORWARD) {\n\t  if (cur_rank == 1)\n\t       fftw_count_plan_ops(p,&ops);\n\t  else\n\t       fftwnd_count_plan_ops(pnd,&ops);\n     }\n     else {\n\t  if (cur_rank == 1)\n\t       fftw_count_plan_ops(ip,&ops);\n\t  else\n\t       fftwnd_count_plan_ops(ipnd,&ops);\n     }\n\n     return (ops.fp_additions + ops.fp_multiplications);\n#else\n     return 0;\n#endif\n}\n\n/**************************************************************************/\n\n/* The following functions destroy and/or initialize the data that\n   FFTW-MEX caches between calls. */\n\nvoid destroy_fftw_mex_data(void) {\n     if (output_work != input_work)\n\t  fftw_free(output_work);\n     if (input_work)\n\t  fftw_free(input_work);\n     if (p)\n\t  fftw_destroy_plan(p);\n     if (pnd)\n\t  fftwnd_destroy_plan(pnd);\n     if (ip)\n\t  fftw_destroy_plan(ip);\n     if (ipnd)\n\t  fftwnd_destroy_plan(ipnd);\n\n     cur_rank = 0;\n     input_work = output_work = 0;\n     ip = p = 0;\n     ipnd = pnd = 0;\n}\n\n/* This function is called when MATLAB exits or the MEX file is\n   cleared, in which case we want to dispose of all data and\n   free any allocated blocks. */\n\nvoid fftw_mex_exit_function(void)\n{\n     if (!first_call) {\n\t  destroy_fftw_mex_data();\n\t  fftw_forget_wisdom();\n\t  first_call = 1;\n     }\n}\n\n#define MAGIC(x) #x\n#define STRINGIZE(x) MAGIC(x)\n\n/* Initialize the cached data each time the MEX file is called.  First,\n   we check if we have previously computed plans and data for these\n   array dimensions.  Only if the dimensions have changed since the\n   last call must we recompute the plans, etc. */\n\nvoid initialize_fftw_mex_data(int rank, const int *dims, fftw_direction dir)\n{\n     int new_plan = 0;\n\n     if (first_call) {\n\t  /* The following things need only be done once: */\n\t  install_fftw_hooks();\n\t  mexAtExit(fftw_mex_exit_function);\n\t  first_call = 0;\n     }\n\n     if (rank == 1) {\n\t  if (cur_rank != 1 || cur_dims[0] != dims[0]) {\n\t       destroy_fftw_mex_data();\n\n\t       cur_rank = 1;\n\t       cur_dims[0] = cur_N = dims[0];\n\t       \n\t       input_work = (fftw_complex*)fftw_malloc(sizeof(fftw_complex) * cur_N);\n\t       output_work = (fftw_complex*)fftw_malloc(sizeof(fftw_complex) * cur_N);\n\t       \n\t       new_plan = 1;\n\t  }\n\t  else if (dir == FFTW_FORWARD && !p ||\n\t\t   dir == FFTW_BACKWARD && !ip)\n\t       new_plan = 1;\n\n\t  if (new_plan) {\n\t       if (dir == FFTW_FORWARD) {\n\t\t    p = fftw_create_plan(cur_N,dir,\n\t\t\t\t\t FFTW_MEASURE | FFTW_USE_WISDOM);\n\n\t\t    fftw_mex_flops = compute_fftw_mex_flops(dir);\n\t       }\n\t       else {\n\t\t    ip = fftw_create_plan(cur_N,dir,\n\t\t\t\t\t  FFTW_MEASURE | FFTW_USE_WISDOM);\n\n\t\t    ifftw_mex_flops = compute_fftw_mex_flops(dir);\n\t       }\n\t  }\n     }\n     else {\n\t  int same_dims = 1, dim;\n\n\t  if (cur_rank == rank)\n\t       for (dim = 0; dim < rank && same_dims; ++dim)\n\t\t    same_dims = (cur_dims[dim] == dims[rank-1-dim]);\n\t  else\n\t       same_dims = 0;\n\n\t  if (!same_dims) {\n\t       if (rank > MAX_RANK)\n\t\t    mexErrMsgTxt(\"Sorry, dimensionality > \" STRINGIZE(MAX_RANK)\n\t\t\t\t \" is not supported.\");\n\n\t       destroy_fftw_mex_data();\n\n\t       cur_rank = rank;\n\n\t       cur_N = 1;\n\t       for (dim = 0; dim < rank; ++dim)\n\t\t    cur_N *= (cur_dims[dim] = dims[rank-1-dim]);\n\n\t       input_work = (fftw_complex*)fftw_malloc(sizeof(fftw_complex) * cur_N);\n\t       output_work = input_work;\n\n\t       new_plan = 1;\n\t  }\n          else if (dir == FFTW_FORWARD && !pnd ||\n                   dir == FFTW_BACKWARD && !ipnd)\n               new_plan = 1;\n\n\t  if (new_plan) {\n\t       if (dir == FFTW_FORWARD) {\n\t\t    pnd = fftwnd_create_plan(rank,cur_dims,dir,\n\t\t\t\t\t     FFTW_IN_PLACE | \n\t\t\t\t\t     FFTW_MEASURE | FFTW_USE_WISDOM);\n\t\t    \n\t\t    fftw_mex_flops = compute_fftw_mex_flops(dir);\n\t       }\n\t       else {\n\t\t    ipnd = fftwnd_create_plan(rank,cur_dims,dir,\n\t\t\t\t\t      FFTW_IN_PLACE | \n\t\t\t\t\t      FFTW_MEASURE | FFTW_USE_WISDOM);\n\t\t    \n\t\t    ifftw_mex_flops = compute_fftw_mex_flops(dir);\n\t       }\n\t  }\n\n     }\n}\n\n/**************************************************************************/\n\n/* MATLAB stores complex numbers as separate arrays for real and\n   imaginary parts.  The following functions take the data in\n   this format and pack it into a fftw_complex work array, or\n   unpack it, respectively. The globals input_work and output_work\n   are used as the arrays to pack to/unpack from.*/\n\nvoid pack_input_work(double *input_re, double *input_im)\n{\n     int i;\n\n     if (input_im)\n\t  for (i = 0; i < cur_N; ++i) {\n\t       c_re(input_work[i]) = input_re[i];\n\t       c_im(input_work[i]) = input_im[i];\n\t  }\n     else\n\t  for (i = 0; i < cur_N; ++i) {\n\t       c_re(input_work[i]) = input_re[i];\n\t       c_im(input_work[i]) = 0.0;\n\t  }\n}\n\nvoid unpack_output_work(double *output_re, double *output_im)\n{\n     int i;\n\n     for (i = 0; i < cur_N; ++i) {\n\t  output_re[i] = c_re(output_work[i]);\n\t  output_im[i] = c_im(output_work[i]);\n     }\n}\n\n/**************************************************************************/\n\n/* The following function is called by MATLAB when the FFTW\n   MEX is invoked from within the program.\n\n   The rhs parameters are the list of arrays on the right-hand-side\n   (rhs) of the MATLAB command--the arguments to FFTW.  The lhs\n   parameters are the list of arrays on the left-hand-side (lhs) of\n   the MATLAB command--these are what the output(s) of FFTW are\n   assigned to.\n\n   The syntax for the FFTW call in MATLAB is fftw(array,sign),\n   as described in fftw.m  */\n\nvoid mexFunction(int nlhs, mxArray *plhs[],\n\t\t int nrhs, const mxArray *prhs[])\n{\n     int rank;\n     const int *dims;\n     int m, n;  /* Array is m x n, C-ordered */\n     fftw_direction dir;\n\n     if (nrhs != 2)\n\t  mexErrMsgTxt(\"Two input arguments are expected.\");\n\n     if (!mxIsDouble(prhs[0]))\n\t  mexErrMsgTxt(\"First input must be a double precision matrix.\");\n     if (mxIsSparse(prhs[0]))\n\t  mexErrMsgTxt(\"Sorry, sparse matrices are not currently supported.\");\n\n     if (mxGetM(prhs[1]) * mxGetN(prhs[1]) != 1)\n\t  mexErrMsgTxt(\"Second input must be a scalar (+/- 1).\");\n\n     if (mxGetScalar(prhs[1]) > 0.0)\n\t  dir = FFTW_BACKWARD;\n     else\n\t  dir = FFTW_FORWARD;\n\n     if ((rank = mxGetNumberOfDimensions(prhs[0])) == 2) {\n\t  int dims2[2];\n\t  m = mxGetM(prhs[0]);\n\t  n = mxGetN(prhs[0]);\n\t  if (m == 1 || n == 1) {\n\t       dims2[0] = m * n;\n\t       initialize_fftw_mex_data(1,dims2,dir);\n\t  }\n\t  else {\n\t       dims2[0] = m;\n\t       dims2[1] = n;\n\t       initialize_fftw_mex_data(2,dims2,dir);\n\t  }\n     }\n     else\n\t  initialize_fftw_mex_data(rank,dims = mxGetDimensions(prhs[0]),dir);\n\n     pack_input_work(mxGetPr(prhs[0]),mxGetPi(prhs[0]));\n     \n     if (dir == FFTW_FORWARD) {\n\t  if (cur_rank == 1)\n\t       fftw(p,1, input_work,1,0, output_work,1,0);\n\t  else\n\t       fftwnd(pnd,1, input_work,1,0, 0,0,0);\n\t  \n\t  mexAddFlops(fftw_mex_flops);\n     }\n     else {\n\t  if (cur_rank == 1)\n\t       fftw(ip,1, input_work,1,0, output_work,1,0);\n\t  else\n\t       fftwnd(ipnd,1, input_work,1,0, 0,0,0);\n\t  \n\t  mexAddFlops(ifftw_mex_flops);\n     }\n\n     /* Create a matrix for the return argument. */\n     if (cur_rank <= 2)\n\t  plhs[0] = mxCreateDoubleMatrix(m, n, mxCOMPLEX);\n     else\n\t  plhs[0] = mxCreateNumericArray(rank,dims,\n\t\t\t\t\t mxDOUBLE_CLASS,mxCOMPLEX);\n\n     unpack_output_work(mxGetPr(plhs[0]),mxGetPi(plhs[0]));\n}\n", "meta": {"hexsha": "df86c33e40e5e25f118765a4a791922f9b3642c9", "size": 10647, "ext": "c", "lang": "C", "max_stars_repo_path": "original/lib/fftw-2.1.3/matlab/fftw.c", "max_stars_repo_name": "albertsgrc/ftdock-opt", "max_stars_repo_head_hexsha": "3361d1f18bf529958b78231fdcf139b1c1c1f232", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "original/lib/fftw-2.1.3/matlab/fftw.c", "max_issues_repo_name": "albertsgrc/ftdock-opt", "max_issues_repo_head_hexsha": "3361d1f18bf529958b78231fdcf139b1c1c1f232", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "original/lib/fftw-2.1.3/matlab/fftw.c", "max_forks_repo_name": "albertsgrc/ftdock-opt", "max_forks_repo_head_hexsha": "3361d1f18bf529958b78231fdcf139b1c1c1f232", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.392, "max_line_length": 79, "alphanum_fraction": 0.6144453837, "num_tokens": 2873, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.31405054499180746, "lm_q2_score": 0.06278921517368556, "lm_q1q2_score": 0.019718987244903816}}
{"text": "/* ndlinear.c\n * \n * Copyright (C) 2006, 2007 Patrick Alken\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include <stdlib.h>\n\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_matrix.h>\n#include <gsl/gsl_vector.h>\n#include <gsl/gsl_multifit.h>\n#include <gsl/gsl_blas.h>\n\n#include \"gsl_multifit_ndlinear.h\"\n\nstatic int ndlinear_construct_row(const gsl_vector *d, gsl_vector *x,\n                                  gsl_multifit_ndlinear_workspace *w);\n\n/*\ngsl_multifit_ndlinear_alloc()\n  Allocate a ndlinear workspace\n\nInputs: n_dim  - dimension of fit function\n        N      - number of terms in each sum; N[i] = N_i, 0 <= i < n_dim\n        u      - basis functions to call\n                 u[j] = u^{(j)}, 0 <= j < n_dim\n        params - parameters to pass to basis functions\n\nReturn: pointer to new workspace\n\nNotes: the supplied basis functions 'u[j]' must accept three\n       arguments:\n\nint uj(double x, double y[], void *params)\n\nand fill the y[] vector so that y[i] = u_{i}^{(j)}(x) (the ith\nbasis function for the jth parameter evaluated at x)\n*/\n\ngsl_multifit_ndlinear_workspace *\ngsl_multifit_ndlinear_alloc(size_t n_dim, size_t N[],\n                            int (**u)(double x, double y[], void *p),\n                            void *params)\n{\n  gsl_multifit_ndlinear_workspace *w;\n  size_t n_coeffs; /* total number of fit coefficients */\n  size_t i, idx;\n  size_t sum_N;\n\n  if (n_dim == 0)\n    {\n      GSL_ERROR_NULL(\"n_dim must be at least 1\", GSL_EINVAL);\n    }\n\n  w = calloc(1, sizeof(gsl_multifit_ndlinear_workspace));\n  if (!w)\n    {\n      GSL_ERROR_NULL(\"failed to allocate space for workspace\", GSL_ENOMEM);\n    }\n\n  w->N = calloc(n_dim, sizeof(size_t));\n  if (!w->N)\n    {\n      gsl_multifit_ndlinear_free(w);\n      GSL_ERROR_NULL(\"failed to allocate space for N vector\", GSL_ENOMEM);\n    }\n\n  n_coeffs = 1;\n  sum_N = 0;\n  for (i = 0; i < n_dim; ++i)\n    {\n      if (N[i] == 0)\n        {\n          gsl_multifit_ndlinear_free(w);\n          GSL_ERROR_NULL(\"one of the sums is empty\", GSL_EINVAL);\n        }\n\n      /* The total number of coefficients is: N_1 * N_2 * ... * N_n */\n      n_coeffs *= N[i];\n      w->N[i] = N[i];\n      sum_N += N[i];\n    }\n\n  w->n_dim = n_dim;\n  w->n_coeffs = n_coeffs;\n\n  w->work = gsl_vector_alloc(n_coeffs);\n  w->work2 = gsl_vector_alloc(sum_N);\n  if (!w->work || !w->work2)\n    {\n      gsl_multifit_ndlinear_free(w);\n      GSL_ERROR_NULL(\"failed to allocate space for basis vector\",\n                     GSL_ENOMEM);\n    }\n\n  w->v = calloc(n_dim, sizeof(gsl_vector_view));\n  if (!w->v)\n    {\n      gsl_multifit_ndlinear_free(w);\n      GSL_ERROR_NULL(\"failed to allocate space for basis vector\",\n                     GSL_ENOMEM);\n    }\n\n  w->u = calloc(n_dim, sizeof(int *));\n  if (!w->u)\n    {\n      gsl_multifit_ndlinear_free(w);\n      GSL_ERROR_NULL(\"failed to allocate space for basis functions\",\n                     GSL_ENOMEM);\n    }\n\n  idx = 0;\n  for (i = 0; i < n_dim; ++i)\n    {\n      w->v[i] = gsl_vector_subvector(w->work2, idx, N[i]);\n      idx += N[i];\n\n      w->u[i] = u[i];\n    }\n\n  w->params = params;\n\n  return (w);\n} /* gsl_multifit_ndlinear_alloc() */\n\n/*\ngsl_multifit_ndlinear_free()\n  Free workspace w\n*/\n\nvoid\ngsl_multifit_ndlinear_free(gsl_multifit_ndlinear_workspace *w)\n{\n  if (w->N)\n    free(w->N);\n\n  if (w->work)\n    gsl_vector_free(w->work);\n\n  if (w->work2)\n    gsl_vector_free(w->work2);\n\n  if (w->v)\n    free(w->v);\n\n  if (w->u)\n    free(w->u);\n\n  free(w);\n} /* gsl_multifit_ndlinear_free() */\n\n/*\ngsl_multifit_ndlinear_design()\n  This function constructs the coefficient design matrix 'X'\n\nInputs: vars  - independent variable vectors for matrix X\n                vars is a ndata-by-n_dim matrix where the ith row\n                specifies the n_dim independent variables for the\n                ith observation, so that\n                vars_{ij} = (x_i)_j, the jth element of the\n                ith input variable vector\n        X     - (output) design matrix (must be ndata-by-w->n_coeffs)\n        w     - workspace\n\nReturn: success or error\n*/\n\nint\ngsl_multifit_ndlinear_design(const gsl_matrix *vars, gsl_matrix *X,\n                             gsl_multifit_ndlinear_workspace *w)\n{\n  const size_t ndata = vars->size1;\n\n  if ((X->size1 != ndata) || (X->size2 != w->n_coeffs))\n    {\n      GSL_ERROR(\"X matrix has wrong dimensions\", GSL_EBADLEN);\n    }\n  else\n    {\n      size_t i; /* looping */\n      int s;\n\n      for (i = 0; i < ndata; ++i)\n        {\n          gsl_vector_const_view d = gsl_matrix_const_row(vars, i);\n          gsl_vector_view xv = gsl_matrix_row(X, i);\n\n          s = ndlinear_construct_row(&d.vector, &xv.vector, w);\n          if (s != GSL_SUCCESS)\n            return s;\n        }\n\n      return GSL_SUCCESS;\n    }\n} /* gsl_multifit_ndlinear_design() */\n\n/*\ngsl_multifit_ndlinear_est()\n  Compute the model function at a given data point with errors\n\nInputs: x     - data point (w->n_dim elements)\n        c     - coefficient vector\n        cov   - covariance matrix\n        y     - where to store fit function result\n        y_err - standard deviation of fit\n        w     - workspace\n\nReturn: success or error\n*/\n\nint\ngsl_multifit_ndlinear_est(const gsl_vector *x, const gsl_vector *c,\n                          const gsl_matrix *cov, double *y, double *y_err,\n                          gsl_multifit_ndlinear_workspace *w)\n{\n  if (c->size != w->n_coeffs)\n    {\n      GSL_ERROR(\"c vector has wrong size\", GSL_EBADLEN);\n    }\n  else\n    {\n      int s;\n\n      s = ndlinear_construct_row(x, w->work, w);\n      if (s != GSL_SUCCESS)\n        return s;\n\n      /*\n       * Now w->work contains the appropriate basis functions\n       * evaluated at the given point - compute the function value\n       */\n      s = gsl_multifit_linear_est(w->work, c, cov, y, y_err);\n\n      return s;\n    }\n} /* gsl_multifit_ndlinear_est() */\n\n/*\ngsl_multifit_ndlinear_calc()\n  Compute the model function at a given data point\n\nInputs: x - data point (w->n_dim elements)\n        c - coefficient vector\n        w - workspace\n\nReturn: model value\n*/\n\ndouble\ngsl_multifit_ndlinear_calc(const gsl_vector *x, const gsl_vector *c,\n                           gsl_multifit_ndlinear_workspace *w)\n{\n  if (c->size != w->n_coeffs)\n    {\n      GSL_ERROR_VAL(\"c vector has wrong size\", GSL_EBADLEN, 0.0);\n    }\n  else\n    {\n      double y;\n      int s;\n\n      s = ndlinear_construct_row(x, w->work, w);\n      if (s != GSL_SUCCESS)\n        {\n          GSL_ERROR_VAL(\"constructing matrix row failed\", s, 0.0);\n        }\n\n      gsl_blas_ddot(w->work, c, &y);\n\n      return y;\n    }\n} /* gsl_multifit_ndlinear_calc() */\n\n/*\ngsl_multifit_ndlinear_ncoeffs()\n  Return the total number of fit coefficients\n*/\n\nsize_t\ngsl_multifit_ndlinear_ncoeffs(gsl_multifit_ndlinear_workspace *w)\n{\n  return w->n_coeffs;\n} /* gsl_multifit_ndlinear_ncoeffs() */\n\n/******************************************\n *         INTERNAL ROUTINES              *\n ******************************************/\n\n/*\nndlinear_construct_row()\n\n  Compute a row of the design matrix X:\n\nX(:,j) = u_{r_0}^{(0)}(d_0) * u_{r_1)^{(1)}(d_1) * ... *\n         u_{r_{n-1}}^{(n-1)}(d_{n-1})\n\nwhere 'd' is the corresponding data vector for that row\n\nInputs: d - data vector of length w->n_dim\n        x - (output) where to store row of design matrix X\n        w - workspace\n\nReturn: success or error\n*/\n\nstatic int\nndlinear_construct_row(const gsl_vector *d, gsl_vector *x,\n                       gsl_multifit_ndlinear_workspace *w)\n{\n  size_t j;\n  int k, s;\n  size_t denom, rk;\n  double melement;\n\n  /* compute basis functions for this data point */\n  for (j = 0; j < w->n_dim; ++j)\n    {\n      s = w->u[j](gsl_vector_get(d, j), w->v[j].vector.data, w->params);\n\n      if (s != GSL_SUCCESS)\n        return s;\n    }\n\n  for (j = 0; j < w->n_coeffs; ++j)\n    {\n      /*\n       * The (:,j) element of the matrix X will be:\n       *\n       * X_{:,j} = u_{r_0}^{(0)}(d_0) *\n       *           u_{r_1)^{(1)}(d_1) *\n       *           ... *\n       *           u_{r_{n-1}}^{(n-1)}(d_{n-1})\n       *\n       * with the basis function indices r_k given by\n       *\n       * r_k = floor(j / Prod_{i=(k+1)..(n-1)} [ N_i ]) (mod N_k)\n       *\n       * In the case where N_i = N for all i,\n       *\n       * r_k = floor(j / N^{n - k - 1}) (mod N)\n       *\n       * n: dimension of fit function (w->n_dim)\n       * N_i: number of terms in sum i of fit function\n       */\n\n      /* calculate the r_k and the matrix element X_{:,j} */\n\n      denom = 1;\n      melement = 1.0;\n      for (k = (int)(w->n_dim - 1); k >= 0; --k)\n        {\n          rk = (j / denom) % w->N[k];\n          denom *= w->N[k];\n\n          melement *= gsl_vector_get(&(w->v[k]).vector, rk);\n        }\n\n      /* set the matrix element */\n      gsl_vector_set(x, j, melement);\n    }\n\n  return GSL_SUCCESS;\n} /* ndlinear_construct_row() */\n", "meta": {"hexsha": "82dcaf06878132a0964372d63d1720c47c9dca87", "size": 9487, "ext": "c", "lang": "C", "max_stars_repo_path": "src/BodyComponents/archive/ndlinear-1.0/src/ndlinear.c", "max_stars_repo_name": "rennhak/Keyposes", "max_stars_repo_head_hexsha": "e5ffe4c849b0894f27d58985b41ec8edd3432be1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2016-11-26T07:28:56.000Z", "max_stars_repo_stars_event_max_datetime": "2018-05-05T12:45:52.000Z", "max_issues_repo_path": "src/BodyComponents/archive/ndlinear-1.0/src/ndlinear.c", "max_issues_repo_name": "rennhak/Keyposes", "max_issues_repo_head_hexsha": "e5ffe4c849b0894f27d58985b41ec8edd3432be1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/BodyComponents/archive/ndlinear-1.0/src/ndlinear.c", "max_forks_repo_name": "rennhak/Keyposes", "max_forks_repo_head_hexsha": "e5ffe4c849b0894f27d58985b41ec8edd3432be1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.0978835979, "max_line_length": 81, "alphanum_fraction": 0.5836407716, "num_tokens": 2673, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.49609382947091946, "lm_q2_score": 0.03963884321354336, "lm_q1q2_score": 0.01966458552560409}}
{"text": "/*\n *  vbHmmGaussDiffusion.c\n *  Model-specific core functions for VB-HMM-GAUSS-DIFFUSION.\n *\n *  Created by OKAMOTO Kenji, SAKO Yasushi and RIKEN\n *  Copyright 2011-2016\n *  Cellular Informatics Laboratory, Advance Science Institute, RIKEN, Japan.\n *  All rights reserved.\n *\n *  Ver. 1.0.0\n *  Last modified on 2016.02.08\n */\n\n#include \"vbHmmGaussDiffusion.h\"\n#include <gsl/gsl_sf_gamma.h>\n#include <gsl/gsl_sf_psi.h>\n#include <string.h>\n#include \"rand.h\"\n\n#ifdef _OPENMP\n#include \"omp.h\"\n#endif\n\n#define  MAX(a,b)  ((a)>(b)?(a):(b))\n#define  MIN(a,b)  ((a)<(b)?(a):(b))\n\nstatic int isGlobalAnalysis = 0;\n\nvoid setFunctions_gaussDiff(){\n    commonFunctions funcs;\n    funcs.newModelParameters  = newModelParameters_gaussDiff;\n    funcs.freeModelParameters = freeModelParameters_gaussDiff;\n    funcs.newModelStats       = newModelStats_gaussDiff;\n    funcs.freeModelStats      = freeModelStats_gaussDiff;\n    funcs.initializeVbHmm     = initializeVbHmm_gaussDiff;\n    funcs.pTilde_z1           = pTilde_z1_gaussDiff;\n    funcs.pTilde_zn_zn1       = pTilde_zn_zn1_gaussDiff;\n    funcs.pTilde_xn_zn        = pTilde_xn_zn_gaussDiff;\n    funcs.calcStatsVars       = calcStatsVars_gaussDiff;\n    funcs.maximization        = maximization_gaussDiff;\n    funcs.varLowerBound       = varLowerBound_gaussDiff;\n    funcs.reorderParameters   = reorderParameters_gaussDiff;\n    funcs.outputResults       = outputResults_gaussDiff;\n    setFunctions( funcs );\n}\n\nvoid setGFunctions_gaussDiff(){\n    gCommonFunctions funcs;\n    funcs.newModelParameters    = newModelParameters_gaussDiff;\n    funcs.freeModelParameters   = freeModelParameters_gaussDiff;\n    funcs.newModelStats         = newModelStats_gaussDiff;\n    funcs.freeModelStats        = freeModelStats_gaussDiff;\n    funcs.newModelStatsG        = newModelStatsG_gaussDiff;\n    funcs.freeModelStatsG       = freeModelStatsG_gaussDiff;\n    funcs.initializeVbHmmG      = initializeVbHmmG_gaussDiff;\n    funcs.pTilde_z1             = pTilde_z1_gaussDiff;\n    funcs.pTilde_zn_zn1         = pTilde_zn_zn1_gaussDiff;\n    funcs.pTilde_xn_zn          = pTilde_xn_zn_gaussDiff;\n    funcs.calcStatsVarsG        = calcStatsVarsG_gaussDiff;\n    funcs.maximizationG         = maximizationG_gaussDiff;\n    funcs.varLowerBoundG        = varLowerBoundG_gaussDiff;\n    funcs.reorderParametersG    = reorderParametersG_gaussDiff;\n    funcs.outputResultsG        = outputResultsG_gaussDiff;\n    setGFunctions( funcs );\n    isGlobalAnalysis = 1;\n}\n\n\nvoid outputResults_gaussDiff( xn, gv, iv, logFP )\nxnDataSet *xn;\nglobalVars *gv;\nindVars *iv;\nFILE *logFP;\n{\n    outputGaussDiffResults( xn, gv, iv, logFP );\n}\n\nvoid outputResultsG_gaussDiff( xns, gv, ivs, logFP )\nxnDataBundle *xns;\nglobalVars *gv;\nindVarBundle *ivs;\nFILE *logFP;\n{\n    outputGaussDiffResultsG( xns, gv, ivs, logFP );\n}\n\n\nvoid *newModelParameters_gaussDiff( xn, sNo )\nxnDataSet *xn;\nint sNo;\n{\n    int i;\n    gaussDiffParameters *p = (gaussDiffParameters*)malloc( sizeof(gaussDiffParameters) );\n    \n    p->uPiArr = (double*)malloc( sNo * sizeof(double) );\n    p->sumUPi = 0.0;\n    p->uAMat = (double**)malloc( sNo * sizeof(double*) );\n    for( i = 0 ; i < sNo ; i++ ){\n        p->uAMat[i] = (double*)malloc( sNo * sizeof(double) );\n    }\n    p->sumUAArr = (double*)malloc( sNo * sizeof(double) );\n\n    p->avgPi = (double *)malloc( sNo * sizeof(double) );\n    p->avgLnPi = (double *)malloc( sNo * sizeof(double) );\n    p->avgA = (double **)malloc( sNo * sizeof(double*) );\n    p->avgLnA = (double **)malloc( sNo * sizeof(double*) );\n    for( i = 0 ; i < sNo ; i++ ){\n        p->avgA[i] = (double *)malloc( sNo * sizeof(double) );\n        p->avgLnA[i] = (double *)malloc( sNo * sizeof(double) );\n    }\n    p->avgDlt = (double *)malloc( sNo * sizeof(double) );\n    p->avgLnDlt = (double *)malloc( sNo * sizeof(double) );\n\n    p->uAArr = (double *)malloc( sNo * sizeof(double) );\n    p->uBArr = (double *)malloc( sNo * sizeof(double) );\n    p->aDlt = (double *)malloc( sNo * sizeof(double) );\n    p->bDlt = (double *)malloc( sNo * sizeof(double) );\n\n    return p;\n}\n\nvoid freeModelParameters_gaussDiff( p, xn, sNo )\nvoid **p;\nxnDataSet *xn;\nint sNo;\n{\n    gaussDiffParameters *gp = *p;\n    int i;\n\n    free( gp->uPiArr );\n    for( i = 0 ; i < sNo ; i++ ){\n        free( gp->uAMat[i] );\n    }\n    free( gp->uAMat );\n    free( gp->sumUAArr );\n\n    free( gp->avgPi );\n    free( gp->avgLnPi );\n    for( i = 0 ; i < sNo ; i++ ){\n        free( gp->avgA[i] );\n        free( gp->avgLnA[i] );\n    }\n    free( gp->avgA );\n    free( gp->avgLnA );\n    free( gp->avgDlt );\n    free( gp->avgLnDlt );\n\n    free( gp->uAArr );\n    free( gp->uBArr );\n    free( gp->aDlt );\n    free( gp->bDlt );\n\n    free( *p );\n    *p = NULL;\n}\n\n\nvoid *newModelStats_gaussDiff( xn, gv, iv )\nxnDataSet *xn;\nglobalVars *gv;\nindVars *iv;\n{\n    if( isGlobalAnalysis == 0 ){\n        int sNo = gv->sNo;\n        gaussDiffStats *s = (gaussDiffStats*)malloc( sizeof(gaussDiffStats) );\n        \n        int i;\n        s->Ni = (double *)malloc( sNo * sizeof(double) );\n        s->Ri = (double *)malloc( sNo * sizeof(double) );\n        s->Nij = (double **)malloc( sNo * sizeof(double*) );\n        for( i = 0 ; i < sNo ; i++ )\n        {   s->Nij[i] = (double *)malloc( sNo * sizeof(double) );   }\n        s->Nii = (double *)malloc( sNo * sizeof(double) );\n\n        return s;\n\n    } else {\n\n        return NULL;\n\n    }\n}\n\nvoid freeModelStats_gaussDiff( s, xn, gv, iv )\nvoid **s;\nxnDataSet *xn;\nglobalVars *gv;\nindVars *iv;\n{\n    if( isGlobalAnalysis == 0 ){\n        int sNo = gv->sNo;\n        gaussDiffStats *gs = *s;\n        int i;\n\n        free( gs->Ni );\n        free( gs->Ri );\n        for( i = 0 ; i < sNo ; i++ )\n        {   free( gs->Nij[i] );   }\n        free( gs->Nij );\n        free( gs->Nii );\n\n        free( gs );\n        *s = NULL;\n    }\n}\n\nvoid *newModelStatsG_gaussDiff( xns, gv, ivs)\nxnDataBundle *xns;\nglobalVars *gv;\nindVarBundle *ivs;\n{\n    int sNo = gv->sNo;\n    gaussDiffGlobalStats *gs = (gaussDiffGlobalStats*)malloc( sizeof(gaussDiffGlobalStats) );\n    \n    int i;\n    gs->NiR = (double *)malloc( sNo * sizeof(double) );\n    gs->RiR = (double *)malloc( sNo * sizeof(double) );\n    gs->NijR = (double **)malloc( sNo * sizeof(double*) );\n    for( i = 0 ; i < sNo ; i++ )\n    {   gs->NijR[i] = (double *)malloc( sNo * sizeof(double) );   }\n    gs->NiiR = (double *)malloc( sNo * sizeof(double) );\n    gs->z1iR = (double *)malloc( sNo * sizeof(double) );\n\n    return gs;\n}\n\nvoid freeModelStatsG_gaussDiff( gs, xns, gv, ivs )\nvoid **gs;\nxnDataBundle *xns;\nglobalVars *gv;\nindVarBundle *ivs;\n{\n    int sNo = gv->sNo;\n    gaussDiffGlobalStats *ggs = *gs;\n    int i;\n    free( ggs->NiR );\n    for( i = 0 ; i < sNo ; i++ )\n    {   free( ggs->NijR[i] );   }\n    free( ggs->NijR );\n    free( ggs->NiiR );\n    free( ggs->RiR );\n    free( ggs->z1iR );\n\n    free( *gs );\n    *gs = NULL;\n}\n\n\nvoid initializeVbHmm_gaussDiff( xn, gv, iv )\nxnDataSet *xn;\nglobalVars *gv;\nindVars *iv;\n{\n    int sNo = gv->sNo;\n    gaussDiffParameters *p = gv->params;\n    int i, j;\n    \n    // hyper parameter for p( pi(i) )\n    p->sumUPi = 0.0;\n    for( i = 0 ; i < sNo ; i++ ){\n        p->uPiArr[i] = 1.0;\n        p->sumUPi += p->uPiArr[i];\n    }\n    \n    // hyper parameter for p( A(i,j) )\n    for( i = 0 ; i < sNo ; i++ ){\n        p->sumUAArr[i] = 0.0;\n        for( j = 0 ; j < sNo ; j++ ){\n            if( j == i ){\n                p->uAMat[i][j] = 5.0;\n            } else {\n                p->uAMat[i][j] = 1.0;\n            }\n            p->sumUAArr[i] += p->uAMat[i][j];\n        }\n    }\n    \n    // hyper parameter for p( delta(k) )\n    for( i = 0 ; i < sNo ; i++ ){\n        p->uAArr[i] = 1.0;\n        p->uBArr[i] = 0.0005;\n    }\n    \n    initialize_indVars_gaussDiff( xn, gv, iv );\n    \n    calcStatsVars_gaussDiff( xn, gv, iv );\n    maximization_gaussDiff( xn, gv, iv );\n}\n\nvoid initializeVbHmmG_gaussDiff( xns, gv, ivs )\nxnDataBundle *xns;\nglobalVars *gv;\nindVarBundle *ivs;\n{\n    int sNo = gv->sNo, rNo = xns->R;\n    gaussDiffParameters *p = gv->params;\n    int i, j, r;\n\n    p->sumUPi = 0.0;\n    for( i = 0 ; i < sNo ; i++ ){\n        p->uPiArr[i] = 1.0;\n        p->sumUPi += p->uPiArr[i];\n    }\n    \n    for( i = 0 ; i < sNo ; i++ ){\n        p->sumUAArr[i] = 0.0;\n        for( j = 0 ; j < sNo ; j++ ){\n            if( j == i ){\n                p->uAMat[i][j] = 5.0;\n            } else {\n                p->uAMat[i][j] = 1.0;\n            }\n            p->sumUAArr[i] += p->uAMat[i][j];\n        }\n    }\n    \n    // hyper parameter for p( delta(k) )\n    for( i = 0 ; i < sNo ; i++ ){\n        p->uAArr[i] = 1.0;\n        p->uBArr[i] = 0.0005;\n    }\n    \n    for( r = 0 ; r < rNo ; r++ ){\n        initialize_indVars_gaussDiff( xns->xn[r], gv, ivs->indVars[r] );\n    }\n    \n    calcStatsVarsG_gaussDiff( xns, gv, ivs );\n    maximizationG_gaussDiff( xns, gv, ivs );\n}\n\n\nvoid initialize_indVars_gaussDiff( xn, gv, iv )\nxnDataSet *xn;\nglobalVars *gv;\nindVars *iv;\n{\n    size_t dLen = xn->N;\n    int sNo = gv->sNo;\n    double **gmMat = iv->gmMat;\n    \n    int i;\n    size_t n;\n    double sumPar;\n    for( n = 0 ; n < dLen ; n++ ){\n        sumPar = 0.0;\n        for( i = 0 ; i < sNo ; i++ ){\n            gmMat[n][i] = enoise(1.0) + 1.0;\n            sumPar += gmMat[n][i];\n        }\n        for( i = 0 ; i < sNo ; i++ ){\n            gmMat[n][i] /= sumPar;\n        }\n    }\n}\n\n\nxnDataSet *newXnDataSet_gaussDiff( filename )\nconst char *filename;\n{\n    xnDataSet *xn = (xnDataSet*)malloc( sizeof(xnDataSet) );\n    xn->name = (char*)malloc( strlen(filename) + 2 );\n    strncpy( xn->name, filename, strlen(filename)+1 );\n    xn->data = (gaussDiffData*)malloc( sizeof(gaussDiffData) );\n    gaussDiffData *d = (gaussDiffData*)xn->data;\n    d->v = NULL;\n    return xn;\n}\n\nvoid freeXnDataSet_gaussDiff( xn )\nxnDataSet **xn;\n{\n    gaussDiffData *d = (gaussDiffData*)(*xn)->data;\n    free( d->v );\n    free( (*xn)->data );\n    free( (*xn)->name );\n    free( *xn );\n    *xn = NULL;\n}\n\n\ndouble pTilde_z1_gaussDiff( i, params )\nint i;\nvoid *params;\n{\n    gaussDiffParameters *p = (gaussDiffParameters*)params;\n    return exp( p->avgLnPi[i] );\n}\n\ndouble pTilde_zn_zn1_gaussDiff( i, j, params )\nint i, j;\nvoid *params;\n{\n    gaussDiffParameters *p = (gaussDiffParameters*)params;\n    return exp( p->avgLnA[i][j] );\n}\n\ndouble pTilde_xn_zn_gaussDiff( xnWv, n, i, params )\nxnDataSet *xnWv;\nsize_t n;\nint i;\nvoid *params;\n{\n    gaussDiffParameters *p = (gaussDiffParameters*)params;\n    gaussDiffData *xn = (gaussDiffData*)xnWv->data;\n    double val;\n    val  = p->avgLnDlt[i] - log(2.0);\n    val -= log(xn->v[n]) + p->avgDlt[i] * pow( xn->v[n], 2.0) / 4.0;\n    return exp(val);\n}\n\n\nvoid calcStatsVars_gaussDiff( xn, gv, iv )\nxnDataSet *xn;\nglobalVars *gv;\nindVars *iv;\n{\n    gaussDiffData *d = (gaussDiffData*)xn->data;\n    gaussDiffStats *s = (gaussDiffStats*)iv->stats;\n    size_t dLen = xn->N;\n    int sNo = gv->sNo;\n    double **gmMat = iv->gmMat, ***xiMat = iv->xiMat;\n    double *Ni = s->Ni, *Ri = s->Ri, *Nii = s->Nii, **Nij = s->Nij;\n    size_t n;\n    int i, j;\n\n    for( i = 0 ; i < sNo ; i++ ){\n        Ni[i]   = 1e-10;\n        Ri[i]   = 1e-10;\n        Nii[i]  = 1e-10;\n        for( j = 0 ; j < sNo ; j++ ){\n            Nij[i][j] = 1e-10;\n        }\n        for( n = 0 ; n < dLen ; n++ ){\n            Ni[i] += gmMat[n][i];\n            Ri[i] += gmMat[n][i] * pow( d->v[n], 2.0 );\n            for( j = 0 ; j < sNo ; j++ ){\n                Nii[i]    += xiMat[n][i][j];\n                Nij[i][j] += xiMat[n][i][j];\n            }\n        }\n    }\n}\n\nvoid calcStatsVarsG_gaussDiff( xns, gv, ivs )\nxnDataBundle *xns;\nglobalVars *gv;\nindVarBundle *ivs;\n{\n    gaussDiffData *d;\n    gaussDiffGlobalStats *gs = (gaussDiffGlobalStats*)ivs->stats;\n    int sNo = gv->sNo, rNo = xns->R;\n    double **gmMat, ***xiMat;\n    double *NiR = gs->NiR, *RiR = gs->RiR, *NiiR = gs->NiiR;\n    double **NijR = gs->NijR, *z1iR = gs->z1iR;\n    size_t dLen, n;\n    int i, j, r;\n    \n    for( i = 0 ; i < sNo ; i++ ){\n        NiR[i]   = 1e-10;\n        RiR[i]  = 1e-10;\n        NiiR[i]  = 1e-10;\n        for( j = 0 ; j < sNo ; j++ ){\n            NijR[i][j] = 1e-10;\n        }\n        z1iR[i] = 1e-10;\n    }\n    for( r = 0 ; r < rNo ; r++ ){\n        d = (gaussDiffData*)xns->xn[r]->data;\n        dLen = xns->xn[r]->N;\n        gmMat = ivs->indVars[r]->gmMat;\n        xiMat = ivs->indVars[r]->xiMat;\n        for( i = 0 ; i < sNo ; i++ ){\n            z1iR[i] += gmMat[0][i];\n            for( n = 0 ; n < dLen ; n++ ){\n                NiR[i] += gmMat[n][i];\n                RiR[i] += gmMat[n][i] * pow( d->v[n], 2.0 );\n                for( j = 0 ; j < sNo ; j++ ){\n                    NiiR[i]    += xiMat[n][i][j];\n                    NijR[i][j] += xiMat[n][i][j];\n                }\n            }\n        }\n    }\n}\n\n\nvoid maximization_gaussDiff( xn, gv, iv )\nxnDataSet *xn;\nglobalVars *gv;\nindVars *iv;\n{\n    gaussDiffParameters *p = (gaussDiffParameters*)gv->params;\n    gaussDiffStats *s = (gaussDiffStats*)iv->stats;\n    int sNo = gv->sNo;\n    double **gmMat = iv->gmMat;\n    double *uPiArr = p->uPiArr, sumUPi = p->sumUPi;\n    double **uAMat = p->uAMat, *sumUAArr = p->sumUAArr;\n    double *uAArr = p->uAArr, *uBArr = p->uBArr, *aDlt = p->aDlt, *bDlt = p->bDlt;\n    double *avgPi = p->avgPi, *avgLnPi = p->avgLnPi, **avgA = p->avgA, **avgLnA = p->avgLnA;\n    double *avgDlt = p->avgDlt, *avgLnDlt = p->avgLnDlt;\n    double *Ni = s->Ni, *Ri = s->Ri, *Nii = s->Nii, **Nij = s->Nij;\n    int i, j;\n\n    for( i = 0 ; i < sNo ; i++ ){\n        avgPi[i] = ( uPiArr[i] + gmMat[0][i] ) / ( sumUPi + 1.0 );\n        avgLnPi[i] = gsl_sf_psi( uPiArr[i] + gmMat[0][i] ) - gsl_sf_psi( sumUPi + 1.0 );\n\n        for( j = 0 ; j < sNo ; j++ ){\n            avgA[i][j] = ( uAMat[i][j] + Nij[i][j] ) / ( sumUAArr[i] + Nii[i] );\n            avgLnA[i][j] = gsl_sf_psi( uAMat[i][j] + Nij[i][j] ) - gsl_sf_psi( sumUAArr[i] + Nii[i] );\n        }\n\n        aDlt[i] = uAArr[i] + Ni[i];\n        bDlt[i] = uBArr[i] + Ri[i] / 4.0;\n\n        avgDlt[i]   = aDlt[i] / bDlt[i];\n        avgLnDlt[i] = gsl_sf_psi( aDlt[i] ) - log( bDlt[i] );\n    }\n}\n\nvoid maximizationG_gaussDiff( xns, gv, ivs )\nxnDataBundle *xns;\nglobalVars *gv;\nindVarBundle *ivs;\n{\n    gaussDiffParameters *p = (gaussDiffParameters*)gv->params;\n    double *uPiArr = p->uPiArr, sumUPi = p->sumUPi;\n    double **uAMat = p->uAMat, *sumUAArr = p->sumUAArr;\n    double *uAArr = p->uAArr, *uBArr = p->uBArr, *aDlt = p->aDlt, *bDlt = p->bDlt;\n    double *avgPi = p->avgPi, *avgLnPi = p->avgLnPi, **avgA = p->avgA, **avgLnA = p->avgLnA;\n    double *avgDlt = p->avgDlt, *avgLnDlt = p->avgLnDlt;\n    gaussDiffGlobalStats *gs = (gaussDiffGlobalStats*)ivs->stats;\n    double *NiR = gs->NiR, *NiiR = gs->NiiR, **NijR = gs->NijR, *RiR = gs->RiR;\n    double *z1iR = gs->z1iR, dR = (double)(xns->R);\n    int sNo = gv->sNo;\n    int i, j;\n    \n    for( i = 0 ; i < sNo ; i++ ){\n        avgPi[i] = ( uPiArr[i] + z1iR[i] ) / ( sumUPi + dR );\n        avgLnPi[i] = gsl_sf_psi( uPiArr[i] + z1iR[i] ) - gsl_sf_psi( sumUPi + dR );\n        \n        for( j = 0 ; j < sNo ; j++ ){\n            avgA[i][j] = ( uAMat[i][j] + NijR[i][j] ) / ( sumUAArr[i] + NiiR[i] );\n            avgLnA[i][j] = gsl_sf_psi( uAMat[i][j] + NijR[i][j] ) - gsl_sf_psi( sumUAArr[i] + NiiR[i] );\n        }\n        \n        aDlt[i] = uAArr[i] + NiR[i];\n        bDlt[i] = uBArr[i] + RiR[i] / 4.0;\n        \n        avgDlt[i]   = aDlt[i] / bDlt[i];\n        avgLnDlt[i] = gsl_sf_psi( aDlt[i] ) - log( bDlt[i] );\n    }\n}\n\n\ndouble varLowerBound_gaussDiff( xn, gv, iv )\nxnDataSet *xn;\nglobalVars *gv;\nindVars *iv;\n{\n    gaussDiffParameters *p = (gaussDiffParameters*)gv->params;\n    gaussDiffStats *s = (gaussDiffStats*)iv->stats;\n    size_t dLen = xn->N;\n    int sNo = gv->sNo;\n    double **gmMat = iv->gmMat, *cn = iv->cn;\n    double *uPiArr = p->uPiArr, sumUPi = p->sumUPi;\n    double **uAMat = p->uAMat, *sumUAArr = p->sumUAArr;\n    double *uAArr = p->uAArr, *uBArr = p->uBArr;\n    double *avgLnPi = p->avgLnPi, **avgLnA = p->avgLnA;\n    double *avgDlt = p->avgDlt, *avgLnDlt = p->avgLnDlt;\n    double *Nii = s->Nii, **Nij = s->Nij;\n    double *aDlt = p->aDlt, *bDlt = p->bDlt;\n    size_t n;\n    int i, j;\n\n    double lnpPi = gsl_sf_lngamma(sumUPi);\n    double lnpA = 0.0;\n    double lnpDlt = 0.0;\n    double lnqPi = gsl_sf_lngamma(sumUPi + 1.0);\n    double lnqA = 0.0;\n    double lnqDlt = - sNo / 2.0;\n    for( i = 0 ; i < sNo ; i++ ){\n        lnpPi += (uPiArr[i]-1.0) * avgLnPi[i] - gsl_sf_lngamma(uPiArr[i]);\n\n        lnpDlt += - gsl_sf_lngamma(uAArr[i]) + uAArr[i] * log(uBArr[i]);\n        lnpDlt += (uAArr[i] - 1.0) * avgLnDlt[i] - uBArr[i] * avgDlt[i];\n        \n        lnqPi += (uPiArr[i]+gmMat[0][i]-1.0) * (gsl_sf_psi(uPiArr[i]+gmMat[0][i]) - gsl_sf_psi(sumUPi+1.0));\n        lnqPi -= gsl_sf_lngamma(uPiArr[i] + gmMat[0][i]);\n\n        lnpA += gsl_sf_lngamma(sumUAArr[i]);\n        lnqA += gsl_sf_lngamma(sumUAArr[i] + Nii[i]);\n        for( j = 0 ; j < sNo ; j++ ){\n            lnpA += (uAMat[i][j]-1.0)*avgLnA[i][j] - gsl_sf_lngamma(uAMat[i][j]);\n\n            lnqA += (uAMat[i][j] + Nij[i][j] - 1.0) * (gsl_sf_psi(uAMat[i][j]+Nij[i][j]) - gsl_sf_psi(sumUAArr[i]+Nii[i]));\n            lnqA -= gsl_sf_lngamma( uAMat[i][j] + Nij[i][j] );\n        }\n\n        lnqDlt += - gsl_sf_lngamma(aDlt[i]) + aDlt[i] * log(bDlt[i]);\n        lnqDlt += (aDlt[i] - 1.0) * avgLnDlt[i] - aDlt[i];\n    }\n\n    double lnpX = 0.0;\n    for( n = 0 ; n < dLen ; n++ ){\n        lnpX += log( cn[n] );\n    }\n\n    double val;\n    val  = lnpPi + lnpA + lnpDlt;\n    val -= lnqPi + lnqA + lnqDlt;\n    val += lnpX;\n    val += log(gsl_sf_fact(sNo));\n\n    return val;\n}\n\ndouble varLowerBoundG_gaussDiff( xns, gv, ivs )\nxnDataBundle *xns;\nglobalVars *gv;\nindVarBundle *ivs;\n{\n    gaussDiffParameters *p = (gaussDiffParameters*)gv->params;\n    int sNo = gv->sNo, rNo = xns->R;\n    double *uPiArr = p->uPiArr, sumUPi = p->sumUPi;\n    double **uAMat = p->uAMat, *sumUAArr = p->sumUAArr;\n    double *uAArr = p->uAArr, *uBArr = p->uBArr;\n    double *avgLnPi = p->avgLnPi, **avgLnA = p->avgLnA;\n    double *avgDlt = p->avgDlt, *avgLnDlt = p->avgLnDlt;\n    double *aDlt = p->aDlt, *bDlt = p->bDlt;\n    gaussDiffGlobalStats *gs = (gaussDiffGlobalStats*)ivs->stats;\n    double *NiiR = gs->NiiR, **NijR = gs->NijR, *z1iR = gs->z1iR, dR = (double)xns->R;\n    size_t n;\n    int i, j, r;\n\n    double lnpPi = gsl_sf_lngamma(sumUPi);\n    double lnpA = 0.0;\n    double lnpDlt = 0.0;\n    double lnqPi = gsl_sf_lngamma(sumUPi + dR);\n    double lnqA = 0.0;\n    double lnqDlt = - sNo / 2.0;\n    for( i = 0 ; i < sNo ; i++ ){\n        lnpPi += (uPiArr[i]-1.0) * avgLnPi[i] - gsl_sf_lngamma(uPiArr[i]);\n        \n        lnpDlt += - gsl_sf_lngamma(uAArr[i]) + uAArr[i] * log(uBArr[i]);\n        lnpDlt += (uAArr[i] - 1.0) * avgLnDlt[i] - uBArr[i] * avgDlt[i];\n        \n        lnqPi += (uPiArr[i]+z1iR[i]-1.0) * (gsl_sf_psi(uPiArr[i]+z1iR[i]) - gsl_sf_psi(sumUPi+dR));\n        lnqPi -= gsl_sf_lngamma(uPiArr[i] + z1iR[i]);\n        \n        lnpA += gsl_sf_lngamma(sumUAArr[i]);\n        lnqA += gsl_sf_lngamma(sumUAArr[i] + NiiR[i]);\n        for( j = 0 ; j < sNo ; j++ ){\n            lnpA += (uAMat[i][j]-1.0)*avgLnA[i][j] - gsl_sf_lngamma(uAMat[i][j]);\n            \n            lnqA += (uAMat[i][j] + NijR[i][j] - 1.0) * (gsl_sf_psi(uAMat[i][j]+NijR[i][j]) - gsl_sf_psi(sumUAArr[i]+NiiR[i]));\n            lnqA -= gsl_sf_lngamma( uAMat[i][j] + NijR[i][j] );\n        }\n        \n        lnqDlt += - gsl_sf_lngamma(aDlt[i]) + aDlt[i] * log(bDlt[i]);\n        lnqDlt += (aDlt[i] - 1.0) * avgLnDlt[i] - aDlt[i];\n    }\n    \n    double lnpX = 0.0;\n    for( r = 0 ; r < rNo ; r++ ){\n        size_t dLen = xns->xn[r]->N;\n        for( n = 0 ; n < dLen ; n++ ){\n            lnpX += log( ivs->indVars[r]->cn[n] );\n        }\n    }\n    \n    double val;\n    val  = lnpPi + lnpA + lnpDlt;\n    val -= lnqPi + lnqA + lnqDlt;\n    val += lnpX;\n    val += log(gsl_sf_fact(sNo));\n    \n    return val;\n}    \n\n\nvoid reorderParameters_gaussDiff( xn, gv, iv )\nxnDataSet *xn;\nglobalVars *gv;\nindVars *iv;\n{\n    gaussDiffParameters *p = (gaussDiffParameters*)gv->params;\n    gaussDiffStats *s = (gaussDiffStats*)iv->stats;\n    size_t dLen = xn->N;\n    int sNo = gv->sNo;\n    double **gmMat = iv->gmMat, ***xiMat = iv->xiMat;\n    double *avgPi = p->avgPi, *avgLnPi = p->avgLnPi, **avgA = p->avgA, **avgLnA = p->avgLnA;\n    double *avgDlt = p->avgDlt, *avgLnDlt = p->avgLnDlt;\n    double *Ni = s->Ni;\n    size_t n;\n    int i, j;\n\n    int *index = (int*)malloc( sNo * sizeof(int) );\n    double *store = (double*)malloc( sNo * sizeof(double) );\n    double **s2D = (double**)malloc( sNo * sizeof(double*) );\n    for( i = 0 ; i < sNo ; i++ )\n    {   s2D[i] = (double*)malloc( MAX(sNo,2) * sizeof(double) );   }\n\n    // index indicates order of avgDlt values (0=biggest avgDlt -- sNo=smallest avgDlt).\n    for( i = 0 ; i < sNo ; i++ ){\n        index[i] = sNo - 1;\n        for( j = 0 ; j < sNo ; j++ ){\n            if( j != i ){\n                if( avgDlt[i] < avgDlt[j] ){\n                    index[i]--;\n                } else if( avgDlt[i] == avgDlt[j] ){\n                    if( j > i )\n                    {   index[i]--;   }\n                }\n            }\n        }\n    }\n\n    for( i = 0 ; i < sNo ; i++ ){   store[index[i]] = avgPi[i];   }\n    for( i = 0 ; i < sNo ; i++ ){   avgPi[i] = store[i];   }\n\n    for( i = 0 ; i < sNo ; i++ ){   store[index[i]] = avgLnPi[i];   }\n    for( i = 0 ; i < sNo ; i++ ){   avgLnPi[i] = store[i];   }\n\n    for( i = 0 ; i < sNo ; i++ ){   store[index[i]] = avgDlt[i];   }\n    for( i = 0 ; i < sNo ; i++ ){   avgDlt[i] = store[i];   }\n\n    for( i = 0 ; i < sNo ; i++ ){   store[index[i]] = avgLnDlt[i];   }\n    for( i = 0 ; i < sNo ; i++ ){   avgLnDlt[i] = store[i];   }\n\n    for( j = 0 ; j < sNo ; j++ ){\n        for( i = 0 ; i < sNo ; i++ ){   s2D[index[i]][index[j]] = avgA[i][j];   }\n    }\n    for( j = 0 ; j < sNo ; j++ ){\n        for( i = 0 ; i < sNo ; i++ ){   avgA[i][j] = s2D[i][j];   }\n    }\n\n    for( j = 0 ; j < sNo ; j++ ){\n        for( i = 0 ; i < sNo ; i++ ){   s2D[index[i]][index[j]] = avgLnA[i][j];   }\n    }\n    for( j = 0 ; j < sNo ; j++ ){\n        for( i = 0 ; i < sNo ; i++ ){   avgLnA[i][j] = s2D[i][j];   }\n    }\n\n    for( i = 0 ; i < sNo ; i++ ){   store[index[i]] = Ni[i];   }\n    for( i = 0 ; i < sNo ; i++ ){   Ni[i] = store[i];   }\n\n    for( n = 0 ; n < dLen ; n++ ){\n        for( i = 0 ; i < sNo ; i++ ){   store[index[i]] = gmMat[n][i];   }\n        for( i = 0 ; i < sNo ; i++ ){   gmMat[n][i] = store[i];   }\n    }\n\n    for( n = 0 ; n < dLen ; n++ ){\n        for( j = 0 ; j < sNo ; j++ ){\n            for( i = 0 ; i < sNo ; i++ ){   s2D[index[i]][index[j]] = xiMat[n][i][j];   }\n        }\n        for( j = 0 ; j < sNo ; j++ ){\n            for( i = 0 ; i < sNo ; i++ ){   xiMat[n][i][j] = s2D[i][j];   }\n        }\n    }\n\n    for( i = 0 ; i < sNo ; i++ ){   free( s2D[i] );   }\n    free( s2D );\n    free( store );\n    free( index );\n}\n\nvoid reorderParametersG_gaussDiff( xns, gv, ivs )\nxnDataBundle *xns;\nglobalVars *gv;\nindVarBundle *ivs;\n{\n    gaussDiffParameters *p = (gaussDiffParameters*)gv->params;\n    size_t dLen;\n    int sNo = gv->sNo, rNo = xns->R;\n    double *avgPi = p->avgPi, *avgLnPi = p->avgLnPi, **avgA = p->avgA, **avgLnA = p->avgLnA;\n    double *avgDlt = p->avgDlt, *avgLnDlt = p->avgLnDlt;\n    size_t n;\n    int i, j, r;\n    \n    int *index = (int*)malloc( sNo * sizeof(int) );\n    double *store = (double*)malloc( sNo * sizeof(double) );\n    double **s2D = (double**)malloc( sNo * sizeof(double*) );\n    for( i = 0 ; i < sNo ; i++ )\n    {   s2D[i] = (double*)malloc( MAX(sNo,2) * sizeof(double) );   }\n    \n    // index indicates order of avgMu values (0=biggest avgMu -- sNo=smallest avgMu).\n    for( i = 0 ; i < sNo ; i++ ){\n        index[i] = sNo - 1;\n        for( j = 0 ; j < sNo ; j++ ){\n            if( j != i ){\n                if( avgDlt[i] < avgDlt[j] ){\n                    index[i]--;\n                } else if( avgDlt[i] == avgDlt[j] ){\n                    if( j > i )\n                    {   index[i]--;   }\n                }\n            }\n        }\n    }\n    \n    for( i = 0 ; i < sNo ; i++ ){   store[index[i]] = avgPi[i];   }\n    for( i = 0 ; i < sNo ; i++ ){   avgPi[i] = store[i];   }\n    \n    for( i = 0 ; i < sNo ; i++ ){   store[index[i]] = avgLnPi[i];   }\n    for( i = 0 ; i < sNo ; i++ ){   avgLnPi[i] = store[i];   }\n    \n    for( i = 0 ; i < sNo ; i++ ){   store[index[i]] = avgDlt[i];   }\n    for( i = 0 ; i < sNo ; i++ ){   avgDlt[i] = store[i];   }\n    \n    for( i = 0 ; i < sNo ; i++ ){   store[index[i]] = avgLnDlt[i];   }\n    for( i = 0 ; i < sNo ; i++ ){   avgLnDlt[i] = store[i];   }\n    \n    for( j = 0 ; j < sNo ; j++ ){\n        for( i = 0 ; i < sNo ; i++ ){   s2D[index[i]][index[j]] = avgA[i][j];   }\n    }\n    for( j = 0 ; j < sNo ; j++ ){\n        for( i = 0 ; i < sNo ; i++ ){   avgA[i][j] = s2D[i][j];   }\n    }\n    \n    for( j = 0 ; j < sNo ; j++ ){\n        for( i = 0 ; i < sNo ; i++ ){   s2D[index[i]][index[j]] = avgLnA[i][j];   }\n    }\n    for( j = 0 ; j < sNo ; j++ ){\n        for( i = 0 ; i < sNo ; i++ ){   avgLnA[i][j] = s2D[i][j];   }\n    }\n    \n    double *NiR = ((gaussDiffGlobalStats*)ivs->stats)->NiR;\n    for( i = 0 ; i < sNo ; i++ ){   store[index[i]] = NiR[i];   }\n    for( i = 0 ; i < sNo ; i++ ){   NiR[i] = store[i];   }\n    \n    for( r = 0 ; r < rNo ; r++ ){\n        double **gmMat = ivs->indVars[r]->gmMat;\n        dLen = xns->xn[r]->N;\n        for( n = 0 ; n < dLen ; n++ ){\n            for( i = 0 ; i < sNo ; i++ ){   store[index[i]] = gmMat[n][i];   }\n            for( i = 0 ; i < sNo ; i++ ){   gmMat[n][i] = store[i];   }\n        }\n    }\n    \n    for( r = 0 ; r < rNo ; r++ ){\n        double ***xiMat = ivs->indVars[r]->xiMat;\n        dLen = xns->xn[r]->N;\n        for( n = 0 ; n < dLen ; n++ ){\n            for( j = 0 ; j < sNo ; j++ ){\n                for( i = 0 ; i < sNo ; i++ ){   s2D[index[i]][index[j]] = xiMat[n][i][j];   }\n            }\n            for( j = 0 ; j < sNo ; j++ ){\n                for( i = 0 ; i < sNo ; i++ ){   xiMat[n][i][j] = s2D[i][j];   }\n            }\n        }\n    }\n    \n    for( i = 0 ; i < sNo ; i++ ){   free( s2D[i] );   }\n    free( s2D );\n    free( store );\n    free( index );\n}\n\n\nvoid outputGaussDiffResults( xn, gv, iv, logFP )\nxnDataSet *xn;\nglobalVars *gv;\nindVars *iv;\nFILE *logFP;\n{\n    gaussDiffParameters *p = (gaussDiffParameters*)gv->params;\n    int sNo = gv->sNo;\n    int i, j;\n    fprintf(logFP, \"  results: K = %d \\n\", sNo);\n\n    fprintf(logFP, \"   delta: ( %g\", p->avgDlt[0]);\n    for( i = 1 ; i < sNo ; i++ ){\n        fprintf(logFP, \", %g\", p->avgDlt[i]);\n    }\n    fprintf(logFP, \" ) \\n\");\n\n    fprintf(logFP, \"   pi: ( %g\", p->avgPi[0]);\n    for( i = 1 ; i < sNo ; i++ ){\n        fprintf(logFP, \", %g\", p->avgPi[i]);\n    }\n    fprintf(logFP, \" ) \\n\");\n    \n    fprintf(logFP, \"   A_matrix: [\");\n    for( i = 0 ; i < sNo ; i++ ){\n            fprintf(logFP, \" ( %g\", p->avgA[i][0]);\n            for( j = 1 ; j < sNo ; j++ )\n            {   fprintf(logFP, \", %g\", p->avgA[i][j]);   }\n            fprintf(logFP, \")\");\n    }\n    fprintf(logFP, \" ] \\n\\n\");\n\n    char fn[256];\n    FILE *fp;\n    size_t n;\n\n    sprintf( fn, \"%s.param%03d\", xn->name, sNo );\n    if( (fp = fopen( fn, \"w\")) != NULL ){\n        fprintf(fp, \"delta, pi\");\n        for( i = 0 ; i < sNo ; i++ )\n        {   fprintf(fp, \", A%dx\", i);   }\n        fprintf(fp, \"\\n\");\n\n        for( i = 0 ; i < sNo ; i++ ){\n            fprintf(fp, \"%g, %g\", p->avgDlt[i], p->avgPi[i]);\n            for( j = 0 ; j < sNo ; j++ )\n            {   fprintf(fp, \", %g\", p->avgA[j][i]);   }\n            fprintf(fp, \"\\n\");\n        }\n        fclose(fp);\n    }\n\n    sprintf( fn, \"%s.Lq%03d\", xn->name, sNo );\n    if( (fp = fopen( fn, \"w\")) != NULL ){\n        for( n = 0 ; n < gv->iteration ; n++ ){\n            fprintf( fp, \"%24.20e\\n\", gv->LqArr[n] );\n        }\n        fclose(fp);\n    }\n\n    sprintf( fn, \"%s.maxS%03d\", xn->name, sNo );\n    if( (fp = fopen( fn, \"w\")) != NULL ){\n        for( n = 0 ; n < xn->N ; n++ ){\n            fprintf( fp, \"%d\\n\", iv->stateTraj[n] );\n        }\n        fclose(fp);\n    }\n\n}\n\nvoid outputGaussDiffResultsG( xns, gv, ivs, logFP )\nxnDataBundle *xns;\nglobalVars *gv;\nindVarBundle *ivs;\nFILE *logFP;\n{\n    int sNo = gv->sNo, rNo = xns->R;\n    gaussDiffParameters *p = (gaussDiffParameters*)gv->params;\n    int i, j, r;\n    \n    fprintf(logFP, \"  results: K = %d \\n\", sNo);\n    \n    fprintf(logFP, \"   delta: ( %g\", p->avgDlt[0]);\n    for( i = 1 ; i < sNo ; i++ )\n    {   fprintf(logFP, \", %g\", p->avgDlt[i]);   }\n    fprintf(logFP, \" ) \\n\");\n    \n    fprintf(logFP, \"   pi: ( %g\", p->avgPi[0]);\n    for( i = 1 ; i < sNo ; i++ ){\n        fprintf(logFP, \", %g\", p->avgPi[i]);\n    }\n    fprintf(logFP, \" ) \\n\");\n    \n    fprintf(logFP, \"   A_matrix: [\");\n    for( i = 0 ; i < sNo ; i++ ){\n        fprintf(logFP, \" ( %g\", p->avgA[i][0]);\n        for( j = 1 ; j < sNo ; j++ )\n        {   fprintf(logFP, \", %g\", p->avgA[i][j]);   }\n        fprintf(logFP, \")\");\n    }\n    fprintf(logFP, \" ] \\n\\n\");\n    \n    char fn[256];\n    FILE *fp;\n    size_t n;\n    \n    sprintf( fn, \"%s.param%03d\", xns->xn[0]->name, sNo );\n    if( (fp = fopen( fn, \"w\")) != NULL ){\n        fprintf(fp, \"delta, pi\");\n        for( i = 0 ; i < sNo ; i++ )\n        {   fprintf(fp, \", A%dx\", i);   }\n        fprintf(fp, \"\\n\");\n        \n        for( i = 0 ; i < sNo ; i++ ){\n            fprintf(fp, \"%g, %g\", p->avgDlt[i], p->avgPi[i]);\n            for( j = 0 ; j < sNo ; j++ )\n            {   fprintf(fp, \", %g\", p->avgA[j][i]);   }\n            fprintf(fp, \"\\n\");\n        }\n        fclose(fp);\n    }\n    \n    sprintf( fn, \"%s.Lq%03d\", xns->xn[0]->name, sNo );\n    if( (fp = fopen( fn, \"w\")) != NULL ){\n        for( n = 0 ; n < gv->iteration ; n++ ){\n            fprintf( fp, \"%24.20e\\n\", gv->LqArr[n] );\n        }\n        fclose(fp);\n    }\n    \n    sprintf( fn, \"%s.maxS%03d\", xns->xn[0]->name, sNo );\n    int flag = 0;\n    if( (fp = fopen( fn, \"w\")) != NULL ){\n        n = 0;\n        do{\n            flag = 1;\n            for( r = 0 ; r < rNo ; r++ ){\n                xnDataSet *xn = xns->xn[r];\n                indVars *iv = ivs->indVars[r];\n                \n                if( r > 0 ){\n                    fprintf( fp, \",\" );\n                }\n                if( n < xn->N ){\n                    fprintf( fp, \"%d\", iv->stateTraj[n] );\n                }\n                flag &= (n >= (xn->N - 1));\n            }\n            fprintf( fp, \"\\n\" );\n            n++;\n        }while( !flag );\n        fclose(fp);\n    }\n}\n\n//\n", "meta": {"hexsha": "c8a0fa0bcfd0940f04f183db8482dfbb62a79d0d", "size": 30318, "ext": "c", "lang": "C", "max_stars_repo_path": "C/vbHmmGaussDiffusion.c", "max_stars_repo_name": "okamoto-kenji/varBayes-HMM", "max_stars_repo_head_hexsha": "77afe3c336c9e1ebeb115ca4f0b2bc25060556bd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7.0, "max_stars_repo_stars_event_min_datetime": "2016-03-31T06:59:00.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-01T06:35:57.000Z", "max_issues_repo_path": "C/vbHmmGaussDiffusion.c", "max_issues_repo_name": "okamoto-kenji/varBayes-HMM", "max_issues_repo_head_hexsha": "77afe3c336c9e1ebeb115ca4f0b2bc25060556bd", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "C/vbHmmGaussDiffusion.c", "max_forks_repo_name": "okamoto-kenji/varBayes-HMM", "max_forks_repo_head_hexsha": "77afe3c336c9e1ebeb115ca4f0b2bc25060556bd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.8112094395, "max_line_length": 126, "alphanum_fraction": 0.4883567518, "num_tokens": 11323, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4960938294709195, "lm_q2_score": 0.03963884250447896, "lm_q1q2_score": 0.01966458517384162}}
{"text": "/* Starting from version 7.8, MATLAB BLAS expects ptrdiff_t arguments for integers */\r\n#if MATLAB_VERSION >= 0x0708\r\n#include <stddef.h>\r\n#include <stdlib.h>\r\n#endif\r\n#include <string.h>\r\n\r\n/* Define MX_HAS_INTERLEAVED_COMPLEX for version <9.4 */\r\n#ifndef MX_HAS_INTERLEAVED_COMPLEX\r\n#define MX_HAS_INTERLEAVED_COMPLEX 0\r\n#endif\r\n\r\n/* Starting from version 7.6, MATLAB BLAS is seperated */\r\n#if MATLAB_VERSION >= 0x0705\r\n#include <blas.h>\r\n#endif\r\n#include <lapack.h>\r\n#include \"f2c.h\"\r\n\r\n// Conversion of optimal problems with coupling weighting terms to standard problems\r\n#define sb02mt FORTRAN_WRAPPER(sb02mt)\r\nextern void sb02mt(\r\n        const char *jobg,\r\n        const char *jobl,\r\n        const char *fact,\r\n        const char *uplo,\r\n        const ptrdiff_t *n,\r\n        const ptrdiff_t *m,\r\n        double *a,\r\n        const ptrdiff_t *lda,\r\n        double *b,\r\n        const ptrdiff_t *ldb,\r\n        double *q,\r\n        const ptrdiff_t *ldq,\r\n        double *r,\r\n        const ptrdiff_t *ldr,\r\n        double *l,\r\n        const ptrdiff_t *ldl,\r\n        ptrdiff_t *ipiv,\r\n        ptrdiff_t *oufact,\r\n        double *g,\r\n        const ptrdiff_t *ldg,\r\n        ptrdiff_t *iwork,\r\n        double *dwork,\r\n        const ptrdiff_t *ldwork,\r\n        ptrdiff_t *info\r\n        );\r\n\r\n// Conversion of optimal problems with coupling weighting terms to standard problems (more flexibility)\r\n#define sb02mx FORTRAN_WRAPPER(sb02mx)\r\nextern void sb02mx(\r\n        const char *jobg,\r\n        const char *jobl,\r\n        const char *fact,\r\n        const char *uplo,\r\n        const char *trans,\r\n        const char *flag,\r\n        const char *def,\r\n        const ptrdiff_t *n,\r\n        const ptrdiff_t *m,\r\n        double *a,\r\n        const ptrdiff_t *lda,\r\n        double *b,\r\n        const ptrdiff_t *ldb,\r\n        double *q,\r\n        const ptrdiff_t *ldq,\r\n        double *r,\r\n        const ptrdiff_t *ldr,\r\n        double *l,\r\n        const ptrdiff_t *ldl,\r\n        ptrdiff_t *ipiv,\r\n        ptrdiff_t *oufact,\r\n        double *g,\r\n        const ptrdiff_t *ldg,\r\n        ptrdiff_t *iwork,\r\n        double *dwork,\r\n        const ptrdiff_t *ldwork,\r\n        ptrdiff_t *info\r\n        );\r\n\r\n// Constructing the 2n-by-2n Hamiltonian or symplectic matrix for linear-quadratic optimization problems\r\n#define sb02mu FORTRAN_WRAPPER(sb02mu)\r\nextern void sb02mu(\r\n        const char *dico,\r\n        const char *hinv,\r\n        const char *uplo,\r\n        const ptrdiff_t *n,\r\n        double *a,\r\n        const ptrdiff_t *lda,\r\n        const double *g,\r\n        const ptrdiff_t *ldg,\r\n        const double *q,\r\n        const ptrdiff_t *ldq,\r\n        double *s,\r\n        const ptrdiff_t *lds,\r\n        ptrdiff_t *iwork,\r\n        double *dwork,\r\n        const ptrdiff_t *ldwork,\r\n        ptrdiff_t *info\r\n        );\r\n\r\n// Constructing the 2n-by-2n Hamiltonian or symplectic matrix for linear-quadratic optimization problems (improved)\r\n#define sb02ru FORTRAN_WRAPPER(sb02ru)\r\nextern void sb02ru(\r\n        const char *dico,\r\n        const char *hinv,\r\n        const char *trana,\r\n        const char *uplo,\r\n        const ptrdiff_t *n,\r\n        const double *a,\r\n        const ptrdiff_t *lda,\r\n        double *g,\r\n        const ptrdiff_t *ldg,\r\n        double *q,\r\n        const ptrdiff_t *ldq,\r\n        double *s,\r\n        const ptrdiff_t *lds,\r\n        ptrdiff_t *iwork,\r\n        double *dwork,\r\n        const ptrdiff_t *ldwork,\r\n        ptrdiff_t *info\r\n        );\r\n\r\n// Constructing the extended Hamiltonian or symplectic matrix pairs for linear-quadratic optimization problems, and compressing them to 2N-by-2N matrices\r\n#define sb02oy FORTRAN_WRAPPER(sb02oy)\r\nextern void sb02oy(\r\n        const char *type,\r\n        const char *dico,\r\n        const char *jobb,\r\n        const char *fact,\r\n        const char *uplo,\r\n        const char *jobl,\r\n        const char *jobe,\r\n        const ptrdiff_t *n,\r\n        const ptrdiff_t *m,        \r\n        const ptrdiff_t *p,        \r\n        const double *a,\r\n        const ptrdiff_t *lda,\r\n        const double *b,\r\n        const ptrdiff_t *ldb,        \r\n        const double *q,\r\n        const ptrdiff_t *ldq,\r\n        const double *r,\r\n        const ptrdiff_t *ldr,\r\n        const double *l,\r\n        const ptrdiff_t *ldl,\r\n        const double *e,\r\n        const ptrdiff_t *lde,\r\n        double *af,\r\n        const ptrdiff_t *ldaf,\r\n        double *bf,\r\n        const ptrdiff_t *ldbf,\r\n        double *tol,\r\n        ptrdiff_t *iwork,\r\n        double *dwork,\r\n        const ptrdiff_t *ldwork,\r\n        ptrdiff_t *info\r\n        );\r\n\r\n// Optimal state feedback matrix for an optimal control problem\r\n#define sb02nd FORTRAN_WRAPPER(sb02nd)\r\nextern void sb02nd(\r\n        const char *dico,\r\n        const char *fact,\r\n        const char *uplo,\r\n        const char *jobl,\r\n        const ptrdiff_t *n,\r\n        const ptrdiff_t *m,\r\n        const ptrdiff_t *p,\r\n        const double *a,\r\n        const ptrdiff_t *lda,\r\n        double *b,\r\n        const ptrdiff_t *ldb,\r\n        double *r,\r\n        const ptrdiff_t *ldr,\r\n        ptrdiff_t *ipiv,\r\n        const double *l,\r\n        const ptrdiff_t *ldl,\r\n        double *x,\r\n        const ptrdiff_t *ldx,\r\n        const double *rnorm,\r\n        double *f,\r\n        const ptrdiff_t *ldf,\r\n        ptrdiff_t *oufact,\r\n        ptrdiff_t *iwork,\r\n        double *dwork,\r\n        const ptrdiff_t *ldwork,\r\n        ptrdiff_t *info\r\n        );\r\n\r\n// Solution of continuous- or discrete-time algebraic Riccati equations for descriptor systems\r\n#define sg02nd FORTRAN_WRAPPER(sg02nd)\r\nextern void sg02nd(\r\n        const char *dico,\r\n        const char *jobe,\r\n        const char *job,\r\n        const char *jobx,\r\n        const char *fact,\r\n        const char *uplo,\r\n        const char *jobl,\r\n        const char *trans,\r\n        const ptrdiff_t *n,\r\n        const ptrdiff_t *m,        \r\n        const ptrdiff_t *p,\r\n        const double *a,\r\n        const ptrdiff_t *lda,\r\n        const double *e,\r\n        const ptrdiff_t *lde,\r\n        double *b,\r\n        const ptrdiff_t *ldb,\r\n        double *r,\r\n        const ptrdiff_t *ldr,\r\n        ptrdiff_t *ipiv,\r\n        const double *l,\r\n        const ptrdiff_t *ldl,\r\n        double *x,\r\n        const ptrdiff_t *ldx,\r\n        const double *rnorm,\r\n        double *k,\r\n        const ptrdiff_t *ldk,\r\n        double *h,\r\n        const ptrdiff_t *ldh,\r\n        double *xe,\r\n        const ptrdiff_t *ldxe,\r\n        ptrdiff_t *oufact,\r\n        ptrdiff_t *iwork,\r\n        double *dwork,\r\n        const ptrdiff_t *ldwork,\r\n        ptrdiff_t *info\r\n        );\r\n\r\n\r\n// Column interchanges in a complex matrix\r\n#define ma02gz FORTRAN_WRAPPER(ma02gz)\r\nextern void ma02gz(\r\n        const ptrdiff_t *n,\r\n        double *a,\r\n        const ptrdiff_t *lda,\r\n        const ptrdiff_t *k1,\r\n        const ptrdiff_t *k2,\r\n        const ptrdiff_t *ipiv,\r\n        const ptrdiff_t *incx\r\n        );\r\n\r\n\r\n// Solution of linear equations X op(A) = B\r\n#define mb02vd FORTRAN_WRAPPER(mb02vd)\r\nextern void mb02vd(\r\n        const char *trans,\r\n        const ptrdiff_t *m,\r\n        const ptrdiff_t *n,\r\n        double *a,\r\n        const ptrdiff_t *lda,\r\n        ptrdiff_t *ipiv,\r\n        double *b,\r\n        const ptrdiff_t *ldb,\r\n        ptrdiff_t *info\r\n        );\r\n\r\n// Periodic Hessenberg form of a product of p matrices using orthogonal similarity transformations\r\n#define mb03vd FORTRAN_WRAPPER(mb03vd)\r\nextern void mb03vd(\r\n        const ptrdiff_t *n,\r\n        const ptrdiff_t *p,\r\n        const ptrdiff_t *ilo,\r\n        const ptrdiff_t *ihi,\r\n        double *a,\r\n        const ptrdiff_t *lda1,\r\n        const ptrdiff_t *lda2,\r\n        double *tau,\r\n        const ptrdiff_t *ldtau,\r\n        double *dwork,\r\n        ptrdiff_t *info\r\n        );\r\n\r\n// Orthogonal matrices for reduction to periodic Hessenberg form of a product of matrices\r\n#define mb03vy FORTRAN_WRAPPER(mb03vy)\r\nextern void mb03vy(\r\n        const ptrdiff_t *n,\r\n        const ptrdiff_t *p,\r\n        const ptrdiff_t *ilo,\r\n        const ptrdiff_t *ihi,\r\n        double *a,\r\n        const ptrdiff_t *lda1,\r\n        const ptrdiff_t *lda2,\r\n        double *tau,\r\n        const ptrdiff_t *ldtau,\r\n        double *dwork,\r\n        const ptrdiff_t *ldwork,\r\n        ptrdiff_t *info\r\n        );\r\n\r\n// Schur decomposition and eigenvalues of a product of matrices in periodic Hessenberg form\r\n#define mb03wd FORTRAN_WRAPPER(mb03wd)\r\nextern void mb03wd(\r\n        const char *job,\r\n        const char *compz,\r\n        const ptrdiff_t *n,\r\n        const ptrdiff_t *p,\r\n        const ptrdiff_t *ilo,\r\n        const ptrdiff_t *ihi,\r\n        const ptrdiff_t *iloz,\r\n        const ptrdiff_t *ihiz,\r\n        double *h,\r\n        const ptrdiff_t *ldh1,\r\n        const ptrdiff_t *ldh2,\r\n        double *z,\r\n        const ptrdiff_t *ldz1,\r\n        const ptrdiff_t *ldz2,\r\n        double *wr,\r\n        double *wi,\r\n        double *dwork,\r\n        const ptrdiff_t *ldwork,\r\n        ptrdiff_t *info\r\n        );\r\n\r\n\r\n// Computes the general product of K complex scalars trying to avoid over- and underflow. \r\n#define zlapr1 FORTRAN_WRAPPER(zlapr1)\r\nextern int zlapr1(\r\n        doublereal *base, \r\n        integer *k, \r\n        integer *s, \r\n        doublecomplex *a, \r\n        integer *inca, \r\n        doublecomplex *alpha, \r\n        doublecomplex *beta, \r\n        integer *scal\r\n        );\r\n\r\n// Finding the eigenvalues of the complex generalized matrix product. \r\n#define zpgeqz FORTRAN_WRAPPER(zpgeqz)\r\nextern int zpgeqz(\r\n        char *job, \r\n        char *compq, \r\n        integer *k, \r\n        integer *n,\t\r\n        integer *ilo, \r\n        integer *ihi, \r\n        integer *s, \r\n        doublecomplex *a, \r\n        integer *lda1, \r\n        integer *lda2, \r\n        doublecomplex *alpha, \r\n        doublecomplex *beta,\r\n        integer *scal,\r\n        doublecomplex *q,\r\n        integer *ldq1,\r\n        integer *ldq2,\r\n        doublereal *dwork,\r\n        integer *ldwork,\r\n        doublecomplex *zwork,\r\n        integer *lzwork, \r\n        integer *info\r\n        );\r\n\r\n// Swaps adjacent diagonal 1-by-1 blocks in a complex generalized matrix product. \r\n#define zpgex2 FORTRAN_WRAPPER(zpgex2)\r\nextern int zpgex2(\r\n        logical *wantq, \r\n        integer *k, \r\n        integer *n, \r\n        integer *j, \r\n        integer *s, \r\n        doublecomplex *a, \r\n        integer *lda1, \r\n        integer *lda2, \r\n        doublecomplex *q, \r\n        integer *ldq1, \r\n        integer *ldq2, \r\n        doublecomplex *zwork,\r\n        integer *info\r\n        );\r\n\r\n// Swaps adjacent diagonal 1-by-1 blocks in a complex generalized matrix product. \r\n#define zpghrd FORTRAN_WRAPPER(zpghrd)\r\nextern int zpghrd(\r\n        char *compq, \r\n        integer *k, \r\n        integer *n, \r\n        integer *ilo, \r\n        integer *ihi, \r\n        integer *s, \r\n        doublecomplex *a, \r\n        integer *lda1, \r\n        integer *lda2, \r\n        doublecomplex *q, \r\n        integer *ldq1, \r\n        integer *ldq2, \r\n        doublereal *dwork, \r\n        integer *ldwork, \r\n        doublecomplex *zwork, \r\n        integer *lzwork, \r\n        integer *info\r\n        );\r\n\r\n// Reorders the periodic Schur decomposition of a complex generalized matrix product. \r\n#define zpgord FORTRAN_WRAPPER(zpgord)\r\nextern int zpgord(\r\n        logical *wantq, \r\n        integer *k, \r\n        integer *n, \r\n        integer *s, \r\n        logical *select, \r\n        doublecomplex *a, \r\n        integer *lda1, \r\n        integer *lda2, \r\n        doublecomplex *alpha,\r\n        doublecomplex *beta,\r\n        integer *scal, \r\n        doublecomplex *q, \r\n        integer *ldq1, \r\n        integer *ldq2, \r\n        integer *m,\r\n        doublecomplex *zwork,\r\n        integer *lzwork,\r\n        integer *info\r\n        );\r\n\r\n", "meta": {"hexsha": "ecf044e0dad5a907b905d22af3196620a6b91880", "size": 11689, "ext": "h", "lang": "C", "max_stars_repo_path": "dprex.h", "max_stars_repo_name": "iwoodsawyer/dpre", "max_stars_repo_head_hexsha": "515076c0b6b7c6643378427553b4c302dc29ed3b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-11-17T13:13:08.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-17T13:13:08.000Z", "max_issues_repo_path": "dprex.h", "max_issues_repo_name": "iwoodsawyer/dpre", "max_issues_repo_head_hexsha": "515076c0b6b7c6643378427553b4c302dc29ed3b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-12-25T15:47:07.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-03T21:11:59.000Z", "max_forks_repo_path": "dprex.h", "max_forks_repo_name": "iwoodsawyer/dpre", "max_forks_repo_head_hexsha": "515076c0b6b7c6643378427553b4c302dc29ed3b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.830952381, "max_line_length": 154, "alphanum_fraction": 0.5583026777, "num_tokens": 2993, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.5, "lm_q2_score": 0.03846619422289417, "lm_q1q2_score": 0.019233097111447085}}
{"text": "/* gsl_histogram2d_calloc_range.c\n * Copyright (C) 2000  Simone Piccardi\n *\n * This library is free software; you can redistribute it and/or\n * modify it under the terms of the GNU General Public License as\n * published by the Free Software Foundation; either version 3 of the\n * License, or (at your option) any later version.\n *\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License along\n * with this library; if not, write to the Free Software Foundation, Inc.,\n * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n/***************************************************************\n *\n * File gsl_histogram2d_calloc_range.c: \n * Routine to create a variable binning 2D histogram providing \n * the input range vectors. Need GSL library and header.\n * Do range check and allocate the histogram data. \n *\n * Author: S. Piccardi\n * Jan. 2000\n *\n ***************************************************************/\n#include <config.h>\n#include <stdlib.h>\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_histogram2d.h>\n/*\n * Routine that create a 2D histogram using the given \n * values for X and Y ranges\n */\ngsl_histogram2d *\ngsl_histogram2d_calloc_range (size_t nx, size_t ny,\n                              double *xrange,\n                              double *yrange)\n{\n  size_t i, j;\n  gsl_histogram2d *h;\n\n  /* check arguments */\n\n  if (nx == 0)\n    {\n      GSL_ERROR_VAL (\"histogram length nx must be positive integer\",\n                        GSL_EDOM, 0);\n    }\n\n  if (ny == 0)\n    {\n      GSL_ERROR_VAL (\"histogram length ny must be positive integer\",\n                        GSL_EDOM, 0);\n    }\n\n  /* init ranges */\n\n  for (i = 0; i < nx; i++)\n    {\n      if (xrange[i] >= xrange[i + 1])\n        {\n          GSL_ERROR_VAL (\"histogram xrange not in increasing order\",\n                            GSL_EDOM, 0);\n        }\n    }\n\n  for (j = 0; j < ny; j++)\n    {\n      if (yrange[j] >= yrange[j + 1])\n        {\n          GSL_ERROR_VAL (\"histogram yrange not in increasing order\"\n                            ,GSL_EDOM, 0);\n        }\n    }\n\n  /* Allocate histogram  */\n\n  h = (gsl_histogram2d *) malloc (sizeof (gsl_histogram2d));\n\n  if (h == 0)\n    {\n      GSL_ERROR_VAL (\"failed to allocate space for histogram struct\",\n                        GSL_ENOMEM, 0);\n    }\n\n  h->xrange = (double *) malloc ((nx + 1) * sizeof (double));\n\n  if (h->xrange == 0)\n    {\n      /* exception in constructor, avoid memory leak */\n      free (h);\n\n      GSL_ERROR_VAL (\"failed to allocate space for histogram xrange\",\n                        GSL_ENOMEM, 0);\n    }\n\n  h->yrange = (double *) malloc ((ny + 1) * sizeof (double));\n\n  if (h->yrange == 0)\n    {\n      /* exception in constructor, avoid memory leak */\n      free (h);\n\n      GSL_ERROR_VAL (\"failed to allocate space for histogram yrange\",\n                        GSL_ENOMEM, 0);\n    }\n\n  h->bin = (double *) malloc (nx * ny * sizeof (double));\n\n  if (h->bin == 0)\n    {\n      /* exception in constructor, avoid memory leak */\n      free (h->xrange);\n      free (h->yrange);\n      free (h);\n\n      GSL_ERROR_VAL (\"failed to allocate space for histogram bins\",\n                        GSL_ENOMEM, 0);\n    }\n\n  /* init histogram */\n\n  /* init ranges */\n\n  for (i = 0; i <= nx; i++)\n    {\n      h->xrange[i] = xrange[i];\n    }\n\n  for (j = 0; j <= ny; j++)\n    {\n      h->yrange[j] = yrange[j];\n    }\n\n  /* clear contents */\n\n  for (i = 0; i < nx; i++)\n    {\n      for (j = 0; j < ny; j++)\n        {\n          h->bin[i * ny + j] = 0;\n        }\n    }\n\n  h->nx = nx;\n  h->ny = ny;\n\n  return h;\n}\n", "meta": {"hexsha": "6f14d8784e84ff2b4b8ee36e7a1410ea10df3118", "size": 3808, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/histogram/calloc_range2d.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/histogram/calloc_range2d.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/histogram/calloc_range2d.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 24.8888888889, "max_line_length": 74, "alphanum_fraction": 0.5430672269, "num_tokens": 989, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.29421497216298875, "lm_q2_score": 0.06371499869663867, "lm_q1q2_score": 0.01874590656789641}}
{"text": "/* this manages and calls function to execute function\n* from beginning to end\n*/\n#include <stdio.h>\n#include <string.h>\n#include <gsl/gsl_matrix.h>\n#include <gsl/gsl_eigen.h>\n#include <gsl/gsl_blas.h>\n#include <gsl/gsl_statistics.h>\n\n#include \"fileio.h\"\n#include \"data_process.h\"\n#include \"sensor_history.h\"\n#include \"sensor_validation.h\"\n\n#include \"externs.h\"\n\nvoid handle_files(char *, double*, double*);\nvoid sensor_validation(double*);\ndouble data_processing(double*);\n\nint sensor_number;\nint temperature_min = 30;\nint temperature_max = 60;\nint data_number;\nint group_number;\nfloat q_percent;\n\n/* path and names of the files used in the program\n* which include input file, output file and sensor history file */\nchar input_file_name[255] = \"../data/input_data/sample_input.csv\";\nchar history_file_name[255] = \"../data/sensor_history/sensor_history.csv\";\nchar output_file_name[255] = \"../data/output_data/output.csv\";\n\n\nint main() {\n\n    printf(\"\\nApplication is running....\\n\");\n    \n    /* user input for the number of sensors to process */\n    printf(\"Insert number of sensors:\");\n    scanf(\"%d\", &sensor_number);\n    \n    /* determining the time intervals for the sensors */\n    int time_interval;\n\n    printf(\"Insert collected time intervals:\");\n    scanf(\"%d\", &time_interval);\n\n    printf(\"Insert q percent(Should be 0~1):\");\n    scanf(\"%f\", &q_percent);\n\n    if ((q_percent<0) || (q_percent>1)) {\n        printf(\"Invalid q_percent! It will be regarded as 0.7 of default value.\\n\");\n        q_percent = 0.7;\n    }\n\n    double values[256];\n    double time_value[256];\n    double group_values[sensor_number];\n    \n    /* function performs reading of sensor data\n    * @input : file name\n    * @output : sensor time and associated values\n    */\n    handle_files(input_file_name, &time_value[0], &values[0]);\n\n    /* number of calculations to be performed based on the user input */\n    group_number = data_number / sensor_number;\n\n    for (int i = 0; i < group_number; i++) {\n        time_value[i] = time_value[i * sensor_number];\n    }\n\n    /* check whether the user input and actual file data matches */\n    if (group_number != time_interval) {\n        printf(\"ERROR: Time interval numbers, sensor numbers do not match with your input file!\\n\");\n        exit(0);\n    }\n\n    sensor_validation(&values[0]);\n\n    /* seperating multiple data computations in the output file*/\n    FILE *fpout = fopen(output_file_name, \"a\");\n    fprintf(fpout, \"--------------\\n\");\n    fclose(fpout);\n\n    FILE *fphis = fopen(history_file_name, \"a\");\n    fprintf(fphis, \"--------------\\n\");\n    fclose(fphis);\n\n    for (int i = 0 ; i < group_number; i++) {\n        for (int j = 0; j < sensor_number; j++) {\n            group_values[j]  = values[i*sensor_number + j];\n        }\n        printf(\"\\n---------------------Time interval %d---------------------\\n\\n\", i);\n        \n        double fused = data_processing(&group_values[0]);\n        float time_val_file = (float)time_value[i];\n        \n        write_data(time_val_file, fused, output_file_name);\n    }\n\n    \n\n    return 1;\n}\n\n/* function checks whether an attempt made to open a file is succuessful or not */\nvoid handle_files(char* input_file_name, double* time_value, double* values) {\n    printf(\"\\n\");\n    if (input_file_name != NULL) {\n        data_number = read_data(&time_value[0], &values[0], input_file_name);    \n\n        if ( data_number == -1 ) {\n            printf(\"ERROR: File open failed!\\n\");\n            exit(0);\n        } else if ( data_number == 0 ) {\n            printf(\"ERROR: Sensor numbers inserted and file are different!\\n\");\n            exit(0);\n        } else if ( data_number > 0) {\n            printf(\"Read data successfully!\\n\");\n        }    \n    } else {\n        printf(\"ERROR: Input file does not exist!\\n\");\n        exit(0);\n    }\n}\n\n/* function performs sensor validation for group values\n* @input : group Values\n*/\nvoid sensor_validation(double* group_values) {\n\n    int res = reading_validation(&group_values[0]);\n    if (res == 1) {\n        frozen_value_check(&group_values[0]);\n\n    }\n\n    if (res == 0) {\n        printf(\"ERROR: Temperature values are out of range! Check history file.\\n\");\n        frozen_value_check(&group_values[0]);\n    } \n\n}\n\n/* function performs sensor fusion algo using group Values\n* @input : group Values\n* @output : fused result\n*/\ndouble data_processing(double* group_values) {\n\n    printf(\"Sensor Values:\\n\");\n\n    for (int i = 0; i < sensor_number; i++) {\n        printf(\"x%d=%f, \", i, group_values[i]);\n    }\n    \n    /* Step 1: Calc the Support Degree Matrix */\n    gsl_matrix* D = gsl_matrix_alloc(sensor_number,sensor_number); \n    support_degree_generator(D, &group_values[0]);    //function in data_process.c to get D - Support Degree Matrix\n\n\n\n    /* Step 2: Calc eigenval & eigenvec */\n    gsl_matrix* T = gsl_matrix_alloc(sensor_number,sensor_number);\n    gsl_vector* evec = gsl_vector_alloc(sensor_number);\n    gsl_matrix* Temp = gsl_matrix_alloc(sensor_number,sensor_number);\n\n    gsl_matrix_memcpy(Temp, D);\n    eigenvec_calc(evec, T, Temp);    //function in data_process.c to get evec - eigen group_values & T - vectors\n\n\n\n    /* Step 3: Principal Comp Calc */\n    gsl_matrix* y = gsl_matrix_alloc(sensor_number,sensor_number);\n    principal_comp_calc(T, D, y);    //function in data_process.c to get T - Principal Components \n\n\n\n    /* Step 4: Calc the contri rate of the kth principal comp */\n    double alpha[sensor_number];\n    contri_rate_calc_kth(evec, &alpha[0]);    //function in data_process.c to get alpha\n\n\n\n    /* Step 5: Calc the contri rate of the m principal comp */\n    double phi[sensor_number];\n    major_contri_calc(&alpha[0], &phi[0]);    //function in data_process.c to get phi\n\n\n\n    /* Step 6: Compute the integrated support degree score */\n    gsl_vector* Z = gsl_vector_alloc(sensor_number);\n    integ_supp_score_calc(&alpha[0], y, Z);    //function in data_process.c to get z_i\n\n\n\n    /* Step 7-1: Eliminate incorrect data */\n    int sensor_correction[sensor_number];\n    elliminate_incorrect_data(Z, &sensor_correction[0]);    //function in data_process.c to elliminate incorrect datas\n\n\n\n    /* Step 7-2: Compute the weight coefficient for each sensor */\n    double omega[sensor_number];\n    weight_coeff_calc(Z, &sensor_correction[0], &omega[0]);     //function in data_process.c to get omega\n\n\n\n    /* Step 7-3: Compute the fused output */\n    double fused;\n    fused = fused_output(&omega[0], &group_values[0]);    //function in data_process.c to get fused output\n    printf(\"FINAL STEP: \\nThe fused output is %f\\n\", fused);\n\n\n\n    /* Free memory */\n    gsl_matrix_free(D);\n    gsl_matrix_free(Temp);\n    gsl_matrix_free(T);\n    gsl_vector_free(evec);\n    gsl_matrix_free(y);\n    gsl_vector_free(Z);\n\n    return fused;\n\n}\n", "meta": {"hexsha": "998861dcf45a18103bf8f05d19e68a57933d34fb", "size": 6779, "ext": "c", "lang": "C", "max_stars_repo_path": "src/main.c", "max_stars_repo_name": "karanbirsandhu/nu-sense", "max_stars_repo_head_hexsha": "83fd1fc4cbd053a4f9b673d5cd5841823ddd4d8b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/main.c", "max_issues_repo_name": "karanbirsandhu/nu-sense", "max_issues_repo_head_hexsha": "83fd1fc4cbd053a4f9b673d5cd5841823ddd4d8b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "src/main.c", "max_forks_repo_name": "karanbirsandhu/nu-sense", "max_forks_repo_head_hexsha": "83fd1fc4cbd053a4f9b673d5cd5841823ddd4d8b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.4739130435, "max_line_length": 118, "alphanum_fraction": 0.6481781974, "num_tokens": 1661, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4301473631961697, "lm_q2_score": 0.04336579830027346, "lm_q1q2_score": 0.01865368379175957}}
{"text": "#include \"jobqueue.h\"\r\n#include \"ance_degnome.h\"\r\n#include \"fitfunc.h\"\r\n#include \"flagparse.c\"\r\n#include <stdio.h>\r\n#include <string.h>\r\n#include <gsl/gsl_rng.h>\r\n#include <gsl/gsl_randist.h>\r\n#include <time.h>\r\n#include <pthread.h>\r\n#include <unistd.h>\r\n#include <limits.h>\r\n\r\ntypedef struct JobData JobData;\r\nstruct JobData {\r\n\tDegnome* child;\r\n\tDegnome* p1;\r\n\tDegnome* p2;\r\n};\r\n\r\nvoid usage(void);\r\nvoid help_menu(void);\r\nint jobfunc(void* p, void* tdat);\r\nvoid calculate_diversity(Degnome* generation, double** percent_decent, double* diversity);\r\n\r\nconst char* usageMsg =\r\n\t\"Usage: devosim [-bhrv] [-s | -u] [-c chromosome_length]\\n\"\r\n\t\"\\t\\t  [-e mutation_effect] [-g num_generations]\\n\"\r\n\t\"\\t\\t  [-m mutation_rate] [-o crossover_rate]\\n\"\r\n\t\"\\t\\t  [-p population_size] [-t num_threads]\\n\"\r\n\t\"\\t\\t  [--seed rngseed] [--target hat_height target]\\n\"\r\n\t\"\\t\\t  [--sqrt | --linear | --close | --ceiling | --log]\\n\";\r\n\r\nconst char* helpMsg =\r\n\t\"OPTIONS\\n\"\r\n\t\"\\t -b\\t Simulation will stop when all degnomes are identical.\\n\\n\"\r\n\t\"\\t -c chromosome_length\\n\"\r\n\t\"\\t\\t Set chromosome length for the current simulation.\\n\"\r\n\t\"\\t\\t Default chromosome length is 10.\\n\\n\"\r\n\t\"\\t -e mutation_effect\\n\"\r\n\t\"\\t\\t Set how much a mutation will effect a gene on average.\\n\"\r\n\t\"\\t\\t Default mutation effect is 2.\\n\\n\"\r\n\t\"\\t -g num_generations\\n\"\r\n\t\"\\t\\t Set how many generations this simulation will run for.\\n\"\r\n\t\"\\t\\t Default number of generations is 1000.\\n\\n\"\r\n\t\"\\t -h\\t Display this help menu.\\n\\n\"\r\n\t\"\\t -m mutation_rate\\n\"\r\n\t\"\\t\\t Set the mutation rate for the current simulation.\\n\"\r\n\t\"\\t\\t Default mutation rate is 1.\\n\\n\"\r\n\t\"\\t -o crossover_rate\\n\"\r\n\t\"\\t\\t Set the crossover rate for the current simulation.\\n\"\r\n\t\"\\t\\t Default crossover rate is 2.\\n\\n\"\r\n\t\"\\t -p population_size\\n\"\r\n\t\"\\t\\t Set the population size for the current simulation.\\n\"\r\n\t\"\\t\\t Default population size is 10.\\n\\n\"\r\n\t\"\\t -r\\t Only show percentages of descent from the original genomes.\\n\\n\"\r\n\t\"\\t -s\\t Degnome selection will occur.\\n\\n\"\r\n\t\"\\t -u\\t All degnomes contribute to two offspring.\\n\\n\"\r\n\t\"\\t -v\\t Output will be given for every generation.\\n\\n\"\r\n\t\"\\t -t num_threads\\n\"\r\n\t\"\\t\\t Select the number of threads to be used in the current run.\\n\"\r\n\t\"\\t\\t Default is 0 (which will result in 3/4 of cores being used).\\n\"\r\n\t\"\\t\\t Must be 1 if a seed is used in order to prevent race conditions.\\n\\n\"\r\n\t\"\\t --seed rngseed\\n\"\r\n\t\"\\t\\t Select the seed used by the RNG in the current run.\\n\"\r\n\t\"\\t\\t Default seed is 0 (which will result in a random seed).\\n\\n\"\r\n\t\"\\t --target hat_height target\\n\"\r\n\t\"\\t\\t Sets the ideal hat height for the current simulation\\n\"\r\n\t\"\\t\\t Used for fitness functions that have an \\\"ideal\\\" value.\\n\\n\"\r\n\t\"\\t --sqrt\\t\\t fitness will be sqrt(hat_height)\\n\\n\"\r\n\t\"\\t --linear\\t fitness will be hat_height\\n\\n\"\r\n\t\"\\t --close\\t fitness will be (target - abs(target - hat_height))\\n\\n\"\r\n\t\"\\t --ceiling\\t fitness will quickly level off after passing target\\n\\n\";\r\n\r\npthread_mutex_t seedLock = PTHREAD_MUTEX_INITIALIZER;\r\nunsigned long rngseed=0;\r\n\r\n//\tthere is no need for the line 'int chrom_size' as it is declared as a global variable in degnome.h\r\nint pop_size;\r\nint num_gens;\r\nint mutation_rate;\r\nint mutation_effect;\r\nint crossover_rate;\r\nint selective;\r\nint uniform;\r\nint verbose;\r\nint reduced;\r\nint break_at_zero_diversity;\r\n\r\nvoid usage(void) {\r\n\tfputs(usageMsg, stderr);\r\n\texit(EXIT_FAILURE);\r\n}\r\n\r\nvoid help_menu(void) {\r\n\tfputs(helpMsg, stderr);\r\n\texit(EXIT_FAILURE);\r\n}\r\n\r\nint num_threads = 0;\r\nJobQueue* jq;\r\n\r\nvoid *ThreadState_new(void *notused);\r\nvoid ThreadState_free(void *rng);\r\n\r\nvoid *ThreadState_new(void *notused) {\r\n\t// Lock seed, initialize random number generator, increment seed,\r\n\t// and unlock.\r\n\tgsl_rng *rng = gsl_rng_alloc(gsl_rng_taus);\r\n\r\n\tpthread_mutex_lock(&seedLock);\r\n\tgsl_rng_set(rng, rngseed);\r\n\trngseed = (rngseed == ULONG_MAX ? 0 : rngseed + 1);\r\n\tpthread_mutex_unlock(&seedLock);\r\n\r\n\treturn rng;\r\n}\r\n\r\nvoid ThreadState_free(void *rng) {\r\n\tgsl_rng_free((gsl_rng *) rng);\r\n}\r\n\r\nint jobfunc(void* p, void* tdat) {\r\n\tgsl_rng* rng = (gsl_rng*) tdat;\r\n\tJobData* data = (JobData*) p;\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t//get data out\r\n\tDegnome_mate(data->child, data->p1, data->p2, rng, mutation_rate, mutation_effect, crossover_rate);\t\t\t//mate\r\n\r\n\treturn 0;\t\t//exited without error\r\n}\r\n\r\nvoid calculate_diversity(Degnome* generation, double** percent_decent, double* diversity) {\r\n\t*diversity = 0;\r\n\tfor (int i = 0; i < pop_size; i++) {\t\t\t//calculate percent decent for each degnome\r\n\t\tfor (int j = 0; j < pop_size; j++) {\r\n\t\t\tpercent_decent[i][j] = 0;\r\n\t\t\tfor (int k = 0; k < chrom_size; k++) {\r\n\t\t\t\tif (generation[i].GOI_array[k] == j) {\r\n\t\t\t\t\tpercent_decent[i][j]++;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tpercent_decent[i][j] /= chrom_size;\r\n\t\t}\r\n\t}\r\n\tfor (int j = 0; j < pop_size; j++) {\t\t\t//sum and average\r\n\t\tpercent_decent[pop_size][j] = 0;\r\n\t\tfor (int k = 0; k < pop_size; k++) {\r\n\t\t\tpercent_decent[pop_size][j] += percent_decent[k][j];\r\n\t\t}\r\n\t\tpercent_decent[pop_size][j] /= pop_size;\r\n\t}\r\n\r\n\tfor (int i = 0; i < pop_size; i++) {\t\t\t//calculate percent diversity for the entire generation\r\n\t\tfor (int j = 0; j < pop_size; j++) {\r\n\t\t\tif (i == j) {\r\n\t\t\t\tcontinue;\r\n\t\t\t}\r\n\t\t\tfor (int k = 0; k < chrom_size; k++) {\r\n\t\t\t\tif (generation[i].GOI_array[k] != generation[j].GOI_array[k]) {\r\n\t\t\t\t\t(*diversity)++;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\t*diversity /= ((pop_size-1) * pop_size * chrom_size);\r\n}\r\n\r\nint main(int argc, char **argv) {\r\n\r\n\tint * flags = NULL;\r\n\r\n\tif (parse_flags(argc, argv, 3, &flags) == -1) {\r\n\t\tfree(flags);\r\n\t\tusage();\r\n\t}\r\n\r\n\tif (flags[2] == 1) {\r\n\t\tfree(flags);\r\n\t\thelp_menu();\r\n\t}\r\n\r\n\tbreak_at_zero_diversity = flags[1];\r\n\treduced = flags[3];\r\n\tverbose = flags[4];\r\n\tif (flags[5] == 1) {\r\n\t\tselective = 1;\r\n\t}\r\n\telse if (flags[5] == 2) {\r\n\t\tuniform = 1;\r\n\t}\r\n\tchrom_size = flags[6];\r\n\tmutation_effect = flags[7];\r\n\tnum_gens = flags[8];\r\n\tmutation_rate = flags[9];\r\n\tcrossover_rate = flags[10];\r\n\tpop_size = flags[11];\r\n\r\n\tnum_threads = flags[12];\r\n\r\n\tif(flags[13] == 0){\r\n\t\tset_function(\"linear\");\r\n\t}\r\n\telse if(flags[13] == 1){\r\n\t\tset_function(\"sqrt\");\r\n\t}\r\n\telse if(flags[13] == 2){\r\n\t\tset_function(\"close\");\r\n\t}\r\n\telse if(flags[13] == 3){\r\n\t\tset_function(\"ceiling\");\r\n\t}\r\n\telse if(flags[13] == 4){\r\n\t\tset_function(\"log\");\r\n\t}\r\n\r\n\ttarget_num = flags[14];\r\n\r\n\tif(flags[15] <= 0) {\r\n\t\ttime_t currtime = time(NULL);                  // time\r\n\t\tunsigned long pid = (unsigned long) getpid();  // process id\r\n\t\trngseed = currtime ^ pid;                      // random seed\r\n\t}\r\n\telse{\r\n\t\trngseed = flags[15];\r\n\t}\r\n\tgsl_rng* rng = gsl_rng_alloc(gsl_rng_taus);    // rand generator\r\n\tgsl_rng_set(rng, rngseed);\r\n\r\n\tfree(flags);\r\n\r\n\r\n\tif (num_threads <= 0) {\r\n\t\tif (num_threads < 0) {\r\n\t\t\t#ifdef DEBUG_MODE\r\n\t\t\t\tfprintf(stderr, \"Error invalid number of threads: %u\\n\", num_threads);\r\n\t\t\t#endif\r\n\t\t}\r\n\t\tnum_threads = (3*getNumCores()/4);\r\n\t}\r\n\t#ifdef DEBUG_MODE\r\n\t\tfprintf(stderr, \"Final number of threads: %u\\n\", num_threads);\r\n\t#endif\r\n\r\n\tDegnome* parents;\r\n\tDegnome* children;\r\n\tDegnome* temp;\r\n\r\n\tprintf(\"%u, %u, %u\\n\", chrom_size, pop_size, num_gens);\r\n\r\n\tparents = malloc(pop_size*sizeof(Degnome));\r\n\tchildren = malloc(pop_size*sizeof(Degnome));\r\n\r\n\tfor (int i = 0; i < pop_size; i++) {\r\n\t\tparents[i].dna_array = malloc(chrom_size*sizeof(double));\r\n\t\tparents[i].GOI_array = malloc(chrom_size*sizeof(int));\r\n\r\n\t\tchildren[i].dna_array = malloc(chrom_size*sizeof(double));\r\n\t\tchildren[i].GOI_array = malloc(chrom_size*sizeof(int));\r\n\r\n\t\tparents[i].hat_size = 0;\r\n\r\n\t\tfor (int j = 0; j < chrom_size; j++) {\r\n\t\t\tparents[i].dna_array[j] = 10;\t//children aren't initialized\r\n\t\t\tparents[i].hat_size += 10;\r\n\t\t\tparents[i].GOI_array[j] = (i);\t//track ancestries\r\n\t\t}\r\n\t}\r\n\r\n\tdouble* diversity;\r\n\tdouble** percent_decent;\r\n\r\n\tdiversity = malloc(sizeof(double));\r\n\t*diversity = 1;\r\n\tpercent_decent = malloc((pop_size+1)*sizeof(double*));\r\n\tfor (int i = 0; i < pop_size+1; i++) {\r\n\t\tpercent_decent[i] = malloc(pop_size*sizeof(double));\r\n\t\tif (i == pop_size) {\r\n\t\t\tcontinue;\r\n\t\t}\r\n\t\tfor (int j = 0; j < pop_size; j++) {\r\n\t\t\tif (i == j) {\r\n\t\t\t\tpercent_decent[i][j] = 1;\r\n\t\t\t}\r\n\t\t\telse {\r\n\t\t\t\tpercent_decent[i][j] = 0;\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tif (!reduced && !verbose) {\r\n\t\tprintf(\"\\nGeneration 0:\\n\\n\");\r\n\t\tfor (int i = 0; i < pop_size; i++) {\r\n\t\t\tprintf(\"Degnome %u allele values:\\n\", i);\r\n\t\t\tif (!reduced) {\r\n\t\t\t\tfor (int j = 0; j < chrom_size; j++) {\r\n\t\t\t\t\tprintf(\"%lf\\t\", parents[i].dna_array[j]);\r\n\t\t\t\t}\r\n\t\t\t\tprintf(\"\\n\");\r\n\t\t\t}\r\n\t\t\telse {\r\n\t\t\t\tprintf(\"%lf\\n\", parents[i].dna_array[0]);\r\n\t\t\t}\r\n\r\n\t\t\tprintf(\"Degnome %u ancestries:\\n\", i);\r\n\t\t\tif (!reduced) {\r\n\t\t\t\tfor (int j = 0; j < chrom_size; j++) {\r\n\t\t\t\t\tprintf(\"%u\\t\", parents[i].GOI_array[j]);\r\n\t\t\t\t}\r\n\t\t\t\tprintf(\"\\n\");\r\n\t\t\t}\r\n\t\t\telse {\r\n\t\t\t\tprintf(\"%u\\n\", parents[i].GOI_array[0]);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\tprintf(\"\\n\\n\");\r\n\r\n\tint final_gen;\r\n\tint broke_early = 0;\r\n\r\n\tjq = JobQueue_new(num_threads, NULL, ThreadState_new, ThreadState_free);\r\n\r\n\tJobData* dat = malloc(pop_size*sizeof(JobData));\r\n\r\n\tfor (int i = 0; i < num_gens; i++) {\r\n\t\tif (break_at_zero_diversity) {\r\n\t\t\tcalculate_diversity(parents, percent_decent, diversity);\r\n\t\t\tif ((*diversity) <= 0) {\r\n\t\t\t\tfinal_gen = i;\r\n\t\t\t\tbroke_early = 1;\r\n\t\t\t\tbreak;\r\n\t\t\t}\r\n\t\t}\r\n\t\tif (!uniform) {\r\n\t\t\tdouble fit;\r\n\t\t\tif (selective) {\r\n\t\t\t\tfit = get_fitness(parents[0].hat_size);\r\n\t\t\t}\r\n\t\t\telse {\r\n\t\t\t\tfit = 100;\t\t\t//in runs withoutslection, everybody is equally fit\r\n\t\t\t}\r\n\r\n\t\t\tdouble total_hat_size = fit;\r\n\t\t\tdouble cum_hat_size[pop_size];\r\n\t\t\tcum_hat_size[0] = fit;\r\n\r\n\t\t\tfor (int j = 1; j < pop_size; j++) {\r\n\t\t\t\tif (selective) {\r\n\t\t\t\t\tfit = get_fitness(parents[j].hat_size);\r\n\t\t\t\t}\r\n\t\t\t\telse {\r\n\t\t\t\t\tfit = 100;\r\n\t\t\t\t}\r\n\r\n\t\t\t\ttotal_hat_size += fit;\r\n\t\t\t\tcum_hat_size[j] = (cum_hat_size[j-1] + fit);\r\n\t\t\t}\r\n\r\n\t\t\tfor (int j = 0; j < pop_size; j++) {\r\n\r\n\t\t\t\tpthread_mutex_lock(&seedLock);\r\n\t\t\t\tgsl_rng_set(rng, rngseed);\r\n\t\t\t\trngseed = (rngseed == ULONG_MAX ? 0 : rngseed + 1);\r\n\t\t\t\tpthread_mutex_unlock(&seedLock);\r\n\r\n\t\t\t\tint m, d;\r\n\r\n\t\t\t\tdouble win_m = gsl_rng_uniform(rng);\r\n\t\t\t\twin_m *= total_hat_size;\r\n\t\t\t\tdouble win_d = gsl_rng_uniform(rng);\r\n\t\t\t\twin_d *= total_hat_size;\r\n\r\n\t\t\t\t// printf(\"win_m:%lf, wind:%lf, max: %lf\\n\", win_m,win_d,total_hat_size);\r\n\r\n\t\t\t\tfor (m = 0; cum_hat_size[m] < win_m; m++) {\r\n\t\t\t\t\tcontinue;\r\n\t\t\t\t}\r\n\r\n\t\t\t\tfor (d = 0; cum_hat_size[d] < win_d; d++) {\r\n\t\t\t\t\tcontinue;\r\n\t\t\t\t}\r\n\r\n\t\t\t\t// printf(\"m:%u, d:%u\\n\", m,d);\t\t\t\t\r\n\t\t\t\tdat[j].child = (children + j);\r\n\t\t\t\tdat[j].p1 = (parents + m);\r\n\t\t\t\tdat[j].p2 = (parents + d);\r\n\r\n\t\t\t\tJobQueue_addJob(jq, jobfunc, dat + j);\t\t\t}\r\n\t\t}\r\n\t\telse {\r\n\t\t\t// printf(\"uniform!!!\\n\");\r\n\r\n\t\t\tint moms[pop_size];\r\n\t\t\tint dads[pop_size];\r\n\t\t\tint mom_max = pop_size;\r\n\t\t\tint dad_max = pop_size;\r\n\r\n\t\t\tint m, d;\r\n\r\n\t\t\tfor (int j = 0; j < pop_size; j++) {\r\n\t\t\t\tmoms[j] = j;\r\n\t\t\t\tdads[j] = j;\r\n\t\t\t}\r\n\r\n\t\t\tfor (int j = 0; j < pop_size; j++) {\r\n\t\t\t\tpthread_mutex_lock(&seedLock);\r\n\t\t\t\tgsl_rng_set(rng, rngseed);\r\n\t\t\t\trngseed = (rngseed == ULONG_MAX ? 0 : rngseed + 1);\r\n\r\n\t\t\t\tpthread_mutex_unlock(&seedLock);\r\n\r\n\t\t\t\tint index_m = (int) gsl_rng_uniform_int (rng, mom_max);\r\n\t\t\t\tint index_d = (int) gsl_rng_uniform_int (rng, dad_max);\r\n\r\n\t\t\t\tm = moms[index_m];\r\n\t\t\t\td = dads[index_d];\r\n\r\n\t\t\t\t// printf(\"m:\\t%u\\nd:\\t%u\\n\", m, d);\r\n\r\n\t\t\t\t//reduce the pool of available degnomes\r\n\t\t\t\t//in order to make sure everybody get's two chances to mate\r\n\t\t\t\t//one as a dad and one as a mom\r\n\t\t\t\t\r\n\t\t\t\tint temp_m = moms[index_m];\r\n\t\t\t\tint temp_d = dads[index_d];\r\n\t\t\t\tmoms[index_m] = moms[mom_max-1];\r\n\t\t\t\tdads[index_d] = dads[dad_max-1];\r\n\t\t\t\tmoms[mom_max-1] = temp_m;\r\n\t\t\t\tdads[dad_max-1] = temp_d;\r\n\r\n\t\t\t\tmom_max--;\r\n\t\t\t\tdad_max--;\t\t\t\t\r\n\r\n\t\t\t\tdat[j].child = (children + j);\r\n\t\t\t\tdat[j].p1 = (parents + m);\r\n\t\t\t\tdat[j].p2 = (parents + d);\r\n\r\n\t\t\t\tJobQueue_addJob(jq, jobfunc, dat + j);\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\tJobQueue_waitOnJobs(jq);\r\n\r\n\t\ttemp = children;\r\n\t\tchildren = parents;\r\n\t\tparents = temp;\r\n\t\tif (verbose) {\r\n\t\t\tcalculate_diversity(parents, percent_decent, diversity);\r\n\t\t\tprintf(\"\\nGeneration %u:\\n\", i);\r\n\t\t\tif (!reduced) {\r\n\t\t\t\tfor (int k = 0; k < pop_size; k++) {\r\n\t\t\t\t\tprintf(\"\\n\\nDegnome %u allele values:\\n\", k);\r\n\r\n\t\t\t\t\tfor (int j = 0; j < chrom_size; j++) {\r\n\t\t\t\t\t\tprintf(\"%lf\\t\", parents[k].dna_array[j]);\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif (selective) {\r\n\t\t\t\t\t\tprintf(\"\\nTOTAL HAT SIZE: %lg\\n\\n\", parents[k].hat_size);\r\n\t\t\t\t\t}\r\n\t\t\t\t\telse {\r\n\t\t\t\t\t\tprintf(\"\\n\");\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tprintf(\"\\n\\nDegnome %u ancestries:\\n\", k);\r\n\t\t\t\t\tfor (int j = 0; j < chrom_size; j++) {\r\n\t\t\t\t\t\tprintf(\"%u\\t\", parents[k].GOI_array[j]);\r\n\t\t\t\t\t}\r\n\t\t\t\t\tprintf(\"\\n\");\r\n\r\n\t\t\t\t\tfor (int j = 0; j < pop_size; j++) {\r\n\t\t\t\t\t\tif (percent_decent[k][j] > 0) {\r\n\t\t\t\t\t\t\tprintf(\"%lf%% Degnome %u\\t\", (100*percent_decent[k][j]), j);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tprintf(\"\\nAverage population descent percentages:\\n\");\r\n\t\t\tfor (int j = 0; j < pop_size; j++) {\r\n\t\t\t\tif (percent_decent[pop_size][j] > 0) {\r\n\t\t\t\t\tprintf(\"%lf%% Degnome %u\\t\", (100*percent_decent[pop_size][j]), j);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tprintf(\"\\nPercent diversity: %lf\\n\", (100* (*diversity)));\r\n\t\tprintf(\"\\n\\n\");\r\n\t\t}\r\n\t}\r\n\r\n\tJobQueue_noMoreJobs(jq);\r\n\r\n\tif (verbose) {\r\n\t\tprintf(\"\\n\");\r\n\t}\r\n\r\n\tcalculate_diversity(parents, percent_decent, diversity);\r\n\t// printf(\"\\n\\n DIVERSITY%lf\\n\\n\\n\", *diversity);\r\n\tif (broke_early) {\r\n\t\tprintf(\"Generation %u:\\n\", final_gen);\r\n\t}\r\n\telse {\r\n\t\tprintf(\"Generation %u:\\n\", num_gens);\r\n\t}\r\n\tif (!reduced) {\r\n\t\tfor (int i = 0; i < pop_size; i++) {\r\n\t\t\tprintf(\"\\n\\nDegnome %u allele values:\\n\", i);\t\t\r\n\t\t\tif (!reduced) {\r\n\t\t\t\tfor (int j = 0; j < chrom_size; j++) {\r\n\t\t\t\t\tprintf(\"%lf\\t\", parents[i].dna_array[j]);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\r\n\t\t\tprintf(\"\\n\\nDegnome %u ancestries:\\n\", i);\r\n\t\t\tif (!reduced) {\r\n\t\t\t\tfor (int j = 0; j < chrom_size; j++) {\r\n\t\t\t\t\tprintf(\"%u\\t\", parents[i].GOI_array[j]);\r\n\t\t\t\t}\r\n\t\t\t\tprintf(\"\\n\");\r\n\t\t\t}\r\n\r\n\t\t\tfor (int j = 0; j < pop_size; j++) {\r\n\t\t\t\tif (percent_decent[i][j] > 0) {\r\n\t\t\t\t\tprintf(\"%lf%% Degnome %u\\t\", (100*percent_decent[i][j]), j);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tprintf(\"\\n\");\r\n\r\n\t\t\tif (selective) {\r\n\t\t\t\tprintf(\"\\nTOTAL HAT SIZE: %lg\\n\\n\", parents[i].hat_size);\r\n\t\t\t}\r\n\t\t\telse {\r\n\t\t\t\tprintf(\"\\n\\n\");\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\tprintf(\"Average population decent percentages:\\n\");\r\n\tfor (int j = 0; j < pop_size; j++) {\r\n\t\tif (percent_decent[pop_size][j] > 0) {\r\n\t\t\tprintf(\"%lf%% Degnome %u\\t\", (100*percent_decent[pop_size][j]), j);\r\n\t\t}\r\n\t}\r\n\tprintf(\"\\nPercent diversity: %lf\\n\", (100* (*diversity)));\r\n\tprintf(\"\\n\\n\\n\");\r\n\r\n\t//free everything\r\n\tJobQueue_free(jq);\r\n\tfree(dat);\r\n\r\n\tfor (int i = 0; i < pop_size; i++) {\r\n\t\tfree(parents[i].dna_array);\r\n\t\tfree(children[i].dna_array);\r\n\t\tfree(parents[i].GOI_array);\r\n\t\tfree(children[i].GOI_array);\r\n\t\tparents[i].hat_size = 0;\r\n\r\n\t\tfree(percent_decent[i]);\r\n\t}\r\n\tfree(percent_decent[pop_size]);\r\n\r\n\tfree(parents);\r\n\tfree(children);\r\n\r\n\tfree(percent_decent);\r\n\tfree(diversity);\r\n\r\n\tgsl_rng_free (rng);\r\n}\r\n", "meta": {"hexsha": "1866aa5e3a62c2d5f31f31d27da219d15160048e", "size": 14726, "ext": "c", "lang": "C", "max_stars_repo_path": "src/devosim.c", "max_stars_repo_name": "masalemi/PopGenSim", "max_stars_repo_head_hexsha": "86bbd44f9ad6b588253b6115c7064e91c2d0d76f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2018-08-14T20:45:40.000Z", "max_stars_repo_stars_event_max_datetime": "2019-02-01T18:53:36.000Z", "max_issues_repo_path": "src/devosim.c", "max_issues_repo_name": "masalemi/PopGenSim", "max_issues_repo_head_hexsha": "86bbd44f9ad6b588253b6115c7064e91c2d0d76f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 27.0, "max_issues_repo_issues_event_min_datetime": "2019-09-17T20:12:17.000Z", "max_issues_repo_issues_event_max_datetime": "2020-11-29T23:56:03.000Z", "max_forks_repo_path": "src/devosim.c", "max_forks_repo_name": "masalemi/PopGenSim", "max_forks_repo_head_hexsha": "86bbd44f9ad6b588253b6115c7064e91c2d0d76f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-04-27T23:28:50.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-27T23:28:50.000Z", "avg_line_length": 26.0637168142, "max_line_length": 110, "alphanum_fraction": 0.5907917968, "num_tokens": 4597, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.49218813572079556, "lm_q2_score": 0.037892427308664316, "lm_q1q2_score": 0.018650203154987253}}
{"text": "/*\n * C version of Diffusive Nested Sampling (DNest4) by Brendon J. Brewer\n *\n * Yan-Rong Li, liyanrong@mail.ihep.ac.cn\n * Jun 30, 2016\n *\n */\n\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <time.h>\n#include <unistd.h>\n#include <math.h>\n#include <float.h>\n#include <gsl/gsl_rng.h>\n#include <gsl/gsl_randist.h>\n\n#include \"dnestvars.h\"\n\ndouble dnest(int argc, char** argv, DNestFptrSet *fptrset, int num_params, \n             char *sample_dir, int max_num_saves, double ptol, const void *arg)\n{\n  int opt;\n  \n  dnest_arg = arg;\n  \n  dnest_check_fptrset(fptrset);\n\n  // cope with argv\n  \n  dnest_post_temp = 1.0;\n  dnest_flag_restart = 0;\n  dnest_flag_postprc = 0;\n  dnest_flag_sample_info = 0;\n  dnest_flag_limits = 0;\n\n  strcpy(file_save_restart, \"restart_dnest.txt\");\n  strcpy(dnest_sample_postfix, \"\\0\");\n  strcpy(dnest_sample_tag, \"\\0\");\n    \n  opterr = 0;\n  optind = 0;\n  while( (opt = getopt(argc, argv, \"r:s:pt:clx:g:\")) != -1)\n  {\n    switch(opt)\n    {\n      case 'r':\n        dnest_flag_restart = 1;\n        strcpy(file_restart, optarg);\n        printf(\"# Dnest restarts.\\n\");\n        break;\n      case 's':\n        strcpy(file_save_restart, optarg);\n        //printf(\"# Dnest sets restart file %s.\\n\", file_save_restart);\n        break;\n      case 'p':\n        dnest_flag_postprc = 1;\n        dnest_post_temp = 1.0;\n        printf(\"# Dnest does postprocess.\\n\");\n        break;\n      case 't':\n        dnest_post_temp = atof(optarg);\n        printf(\"# Dnest sets a temperature %f.\\n\", dnest_post_temp);\n        if(dnest_post_temp == 0.0)\n        {\n          printf(\"# Dnest incorrect option -t %s.\\n\", optarg);\n          exit(0);\n        }\n        if(dnest_post_temp < 1.0)\n        {\n          printf(\"# Dnest temperature should >= 1.0\\n\");\n          exit(0);\n        }\n        break;\n      case 'c':\n        dnest_flag_sample_info = 1;\n        printf(\"# Dnest recalculates sample information.\\n\");\n        break;\n      case 'l':\n        dnest_flag_limits = 1;\n        printf(\"# Dnest level-dependent sampling.\\n\");\n        break;\n      case 'x':\n        strcpy(dnest_sample_postfix, optarg);\n        printf(\"# Dnest sets sample postfix %s.\\n\", dnest_sample_postfix);\n        break;\n      case 'g':\n        strcpy(dnest_sample_tag, optarg);\n        printf(\"# Dnest sets sample tag %s.\\n\", dnest_sample_tag);\n        break;\n      case '?':\n        printf(\"# Dnest incorrect option -%c %s.\\n\", optopt, optarg);\n        exit(0);\n        break;\n      default:\n        break;\n    }\n  }\n  \n  setup(argc, argv, fptrset, num_params, sample_dir, max_num_saves, ptol);\n\n  if(dnest_flag_postprc == 1)\n  {\n    dnest_postprocess(dnest_post_temp, max_num_saves, ptol);\n    finalise();\n    return post_logz;\n  }\n\n  if(dnest_flag_sample_info == 1)\n  {\n    dnest_postprocess(dnest_post_temp, max_num_saves, ptol);\n    finalise();\n    return post_logz;\n  }\n\n  if(dnest_flag_restart==1)\n    dnest_restart();\n\n  initialize_output_file();\n  dnest_run();\n  close_output_file();\n\n  dnest_postprocess(dnest_post_temp, max_num_saves, ptol);\n\n  finalise();\n  \n  return post_logz;\n}\n\n// postprocess, calculate evidence, generate posterior sample.\nvoid dnest_postprocess(double temperature, int max_num_saves, double ptol)\n{\n  options_load(max_num_saves, ptol);\n  postprocess(temperature);\n}\n\nvoid dnest_run()\n{\n  int i, j, k, size_all_above_incr;\n  Level *pl, *levels_orig;\n  int *buf_size_above, *buf_displs;\n  double *plimits;\n  \n  printf(\"# Start diffusive nested sampling.\\n\");\n\n  while(true)\n  {\n    //check for termination\n    if(options.max_num_saves !=0 &&\n        count_saves != 0 && (count_saves%options.max_num_saves == 0))\n      break;\n\n    dnest_mcmc_run();\n\n    count_mcmc_steps += options.thread_steps;\n    \n    if(dnest_flag_limits == 1)\n    {\n      // limits of smaller levels should be larger than those of higher levels\n      for(j=size_levels-2; j >= 0; j--)\n        for(k=0; k<particle_offset_double; k++)\n        {\n          limits[ j * particle_offset_double *2 + k*2 ] = fmin( limits[ j * particle_offset_double *2 + k*2 ],\n                  limits[ (j+1) * particle_offset_double *2 + k*2 ] );\n          limits[ j * particle_offset_double *2 + k*2 + 1] = fmax( limits[ j * particle_offset_double *2 + k*2 +1 ],\n                  limits[ (j+1) * particle_offset_double *2 + k*2 + 1 ] );\n        }\n    }\n\n    do_bookkeeping();\n\n    if(count_mcmc_steps >= (count_saves + 1)*options.save_interval)\n    {\n      save_particle();\n\n      // save levels, limits, sync samples when running a number of steps\n      if( count_saves % num_saves == 0 )\n      {\n        if(size_levels <= options.max_num_levels)\n        {\n          save_levels();\n\n          printf(\"# Save levels at N= %d.\\n\", count_saves);\n        }\n        if(dnest_flag_limits == 1)\n          save_limits();\n        fflush(fsample_info);\n        fsync(fileno(fsample_info));\n        fflush(fsample);\n        fsync(fileno(fsample));\n        printf(\"# Save limits, and sync samples at N= %d.\\n\", count_saves);\n      }\n\n      //if( count_saves % num_saves_restart == 0 )\n      //{\n      //  dnest_save_restart();\n      //}\n    }\n  }\n  \n  //dnest_save_restart();\n\n  //save levels\n  save_levels();\n  if(dnest_flag_limits == 1)\n    save_limits();\n\n  /* output state of sampler */\n  FILE *fp;\n  fp = fopen(options.sampler_state_file, \"w\");\n  fprintf(fp, \"%d %d\\n\", size_levels, count_saves);\n  fclose(fp);\n}\n\nvoid do_bookkeeping()\n{\n  int i;\n  //bool created_level = false;\n\n  if(!enough_levels(levels, size_levels) && size_above >= options.new_level_interval)\n  {\n    // in descending order \n    qsort(above, size_above, sizeof(LikelihoodType), dnest_cmp);\n    int index = (int)( (1.0/compression) * size_above);\n\n    Level level_tmp = {above[index], 0.0, 0, 0, 0, 0};\n    levels[size_levels] = level_tmp;\n    size_levels++;\n    \n    printf(\"# Creating level %d with log likelihood = %e.\\n\", \n               size_levels-1, levels[size_levels-1].log_likelihood.value);\n\n    // clear out the last index records\n    for(i=index; i<size_above; i++)\n    {\n      above[i].value = 0.0;\n      above[i].tiebreaker = 0.0;\n    }\n    size_above = index;\n\n    if(enough_levels(levels, size_levels))\n    {\n      renormalise_visits();\n      options.max_num_levels = size_levels;\n      printf(\"# Done creating levles.\\n\");\n    }\n    else\n    {\n      kill_lagging_particles();\n    }\n  }\n  recalculate_log_X();\n}\n\nvoid recalculate_log_X()\n{\n  int i;\n\n  levels[0].log_X = 0.0;\n  for(i=1; i<size_levels; i++)\n  {\n    levels[i].log_X = levels[i-1].log_X \n    + log( (double)( (levels[i-1].exceeds + 1.0/compression * regularisation)\n                    /(levels[i-1].visits + regularisation)  ) );\n  }\n}\n\nvoid renormalise_visits()\n{\n  size_t i;\n\n  for(i=0; i<size_levels; i++)\n  {\n    if(levels[i].tries >= regularisation)\n    {\n      levels[i].accepts = ((double)(levels[i].accepts+1) / (double)(levels[i].tries+1)) * regularisation;\n      levels[i].tries = regularisation;\n    }\n\n    if(levels[i].visits >= regularisation)\n    {\n      levels[i].exceeds = ( (double) (levels[i].exceeds+1) / (double)(levels[i].visits + 1) ) * regularisation;\n      levels[i].visits = regularisation;\n    }\n  }\n}\n\nvoid kill_lagging_particles()\n{\n  static unsigned int deletions = 0;\n\n  bool *good;\n  good = (bool *)malloc(options.num_particles * sizeof(bool));\n\n  double max_log_push = -DBL_MAX;\n\n  double kill_probability = 0.0;\n  unsigned int num_bad = 0;\n  size_t i;\n\n  for(i=0; i<options.num_particles; i++)good[i] = true;\n\n  for(i=0; i<options.num_particles; i++)\n  {\n    if( log_push(level_assignments[i]) > max_log_push)\n      max_log_push = log_push(level_assignments[i]);\n\n    kill_probability = pow(1.0 - 1.0/(1.0 + exp(-log_push(level_assignments[i]) - 4.0)), 3);\n    if(gsl_rng_uniform(dnest_gsl_r) <= kill_probability)\n    {\n      good[i] = false;\n      ++num_bad;\n    }\n  }\n\n  if(num_bad < options.num_particles)\n  {\n    for(i=0; i< options.num_particles; i++)\n    {\n      if(!good[i])\n      {\n        int i_copy;\n        do\n        {\n          i_copy = gsl_rng_uniform_int(dnest_gsl_r, options.num_particles);\n        }while(!good[i_copy] || gsl_rng_uniform(dnest_gsl_r) >= exp(log_push(level_assignments[i_copy]) - max_log_push));\n\n        memcpy(particles+i*particle_offset_size, particles + i_copy*particle_offset_size, dnest_size_of_modeltype);\n        log_likelihoods[i] = log_likelihoods[i_copy];\n        level_assignments[i] = level_assignments[i_copy];\n         \n        kill_action(i, i_copy);\n\n        deletions++;\n\n        printf(\"# Replacing lagging particle.\\n\");\n        printf(\"# This has happened %d times.\\n\", deletions);\n      }\n    }\n  }\n  else\n    printf(\"# Warning: all particles lagging!.\\n\");\n\n  free(good);\n}\n\n/* save levels */\nvoid save_levels()\n{\n  if(!save_to_disk)\n    return;\n  \n  int i;\n  FILE *fp;\n\n  fp = fopen(options.levels_file, \"w\");\n  fprintf(fp, \"# log_X, log_likelihood, tiebreaker, accepts, tries, exceeds, visits\\n\");\n  for(i=0; i<size_levels; i++)\n  {\n    fprintf(fp, \"%14.12g %14.12g %f %llu %llu %llu %llu\\n\", levels[i].log_X, levels[i].log_likelihood.value, \n      levels[i].log_likelihood.tiebreaker, levels[i].accepts,\n      levels[i].tries, levels[i].exceeds, levels[i].visits);\n  }\n  fclose(fp);\n\n  /* update state of sampler */\n  fp = fopen(options.sampler_state_file, \"w\");\n  fprintf(fp, \"%d %d\\n\", size_levels, count_saves);\n  fclose(fp);\n}\n\nvoid save_limits()\n{\n  int i, j;\n  FILE *fp;\n\n  fp = fopen(options.limits_file, \"w\");\n  for(i=0; i<size_levels; i++)\n  {\n    fprintf(fp, \"%d  \", i);\n    for(j=0; j<particle_offset_double; j++)\n      fprintf(fp, \"%f  %f  \", limits[i*2*particle_offset_double+j*2], limits[i*2*particle_offset_double+j*2+1]);\n\n    fprintf(fp, \"\\n\");\n  }\n  fclose(fp);\n}\n\n/* save particle */\nvoid save_particle()\n{\n  count_saves++;\n\n  if(!save_to_disk)\n    return;\n  \n  int whichparticle, whichtask;\n  void *particle_message;\n  \n  if(count_saves%10 == 0)\n    printf(\"#[%.1f%%] Saving sample N= %d.\\n\", 100.0*count_saves/options.max_num_saves, count_saves);\n    \n  whichparticle =  gsl_rng_uniform_int(dnest_gsl_r,options.num_particles);\n\n  print_particle(fsample, particles + whichparticle * particle_offset_size, dnest_arg);\n\n  fprintf(fsample_info, \"%d %e %f %d\\n\", level_assignments[whichparticle], \n        log_likelihoods[whichparticle].value,\n        log_likelihoods[whichparticle].tiebreaker,\n        whichparticle);\n}\n\nvoid dnest_mcmc_run()\n{\n  unsigned int which;\n  unsigned int i;\n  \n  for(i = 0; i<options.thread_steps; i++)\n  {\n\n    /* randomly select out one particle to update */\n    which = gsl_rng_uniform_int(dnest_gsl_r, options.num_particles);\n\n    dnest_which_particle_update = which;\n\n    //if(count_mcmc_steps >= 10000)printf(\"FFFF\\n\");\n    //printf(\"%d\\n\", which);\n    //printf(\"%f %f %f\\n\", particles[which].param[0], particles[which].param[1], particles[which].param[2]);\n    //printf(\"level:%d\\n\", level_assignments[which]);\n    //printf(\"%e\\n\", log_likelihoods[which].value);\n\n    if(gsl_rng_uniform(dnest_gsl_r) <= 0.5)\n    {\n      update_particle(which);\n      update_level_assignment(which);\n    }\n    else\n    {\n      update_level_assignment(which);\n      update_particle(which);\n    }\n        \n    if( !enough_levels(levels, size_levels)  && levels[size_levels-1].log_likelihood.value < log_likelihoods[which].value)\n    {\n      above[size_above] = log_likelihoods[which];\n      size_above++;\n    }\n  }\n}\n\n\nvoid update_particle(unsigned int which)\n{\n  void *particle = particles+ which*particle_offset_size;\n  LikelihoodType *logl = &(log_likelihoods[which]);\n  \n  Level *level = &(levels[level_assignments[which]]);\n\n  void *proposal = (void *)malloc(dnest_size_of_modeltype);\n  LikelihoodType logl_proposal;\n  double log_H;\n\n  memcpy(proposal, particle, dnest_size_of_modeltype);\n  dnest_which_level_update = level_assignments[which];\n  \n  log_H = perturb(proposal, dnest_arg);\n  \n  logl_proposal.value = log_likelihoods_cal(proposal, dnest_arg);\n  logl_proposal.tiebreaker =  (*logl).tiebreaker + gsl_rng_uniform(dnest_gsl_r);\n  dnest_wrap(&logl_proposal.tiebreaker, 0.0, 1.0);\n  \n  if(log_H > 0.0)\n    log_H = 0.0;\n\n  dnest_perturb_accept[which] = 0;\n  if( gsl_rng_uniform(dnest_gsl_r) <= exp(log_H) && level->log_likelihood.value < logl_proposal.value)\n  {\n    memcpy(particle, proposal, dnest_size_of_modeltype);\n    memcpy(logl, &logl_proposal, sizeof(LikelihoodType));\n    level->accepts++;\n\n    dnest_perturb_accept[which] = 1;\n    accept_action();\n    account_unaccepts[which] = 0; /* reset the number of unaccepted perturb */\n  }\n  else \n  {\n    account_unaccepts[which] += 1; /* number of unaccepted perturb */\n  }\n  level->tries++;\n  \n  unsigned int current_level = level_assignments[which];\n  for(; current_level < size_levels-1; ++current_level)\n  {\n    levels[current_level].visits++;\n    if(levels[current_level+1].log_likelihood.value < log_likelihoods[which].value)\n      levels[current_level].exceeds++;\n    else\n      break; // exit the loop if it does not satify higher levels\n  }\n  free(proposal);\n}\n\nvoid update_level_assignment(unsigned int which)\n{\n  int i;\n\n  int proposal = level_assignments[which] \n                 + (int)( pow(10.0, 2*gsl_rng_uniform(dnest_gsl_r))*gsl_ran_ugaussian(dnest_gsl_r));\n\n  if(proposal == level_assignments[which])\n    proposal =  ((gsl_rng_uniform(dnest_gsl_r) < 0.5)?(proposal-1):(proposal+1));\n\n  proposal=mod_int(proposal, size_levels);\n\n  double log_A = -levels[proposal].log_X + levels[level_assignments[which]].log_X;\n\n  log_A += log_push(proposal) - log_push(level_assignments[which]);\n\n  if(size_levels == options.max_num_levels)\n    log_A += options.beta*log( (double)(levels[level_assignments[which]].tries +1)/ (levels[proposal].tries +1) );\n\n  if(log_A > 0.0)\n    log_A = 0.0;\n\n  if( gsl_rng_uniform(dnest_gsl_r) <= exp(log_A) && levels[proposal].log_likelihood.value < log_likelihoods[which].value)\n  {\n    level_assignments[which] = proposal;\n\n// update the limits of the level\n    if(dnest_flag_limits == 1)\n    {\n      double *particle = (double *) (particles+ which*particle_offset_size);\n      for(i=0; i<particle_offset_double; i++)\n      {\n        limits[proposal * 2 * particle_offset_double +  i*2] = \n            fmin(limits[proposal * 2* particle_offset_double +  i*2], particle[i]);\n        limits[proposal * 2 * particle_offset_double +  i*2+1] = \n            fmax(limits[proposal * 2 * particle_offset_double +  i*2+1], particle[i]);\n      }\n    }\n\n  }\n\n}\n\ndouble log_push(unsigned int which_level)\n{\n  if(which_level > size_levels)\n  {\n    printf(\"level overflow %d %d.\\n\", which_level, size_levels);\n    exit(0);\n  }\n  if(enough_levels(levels, size_levels))\n    return 0.0;\n\n  int i = which_level - (size_levels - 1);\n  return ((double)i)/options.lambda;\n}\n\nbool enough_levels(Level *l, int size_l)\n{\n  int i;\n\n  if(options.max_num_levels == 0)\n  {\n    if(size_l >= LEVEL_NUM_MAX)\n      return true;\n\n    if(size_l < 10)\n      return false;\n\n    int num_levels_to_check = 20;\n    if(size_l > 80)\n      num_levels_to_check = (int)(sqrt(20) * sqrt(0.25*size_l));\n\n    int k = size_l - 1, kc = 0;\n    double tot = 0.0;\n    double max = -DBL_MAX;\n    double diff;\n\n    for(i= 0; i<num_levels_to_check; i++)\n    {\n      diff = l[k].log_likelihood.value - l[k-1].log_likelihood.value;\n      tot += diff;\n      if(diff > max)\n        max = diff;\n\n      k--;\n      kc++;\n      if( k < 1 )\n        break;\n    }\n    if(tot/kc < options.max_ptol && max < options.max_ptol*1.1)\n      return true;\n    else\n      return false;\n  }\n  return (size_l >= options.max_num_levels);\n}\n\nvoid initialize_output_file()\n{\n  if(dnest_flag_restart !=1)\n    fsample = fopen(options.sample_file, \"w\");\n  else\n    fsample = fopen(options.sample_file, \"a\");\n  \n  if(fsample==NULL)\n  {\n    fprintf(stderr, \"# Cannot open file sample.txt.\\n\");\n    exit(0);\n  }\n  if(dnest_flag_restart != 1)\n    fprintf(fsample, \"# \\n\");\n\n  if(dnest_flag_restart != 1)\n    fsample_info = fopen(options.sample_info_file, \"w\");\n  else\n    fsample_info = fopen(options.sample_info_file, \"a\");\n\n  if(fsample_info==NULL)\n  {\n    fprintf(stderr, \"# Cannot open file %s.\\n\", options.sample_info_file);\n    exit(0);\n  }\n  if(dnest_flag_restart != 1)\n    fprintf(fsample_info, \"# level assignment, log likelihood, tiebreaker, ID.\\n\");\n}\n\nvoid close_output_file()\n{\n  fclose(fsample);\n  fclose(fsample_info);\n}\n\nvoid setup(int argc, char** argv, DNestFptrSet *fptrset, int num_params, char *sample_dir, int max_num_saves, double ptol)\n{\n  int i, j;\n\n  // root task.\n  dnest_root = 0;\n\n  // setup function pointers\n  from_prior = fptrset->from_prior;\n  log_likelihoods_cal = fptrset->log_likelihoods_cal;\n  log_likelihoods_cal_initial = fptrset->log_likelihoods_cal_initial;\n  log_likelihoods_cal_restart = fptrset->log_likelihoods_cal_restart;\n  perturb = fptrset->perturb;\n  print_particle = fptrset->print_particle;\n  read_particle = fptrset->read_particle;\n  restart_action = fptrset->restart_action;\n  accept_action = fptrset->accept_action;\n  kill_action = fptrset->kill_action;\n  strcpy(dnest_sample_dir, sample_dir);\n\n  // random number generator\n  dnest_gsl_T = (gsl_rng_type *) gsl_rng_default;\n  dnest_gsl_r = gsl_rng_alloc (dnest_gsl_T);\n#ifndef Debug\n  gsl_rng_set(dnest_gsl_r, time(NULL));\n#else\n  gsl_rng_set(dnest_gsl_r, 9999);\n  printf(\"# debugging, dnest random seed %d\\n\", 9999);\n#endif  \n  \n  dnest_num_params = num_params;\n  dnest_size_of_modeltype = dnest_num_params * sizeof(double);\n\n  // read options\n  options_load(max_num_saves, ptol);\n\n  //dnest_post_temp = 1.0;\n  compression = exp(1.0);\n  regularisation = options.new_level_interval*sqrt(options.lambda);\n  save_to_disk = true;\n\n  // particles\n  particle_offset_size = dnest_size_of_modeltype/sizeof(void);\n  particle_offset_double = dnest_size_of_modeltype/sizeof(double);\n  particles = (void *)malloc(options.num_particles*dnest_size_of_modeltype);\n  \n  // initialise sampler\n  above = (LikelihoodType *)malloc(2*options.new_level_interval * sizeof(LikelihoodType));\n\n  log_likelihoods = (LikelihoodType *)malloc(2*options.num_particles * sizeof(LikelihoodType));\n  level_assignments = (unsigned int*)malloc(options.num_particles * sizeof(unsigned int));\n\n  account_unaccepts = (unsigned int *)malloc(options.num_particles * sizeof(unsigned int));\n  for(i=0; i<options.num_particles; i++)\n  {\n    account_unaccepts[i] = 0;\n  }\n\n  if(options.max_num_levels != 0)\n  {\n    levels = (Level *)malloc(options.max_num_levels * sizeof(Level));\n    if(dnest_flag_limits == 1)\n    {\n      limits = malloc(options.max_num_levels * particle_offset_double * 2 * sizeof(double));\n      for(i=0; i<options.max_num_levels; i++)\n      {\n        for(j=0; j<particle_offset_double; j++)\n        {\n          limits[i*2*particle_offset_double+ j*2] = DBL_MAX;\n          limits[i*2*particle_offset_double + j*2 + 1] = -DBL_MAX;\n        }\n      }\n    }\n  }\n  else\n  {\n    levels = (Level *)malloc(LEVEL_NUM_MAX * sizeof(Level));\n\n    if(dnest_flag_limits == 1)\n    {\n      limits = malloc(LEVEL_NUM_MAX * particle_offset_double * 2 * sizeof(double));\n      for(i=0; i<LEVEL_NUM_MAX; i++)\n      {\n        for(j=0; j<particle_offset_double; j++)\n        {\n          limits[i*2*particle_offset_double + j*2] = DBL_MAX;\n          limits[i*2*particle_offset_double + j*2 + 1] = -DBL_MAX;\n        }\n      }\n    }\n  }\n  \n  dnest_perturb_accept = malloc(options.num_particles * sizeof(int));\n  for(i=0; i<options.num_particles; i++)\n  {\n    dnest_perturb_accept[i] = 0;\n  }\n\n  count_mcmc_steps = 0;\n  count_saves = 0;\n  num_saves = (int)fmax(0.02*options.max_num_saves, 1.0);\n  num_saves_restart = (int)fmax(0.2 * options.max_num_saves, 1.0);\n\n// first level\n  size_levels = 0;\n  size_above = 0;\n  LikelihoodType like_tmp = {-DBL_MAX, gsl_rng_uniform(dnest_gsl_r)};\n  Level level_tmp = {like_tmp, 0.0, 0, 0, 0, 0};\n  levels[size_levels] = level_tmp;\n  size_levels++;\n  \n  for(i=0; i<options.num_particles; i++)\n  {\n    dnest_which_particle_update = i;\n    dnest_which_level_update = 0;\n    from_prior(particles+i*particle_offset_size, dnest_arg);\n    log_likelihoods[i].value = log_likelihoods_cal_initial(particles+i*particle_offset_size, dnest_arg);\n    log_likelihoods[i].tiebreaker = dnest_rand();\n    level_assignments[i] = 0;\n  }\n\n  /*ModelType proposal;\n  printf(\"%f %f %f \\n\", particles[0].param[0], particles[0].param[1], particles[0].param[2] );\n  proposal = particles[0];\n  printf(\"%f %f %f \\n\", proposal.param[0], proposal.param[1], proposal.param[2] );*/\n}\n\nvoid finalise()\n{\n  free(particles);\n  free(above);\n  free(log_likelihoods);\n  free(level_assignments);\n  free(levels);\n\n  free(account_unaccepts);\n\n  if(dnest_flag_limits == 1)\n    free(limits);\n\n  gsl_rng_free(dnest_gsl_r);\n\n  free(dnest_perturb_accept);\n\n  printf(\"# Finalizing dnest.\\n\");\n}\n\n\nvoid options_load(int max_num_saves, double ptol)\n{\n  //sscanf(buf, \"%d\", &options.num_particles);\n  options.num_particles = 2;\n\n  //fgets(buf, BUF_MAX_LENGTH, fp);\n  //sscanf(buf, \"%d\", &options.new_level_interval);\n  options.new_level_interval = options.num_particles * dnest_num_params*10;\n\n  //fgets(buf, BUF_MAX_LENGTH, fp);\n  //sscanf(buf, \"%d\", &options.save_interval);\n  options.save_interval = options.new_level_interval;\n\n  //fgets(buf, BUF_MAX_LENGTH, fp);\n  //sscanf(buf, \"%d\", &options.thread_steps);\n  options.thread_steps = options.new_level_interval;\n\n  //fgets(buf, BUF_MAX_LENGTH, fp);\n  //sscanf(buf, \"%d\", &options.max_num_levels);\n  options.max_num_levels = 0;\n\n  //fgets(buf, BUF_MAX_LENGTH, fp);\n  //sscanf(buf, \"%lf\", &options.lambda);\n  options.lambda = 10.0;\n\n  //fgets(buf, BUF_MAX_LENGTH, fp);\n  //sscanf(buf, \"%lf\", &options.beta);\n  options.beta = 100.0;\n\n  //fgets(buf, BUF_MAX_LENGTH, fp);\n  //sscanf(buf, \"%d\", &options.max_num_saves);\n  options.max_num_saves = max_num_saves;\n\n  options.max_ptol = ptol;\n\n  //fgets(buf, BUF_MAX_LENGTH, fp);\n  //sscanf(buf, \"%s\", options.sample_file);\n  strcpy(options.sample_file, dnest_sample_dir);\n  strcat(options.sample_file,\"/sample\");\n  strcat(options.sample_file, dnest_sample_tag);\n  strcat(options.sample_file, \".txt\");\n  strcat(options.sample_file, dnest_sample_postfix);\n  \n  //fgets(buf, BUF_MAX_LENGTH, fp);\n  //sscanf(buf, \"%s\", options.sample_info_file);\n  strcpy(options.sample_info_file, dnest_sample_dir);\n  strcat(options.sample_info_file,\"/sample_info\");\n  strcat(options.sample_info_file, dnest_sample_tag);\n  strcat(options.sample_info_file, \".txt\");\n  strcat(options.sample_info_file, dnest_sample_postfix);\n  \n  //fgets(buf, BUF_MAX_LENGTH, fp);\n  //sscanf(buf, \"%s\", options.levels_file);\n  strcpy(options.levels_file, dnest_sample_dir);\n  strcat(options.levels_file,\"/levels\");\n  strcat(options.levels_file, dnest_sample_tag);\n  strcat(options.levels_file, \".txt\");\n  strcat(options.levels_file, dnest_sample_postfix);\n  \n  //fgets(buf, BUF_MAX_LENGTH, fp);\n  //sscanf(buf, \"%s\", options.sampler_state_file);\n  strcpy(options.sampler_state_file, dnest_sample_dir);\n  strcat(options.sampler_state_file,\"/sampler_state\");\n  strcat(options.sampler_state_file, dnest_sample_tag);\n  strcat(options.sampler_state_file, \".txt\");\n  strcat(options.sampler_state_file, dnest_sample_postfix);\n  \n  //fgets(buf, BUF_MAX_LENGTH, fp);\n  //sscanf(buf, \"%s\", options.posterior_sample_file);\n  strcpy(options.posterior_sample_file, dnest_sample_dir);\n  strcat(options.posterior_sample_file,\"/posterior_sample\");\n  strcat(options.posterior_sample_file, dnest_sample_tag);\n  strcat(options.posterior_sample_file, \".txt\");\n  strcat(options.posterior_sample_file, dnest_sample_postfix);\n\n  //fgets(buf, BUF_MAX_LENGTH, fp);\n  //sscanf(buf, \"%s\", options.posterior_sample_info_file);\n  strcpy(options.posterior_sample_info_file, dnest_sample_dir);\n  strcat(options.posterior_sample_info_file,\"/posterior_sample_info\");\n  strcat(options.posterior_sample_info_file, dnest_sample_tag);\n  strcat(options.posterior_sample_info_file, \".txt\");\n  strcat(options.posterior_sample_info_file, dnest_sample_postfix);\n\n  //fgets(buf, BUF_MAX_LENGTH, fp);\n  //sscanf(buf, \"%s\", options.limits_file);\n  strcpy(options.limits_file, dnest_sample_dir);\n  strcat(options.limits_file,\"/limits\");\n  strcat(options.limits_file, dnest_sample_tag);\n  strcat(options.limits_file, \".txt\");\n  strcat(options.limits_file, dnest_sample_postfix);\n\n  // check options.\n  \n  if(options.new_level_interval < options.thread_steps)\n  {\n    printf(\"# incorrect options:\\n\");\n    printf(\"# new level interval should be equal to or larger than\"); \n    printf(\"  totaltask * thread step.\\n\");\n    exit(0);\n  }\n\n/*  strcpy(options.sample_file, \"sample.txt\");\n  strcpy(options.sample_info_file, \"sample_info.txt\");\n  strcpy(options.levels_file, \"levels.txt\");\n  strcpy(options.sampler_state_file, \"sampler_state.txt\");*/\n}\n\n\ndouble mod(double y, double x)\n{\n  if(x > 0.0)\n  {\n    return (y/x - floor(y/x))*x;\n  }\n  else if(x == 0.0)\n  {\n    return 0.0;\n  }\n  else\n  {\n    printf(\"Warning in mod(double, double) %e\\n\", x);\n    exit(0);\n  }\n  \n}\n\nvoid dnest_wrap(double *x, double min, double max)\n{\n  *x = mod(*x - min, max - min) + min;\n}\n\nvoid wrap_limit(double *x, double min, double max)\n{\n\n  *x = fmax(fmin(*x, max), min);\n}\n\nint mod_int(int y, int x)\n{\n  if(y >= 0)\n    return y - (y/x)*x;\n  else\n    return (x-1) - mod_int(-y-1, x);\n}\n\ndouble dnest_randh()\n{\n  return pow(10.0, 1.5 - 3.0*fabs(gsl_ran_tdist(dnest_gsl_r, 2))) * gsl_ran_ugaussian(dnest_gsl_r);\n}\n\ndouble dnest_rand()\n{\n  return gsl_rng_uniform(dnest_gsl_r);\n}\n\nint dnest_rand_int(int size)\n{\n  return gsl_rng_uniform_int(dnest_gsl_r, size);\n}\n\ndouble dnest_randn()\n{\n  return gsl_ran_ugaussian(dnest_gsl_r);\n}\n\nint dnest_cmp(const void *pa, const void *pb)\n{\n  LikelihoodType *a = (LikelihoodType *)pa;\n  LikelihoodType *b = (LikelihoodType *)pb;\n\n  // in decesending order\n  if(a->value > b->value)\n    return false;\n  if( a->value == b->value && a->tiebreaker > b->tiebreaker)\n    return false;\n  \n  return true;\n}\n\n\nint dnest_get_size_levels()\n{\n  return size_levels;\n}\n\nint dnest_get_which_level_update()\n{\n  return dnest_which_level_update;\n}\n\nint dnest_get_which_particle_update()\n{\n  return dnest_which_particle_update;\n}\n\nunsigned int dnest_get_which_num_saves()\n{\n  return num_saves;\n}\nunsigned int dnest_get_count_saves()\n{\n  return count_saves;\n}\n\nunsigned long long int dnest_get_count_mcmc_steps()\n{\n  return count_mcmc_steps;\n}\n\nvoid dnest_get_posterior_sample_file(char *fname)\n{\n  strcpy(fname, options.posterior_sample_file);\n  return;\n}\n/* \n * version check\n * \n *  1: greater\n *  0: equal\n * -1: lower\n */\nint dnest_check_version(char *version_str)\n{\n  int major, minor, patch;\n\n  sscanf(version_str, \"%d.%d.%d\", &major, &minor, &patch);\n  \n  if(major > DNEST_MAJOR_VERSION)\n    return 1;\n  if(major < DNEST_MAJOR_VERSION)\n    return -1;\n\n  if(minor > DNEST_MINOR_VERSION)\n    return 1;\n  if(minor < DNEST_MINOR_VERSION)\n    return -1;\n\n  if(patch > DNEST_PATCH_VERSION)\n    return 1;\n  if(patch > DNEST_PATCH_VERSION)\n    return -1;\n\n  return 0;\n}\n\nvoid dnest_check_fptrset(DNestFptrSet *fptrset)\n{\n  if(fptrset->from_prior == NULL)\n  {\n    printf(\"\\\"from_prior\\\" function is not defined.\\n\");\n    exit(0);\n  }\n\n  if(fptrset->print_particle == NULL)\n  {\n    //printf(\"\\\"print_particle\\\" function is not defined. \\\n    //  \\nSet to be default function in dnest.\\n\");\n    fptrset->print_particle = dnest_print_particle;\n  }\n\n  if(fptrset->read_particle == NULL)\n  {\n    //printf(\"\\\"read_particle\\\" function is not defined. \\\n    //  \\nSet to be default function in dnest.\\n\");\n    fptrset->read_particle = dnest_read_particle;\n  }\n\n  if(fptrset->log_likelihoods_cal == NULL)\n  {\n    printf(\"\\\"log_likelihoods_cal\\\" function is not defined.\\n\");\n    exit(0);\n  }\n\n  if(fptrset->log_likelihoods_cal_initial == NULL)\n  {\n    //printf(\"\\\"log_likelihoods_cal_initial\\\" function is not defined. \\\n    //  \\nSet to the same as \\\"log_likelihoods_cal\\\" function.\\n\");\n    fptrset->log_likelihoods_cal_initial = fptrset->log_likelihoods_cal;\n  }\n\n  if(fptrset->log_likelihoods_cal_restart == NULL)\n  {\n    //printf(\"\\\"log_likelihoods_cal_restart\\\" function is not defined. \\\n    //  \\nSet to the same as \\\"log_likelihoods_cal\\\" function.\\n\");\n    fptrset->log_likelihoods_cal_restart = fptrset->log_likelihoods_cal;\n  }\n\n  if(fptrset->perturb == NULL)\n  {\n    printf(\"\\\"perturb\\\" function is not defined.\\n\");\n    exit(0);\n  }\n\n  if(fptrset->restart_action == NULL)\n  {\n    //printf(\"\\\"restart_action\\\" function is not defined.\\\n    //  \\nSet to the default function in dnest.\\n\");\n    fptrset->restart_action = dnest_restart_action;\n  }\n\n  if(fptrset->accept_action == NULL)\n  {\n    //printf(\"\\\"accept_action\\\" function is not defined.\\\n    //  \\nSet to the default function in dnest.\\n\");\n    fptrset->accept_action = dnest_accept_action;\n  }\n\n  if(fptrset->kill_action == NULL)\n  {\n    //printf(\"\\\"kill_action\\\" function is not defined.\\\n    //  \\nSet to the default function in dnest.\\n\");\n    fptrset->kill_action = dnest_kill_action;\n  }\n\n  return;\n}\n\nDNestFptrSet * dnest_malloc_fptrset()\n{\n  DNestFptrSet * fptrset;\n  fptrset = (DNestFptrSet *)malloc(sizeof(DNestFptrSet));\n\n  fptrset->from_prior = NULL;\n  fptrset->log_likelihoods_cal = NULL;\n  fptrset->log_likelihoods_cal_initial = NULL;\n  fptrset->log_likelihoods_cal_restart = NULL;\n  fptrset->perturb = NULL;\n  fptrset->print_particle = NULL;\n  fptrset->read_particle = NULL;\n  fptrset->restart_action = NULL;\n  fptrset->accept_action = NULL;\n  fptrset->kill_action = NULL;\n  return fptrset;\n}\n\nvoid dnest_free_fptrset(DNestFptrSet * fptrset)\n{\n  free(fptrset);\n  return;\n}\n\n\n/*!\n *  Save sampler state for later restart. \n */\nvoid dnest_save_restart()\n{\n  FILE *fp;\n  int i, j;\n  void *particles_all;\n  LikelihoodType *log_likelihoods_all;\n  unsigned int *level_assignments_all;\n  char str[200];\n\n  \n  sprintf(str, \"%s_%d\", file_save_restart, count_saves);\n  fp = fopen(str, \"wb\");\n  if(fp == NULL)\n  {\n    fprintf(stderr, \"# Error: Cannot open file %s. \\n\", file_save_restart);\n    exit(0);\n  }\n\n  \n  printf(\"# Save restart data to file %s.\\n\", str);\n\n    //fprintf(fp, \"%d %d\\n\", count_saves, count_mcmc_steps);\n    //fprintf(fp, \"%d\\n\", size_levels_combine);\n\n  fwrite(&count_saves, sizeof(int), 1, fp);\n  fwrite(&count_mcmc_steps, sizeof(int), 1, fp);\n  fwrite(&size_levels, sizeof(int), 1, fp);\n\n  for(i=0; i<size_levels; i++)\n  {\n    //fprintf(fp, \"%14.12g %14.12g %f %llu %llu %llu %llu\\n\", levels_combine[i].log_X, levels_combine[i].log_likelihood.value, \n    //  levels_combine[i].log_likelihood.tiebreaker, levels_combine[i].accepts,\n    //  levels_combine[i].tries, levels[i].exceeds, levels_combine[i].visits);\n\n    fwrite(&levels[i], sizeof(Level), 1, fp);\n  }\n\n  for(i=0; i<options.num_particles; i++)\n  {\n    //fprintf(fp, \"%d %e %f\\n\", level_assignments_all[j*options.num_particles + i], \n    //  log_likelihoods_all[j*options.num_particles + i].value,\n    //  log_likelihoods_all[j*options.num_particles + i].tiebreaker);  \n    fwrite(&level_assignments[j*options.num_particles + i], sizeof(int), 1, fp);\n    fwrite(&log_likelihoods[j*options.num_particles + i], sizeof(LikelihoodType), 1, fp);    \n  }\n    \n    \n  if(dnest_flag_limits == 1)\n  {\n    for(i=0; i<size_levels; i++)\n    {\n      //fprintf(fp, \"%d  \", i);\n      for(j=0; j<particle_offset_double; j++)\n      {\n        //fprintf(fp, \"%f  %f  \", limits[i*2*particle_offset_double+j*2], limits[i*2*particle_offset_double+j*2+1]);\n        fwrite(&limits[i*2*particle_offset_double+j*2], sizeof(double), 2, fp);\n      }\n\n        //fprintf(fp, \"\\n\");\n    }\n  }\n    \n\n  for(i=0; i<options.num_particles; i++)\n  {\n    //print_particle(fp, particles_all + (j * options.num_particles + i) * particle_offset_size);\n    fwrite(particles + (j * options.num_particles + i) * particle_offset_size, dnest_size_of_modeltype, 1, fp);\n  } \n    \n  fclose(fp);\n\n  restart_action(0);\n}\n\nvoid dnest_restart()\n{\n  FILE *fp;\n  int i, j;\n  void *particles_all;\n  unsigned int *level_assignments_all;\n  LikelihoodType *log_likelihoods_all;\n  void *particle;\n\n  fp = fopen(file_restart, \"rb\");\n  if(fp == NULL)\n  {\n    fprintf(stderr, \"# Error: Cannot open file %s. \\n\", file_restart);\n    exit(0);\n  }\n\n  printf(\"# Reading %s\\n\", file_restart);\n\n  fread(&count_saves, sizeof(int), 1, fp);\n  fread(&count_mcmc_steps, sizeof(int), 1, fp);\n  fread(&size_levels, sizeof(int), 1, fp);\n    \n  /* consider that the newly input max_num_levels may be different from the save one */\n  if(options.max_num_levels != 0)\n  {\n    if(size_levels > options.max_num_levels)\n    {\n      printf(\"# input max_num_levels %d smaller than the one in restart data %d.\\n\", options.max_num_levels, size_levels);\n      size_levels = options.max_num_levels;\n    }   \n  }\n    // read levels\n  for(i=0; i<size_levels; i++)\n  {     \n    if(i<size_levels) // not read all the levels\n      fread(&levels[i], sizeof(Level), 1, fp);\n    else\n      fseek(fp, sizeof(Level), SEEK_CUR); /* offset the file point */\n  }\n    memcpy(levels, levels, size_levels * sizeof(Level));\n\n    // read level assignment\n  for(i=0; i<options.num_particles; i++)\n  {\n    fread(&level_assignments[j*options.num_particles + i], sizeof(int), 1, fp);\n    fread(&log_likelihoods[j*options.num_particles + i], sizeof(LikelihoodType), 1, fp); \n    \n    /* reset the level assignment that exceeds the present maximum level */\n    if(level_assignments[j*options.num_particles + i] > size_levels -1)\n    {\n      level_assignments[j*options.num_particles + i] = size_levels - 1;\n    }\n  }\n\n  // read limits\n  if(dnest_flag_limits == 1)\n  {\n    for(i=0; i<size_levels; i++)\n    {\n      if(i < size_levels)\n      {\n        for(j=0; j<particle_offset_double; j++)\n        {\n          fread(&limits[i*2*particle_offset_double+j*2], sizeof(double), 2, fp);      \n        }\n      }\n      else \n      {\n        fseek(fp, sizeof(double) * 2 * particle_offset_double, SEEK_CUR); /* offset the file point */\n      }\n    }\n  }\n\n  // read particles\n  for(i=0; i<options.num_particles; i++)\n  {\n    particle = (particles + (j * options.num_particles + i) * dnest_size_of_modeltype);\n    fread(particle, dnest_size_of_modeltype, 1, fp);\n  }\n\n  fclose(fp);\n\n  if(count_saves > options.max_num_saves)\n  {\n    printf(\"# Number of samples already larger than the input number, exit!\\n\");\n    exit(0);\n  }\n  \n  num_saves = (int)fmax(0.02*(options.max_num_saves-count_saves), 1.0); /* reset num_saves */\n  num_saves_restart = (int)fmax(0.2 * (options.max_num_saves-count_saves), 1.0); /* reset num_saves_restart */\n\n  restart_action(1);\n\n  for(i=0; i<options.num_particles; i++)\n  {\n    dnest_which_particle_update = i;\n    dnest_which_level_update = level_assignments[i];\n    //printf(\"%d %d %f\\n\", thistask, i, log_likelihoods[i].value);\n    log_likelihoods[i].value = log_likelihoods_cal_restart(particles+i*particle_offset_size, dnest_arg);\n    //printf(\"%d %d %f\\n\", thistask, i, log_likelihoods[i].value);\n    //due to randomness, the original level assignment may be incorrect. re-asign the level\n    while(log_likelihoods[i].value < levels[level_assignments[i]].log_likelihood.value)\n    {\n      printf(\"# level assignment decrease %d %f %f %d.\\n\", i, log_likelihoods[i].value, \n        levels[level_assignments[i]].log_likelihood.value, level_assignments[i]);\n      level_assignments[i]--;\n    }\n    \n  }\n  return;\n}\n\nvoid dnest_print_particle(FILE *fp, const void *model, const void *arg)\n{\n  int i;\n  double *pm = (double *)model;\n\n  for(i=0; i<dnest_num_params; i++)\n  {\n    fprintf(fp, \"%e \", pm[i] );\n  }\n  fprintf(fp, \"\\n\");\n  return;\n}\n\nvoid dnest_read_particle(FILE *fp, void *model)\n{\n  int j;\n  double *psample = (double *)model;\n\n  for(j=0; j < dnest_num_params; j++)\n  {\n    if(fscanf(fp, \"%lf\", psample+j) < 1)\n    {\n      printf(\"%f\\n\", *psample);\n      fprintf(stderr, \"#Error: Cannot read file %s.\\n\", options.sample_file);\n      exit(0);\n    }\n  }\n  return;\n}\n\nvoid dnest_restart_action(int iflag)\n{\n  return;\n}\n\nvoid dnest_accept_action()\n{\n  return;\n}\n\nvoid dnest_kill_action(int i, int i_copy)\n{\n  return;\n}\n\n\n\n", "meta": {"hexsha": "f82a64930ba2fa3f0e93806d8ebad0852a14698a", "size": 35886, "ext": "c", "lang": "C", "max_stars_repo_path": "src/pycali/cdnest/dnest.c", "max_stars_repo_name": "LiyrAstroph/PyCALI", "max_stars_repo_head_hexsha": "e232531b5c6f7817b6e3bd34dbb31463807ae2b0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2021-01-14T01:32:41.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-13T09:23:59.000Z", "max_issues_repo_path": "src/pycali/cdnest/dnest.c", "max_issues_repo_name": "LiyrAstroph/pyCALI", "max_issues_repo_head_hexsha": "e232531b5c6f7817b6e3bd34dbb31463807ae2b0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/pycali/cdnest/dnest.c", "max_forks_repo_name": "LiyrAstroph/pyCALI", "max_forks_repo_head_hexsha": "e232531b5c6f7817b6e3bd34dbb31463807ae2b0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-02-05T02:01:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-06T11:26:06.000Z", "avg_line_length": 26.3093841642, "max_line_length": 127, "alphanum_fraction": 0.6566070334, "num_tokens": 10224, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47268347662043286, "lm_q2_score": 0.039048291607938254, "lm_q1q2_score": 0.018457482233328725}}
{"text": "/* multifit_nlinear/fdf.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough\n * Copyright (C) 2015, 2016 Patrick Alken\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include <config.h>\n#include <stdlib.h>\n#include <string.h>\n#include <gsl/gsl_math.h>\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_multifit_nlinear.h>\n\ngsl_multifit_nlinear_workspace *\ngsl_multifit_nlinear_alloc (const gsl_multifit_nlinear_type * T, \n                            const gsl_multifit_nlinear_parameters * params,\n                            const size_t n, const size_t p)\n{\n  gsl_multifit_nlinear_workspace * w;\n\n  if (n < p)\n    {\n      GSL_ERROR_VAL (\"insufficient data points, n < p\", GSL_EINVAL, 0);\n    }\n\n  w = calloc (1, sizeof (gsl_multifit_nlinear_workspace));\n  if (w == 0)\n    {\n      GSL_ERROR_VAL (\"failed to allocate space for multifit workspace\",\n                     GSL_ENOMEM, 0);\n    }\n\n  w->x = gsl_vector_calloc (p);\n  if (w->x == 0) \n    {\n      gsl_multifit_nlinear_free (w);\n      GSL_ERROR_VAL (\"failed to allocate space for x\", GSL_ENOMEM, 0);\n    }\n\n  w->f = gsl_vector_calloc (n);\n  if (w->f == 0) \n    {\n      gsl_multifit_nlinear_free (w);\n      GSL_ERROR_VAL (\"failed to allocate space for f\", GSL_ENOMEM, 0);\n    }\n\n  w->dx = gsl_vector_calloc (p);\n  if (w->dx == 0) \n    {\n      gsl_multifit_nlinear_free (w);\n      GSL_ERROR_VAL (\"failed to allocate space for dx\", GSL_ENOMEM, 0);\n    }\n\n  w->g = gsl_vector_alloc (p);\n  if (w->g == 0) \n    {\n      gsl_multifit_nlinear_free (w);\n      GSL_ERROR_VAL (\"failed to allocate space for g\", GSL_ENOMEM, 0);\n    }\n\n  w->J = gsl_matrix_alloc(n, p);\n  if (w->J == 0) \n    {\n      gsl_multifit_nlinear_free (w);\n      GSL_ERROR_VAL (\"failed to allocate space for Jacobian\", GSL_ENOMEM, 0);\n    }\n\n  w->sqrt_wts_work = gsl_vector_calloc (n);\n  if (w->sqrt_wts_work == 0)\n    {\n      gsl_multifit_nlinear_free (w);\n      GSL_ERROR_VAL (\"failed to allocate space for weights\", GSL_ENOMEM, 0);\n    }\n\n  w->state = (T->alloc)(params, n, p);\n  if (w->state == 0)\n    {\n      gsl_multifit_nlinear_free (w);\n      GSL_ERROR_VAL (\"failed to allocate space for multifit state\", GSL_ENOMEM, 0);\n    }\n\n  w->type = T;\n  w->fdf = NULL;\n  w->niter = 0;\n  w->params = *params;\n\n  return w;\n}\n\nvoid\ngsl_multifit_nlinear_free (gsl_multifit_nlinear_workspace * w)\n{\n  RETURN_IF_NULL (w);\n\n  if (w->state)\n    (w->type->free) (w->state);\n\n  if (w->dx)\n    gsl_vector_free (w->dx);\n\n  if (w->x)\n    gsl_vector_free (w->x);\n\n  if (w->f)\n    gsl_vector_free (w->f);\n\n  if (w->sqrt_wts_work)\n    gsl_vector_free (w->sqrt_wts_work);\n\n  if (w->g)\n    gsl_vector_free (w->g);\n\n  if (w->J)\n    gsl_matrix_free (w->J);\n\n  free (w);\n}\n\ngsl_multifit_nlinear_parameters\ngsl_multifit_nlinear_default_parameters(void)\n{\n  gsl_multifit_nlinear_parameters params;\n\n  params.trs = gsl_multifit_nlinear_trs_lm;\n  params.scale = gsl_multifit_nlinear_scale_more;\n  params.solver = gsl_multifit_nlinear_solver_qr;\n  params.fdtype = GSL_MULTIFIT_NLINEAR_FWDIFF;\n  params.factor_up = 3.0;\n  params.factor_down = 2.0;\n  params.avmax = 0.75;\n  params.h_df = GSL_SQRT_DBL_EPSILON;\n  params.h_fvv = 0.02;\n\n  return params;\n}\n\nint\ngsl_multifit_nlinear_init (const gsl_vector * x,\n                           gsl_multifit_nlinear_fdf * fdf,\n                           gsl_multifit_nlinear_workspace * w)\n{\n  return gsl_multifit_nlinear_winit(x, NULL, fdf, w);\n}\n\nint\ngsl_multifit_nlinear_winit (const gsl_vector * x,\n                            const gsl_vector * wts,\n                            gsl_multifit_nlinear_fdf * fdf, \n                            gsl_multifit_nlinear_workspace * w)\n{\n  const size_t n = w->f->size;\n\n  if (n != fdf->n)\n    {\n      GSL_ERROR (\"function size does not match workspace\", GSL_EBADLEN);\n    }\n  else if (w->x->size != x->size)\n    {\n      GSL_ERROR (\"vector length does not match workspace\", GSL_EBADLEN);\n    }\n  else if (wts != NULL && n != wts->size)\n    {\n      GSL_ERROR (\"weight vector length does not match workspace\", GSL_EBADLEN);\n    }\n  else\n    {\n      size_t i;\n\n      /* initialize counters for function and Jacobian evaluations */\n      fdf->nevalf = 0;\n      fdf->nevaldf = 0;\n      fdf->nevalfvv = 0;\n\n      w->fdf = fdf;\n      gsl_vector_memcpy(w->x, x);\n      w->niter = 0;\n\n      if (wts)\n        {\n          w->sqrt_wts = w->sqrt_wts_work;\n\n          for (i = 0; i < n; ++i)\n            {\n              double wi = gsl_vector_get(wts, i);\n              gsl_vector_set(w->sqrt_wts, i, sqrt(wi));\n            }\n        }\n      else\n        {\n          w->sqrt_wts = NULL;\n        }\n  \n      return (w->type->init) (w->state, w->sqrt_wts, w->fdf,\n                              w->x, w->f, w->J, w->g);\n    }\n}\n\nint\ngsl_multifit_nlinear_iterate (gsl_multifit_nlinear_workspace * w)\n{\n  int status =\n    (w->type->iterate) (w->state, w->sqrt_wts, w->fdf,\n                        w->x, w->f, w->J, w->g, w->dx);\n\n  w->niter++;\n\n  return status;\n}\n\ndouble\ngsl_multifit_nlinear_avratio (const gsl_multifit_nlinear_workspace * w)\n{\n  return (w->type->avratio) (w->state);\n}\n\n/*\ngsl_multifit_nlinear_driver()\n  Iterate the nonlinear least squares solver until completion\n\nInputs: maxiter  - maximum iterations to allow\n        xtol     - tolerance in step x\n        gtol     - tolerance in gradient\n        ftol     - tolerance in ||f||\n        callback - callback function to call each iteration\n        callback_params - parameters to pass to callback function\n        info     - (output) info flag on why iteration terminated\n                   1 = stopped due to small step size ||dx|\n                   2 = stopped due to small gradient\n                   3 = stopped due to small change in f\n                   GSL_ETOLX = ||dx|| has converged to within machine\n                               precision (and xtol is too small)\n                   GSL_ETOLG = ||g||_inf is smaller than machine\n                               precision (gtol is too small)\n                   GSL_ETOLF = change in ||f|| is smaller than machine\n                               precision (ftol is too small)\n        w        - workspace\n\nReturn:\nGSL_SUCCESS if converged\nGSL_MAXITER if maxiter exceeded without converging\nGSL_ENOPROG if no accepted step found on first iteration\n*/\n\nint\ngsl_multifit_nlinear_driver (const size_t maxiter,\n                             const double xtol,\n                             const double gtol,\n                             const double ftol,\n                             void (*callback)(const size_t iter, void *params,\n                                              const gsl_multifit_nlinear_workspace *w),\n                             void *callback_params,\n                             int *info,\n                             gsl_multifit_nlinear_workspace * w)\n{\n  int status;\n  size_t iter = 0;\n\n  /* call user callback function prior to any iterations\n   * with initial system state */\n  if (callback)\n    callback(iter, callback_params, w);\n\n  do\n    {\n      status = gsl_multifit_nlinear_iterate (w);\n\n      /*\n       * If the solver reports no progress on the first iteration,\n       * then it didn't find a single step to reduce the\n       * cost function and more iterations won't help so return.\n       *\n       * If we get a no progress flag on subsequent iterations,\n       * it means we did find a good step in a previous iteration,\n       * so continue iterating since the solver has now reset\n       * mu to its initial value.\n       */\n      if (status == GSL_ENOPROG && iter == 0)\n        {\n          *info = status;\n          return GSL_EMAXITER;\n        }\n\n      ++iter;\n\n      if (callback)\n        callback(iter, callback_params, w);\n\n      /* test for convergence */\n      status = gsl_multifit_nlinear_test(xtol, gtol, ftol, info, w);\n    }\n  while (status == GSL_CONTINUE && iter < maxiter);\n\n  /*\n   * the following error codes mean that the solution has converged\n   * to within machine precision, so record the error code in info\n   * and return success\n   */\n  if (status == GSL_ETOLF || status == GSL_ETOLX || status == GSL_ETOLG)\n    {\n      *info = status;\n      status = GSL_SUCCESS;\n    }\n\n  /* check if max iterations reached */\n  if (iter >= maxiter && status != GSL_SUCCESS)\n    status = GSL_EMAXITER;\n\n  return status;\n} /* gsl_multifit_nlinear_driver() */\n\ngsl_matrix *\ngsl_multifit_nlinear_jac (const gsl_multifit_nlinear_workspace * w)\n{\n  return w->J;\n}\n\nconst char *\ngsl_multifit_nlinear_name (const gsl_multifit_nlinear_workspace * w)\n{\n  return w->type->name;\n}\n\ngsl_vector *\ngsl_multifit_nlinear_position (const gsl_multifit_nlinear_workspace * w)\n{\n  return w->x;\n}\n\ngsl_vector *\ngsl_multifit_nlinear_residual (const gsl_multifit_nlinear_workspace * w)\n{\n  return w->f;\n}\n\nsize_t\ngsl_multifit_nlinear_niter (const gsl_multifit_nlinear_workspace * w)\n{\n  return w->niter;\n}\n\nint\ngsl_multifit_nlinear_rcond (double *rcond, const gsl_multifit_nlinear_workspace * w)\n{\n  int status = (w->type->rcond) (rcond, w->state);\n  return status;\n}\n\nconst char *\ngsl_multifit_nlinear_trs_name (const gsl_multifit_nlinear_workspace * w)\n{\n  return w->params.trs->name;\n}\n\n/*\ngsl_multifit_nlinear_eval_f()\n  Compute residual vector y with user callback function, and apply\nweighting transform if given:\n\ny~ = sqrt(W) y\n\nInputs: fdf  - callback function\n        x    - model parameters\n        swts - weight matrix sqrt(W) = sqrt(diag(w1,w2,...,wn))\n               set to NULL for unweighted fit\n        y    - (output) (weighted) residual vector\n               y_i = sqrt(w_i) f_i where f_i is unweighted residual\n*/\n\nint\ngsl_multifit_nlinear_eval_f(gsl_multifit_nlinear_fdf *fdf,\n                            const gsl_vector *x,\n                            const gsl_vector *swts,\n                            gsl_vector *y)\n{\n  int s = ((*((fdf)->f)) (x, fdf->params, y));\n\n  ++(fdf->nevalf);\n\n  /* y <- sqrt(W) y */\n  if (swts)\n    gsl_vector_mul(y, swts);\n\n  return s;\n}\n\n/*\ngsl_multifit_nlinear_eval_df()\n  Compute Jacobian matrix J with user callback function, and apply\nweighting transform if given:\n\nJ~ = sqrt(W) J\n\nInputs: x      - model parameters\n        f      - residual vector f(x)\n        swts   - weight matrix W = diag(w1,w2,...,wn)\n                 set to NULL for unweighted fit\n        h      - finite difference step size\n        fdtype - finite difference method\n        fdf    - callback function\n        df     - (output) (weighted) Jacobian matrix\n                 df = sqrt(W) df where df is unweighted Jacobian\n        work   - workspace for finite difference, size n\n*/\n\nint\ngsl_multifit_nlinear_eval_df(const gsl_vector *x,\n                             const gsl_vector *f,\n                             const gsl_vector *swts,\n                             const double h,\n                             const gsl_multifit_nlinear_fdtype fdtype,\n                             gsl_multifit_nlinear_fdf *fdf,\n                             gsl_matrix *df,\n                             gsl_vector *work)\n{\n  int status;\n\n  if (fdf->df)\n    {\n      /* call user-supplied function */\n      status = ((*((fdf)->df)) (x, fdf->params, df));\n      ++(fdf->nevaldf);\n\n      /* J <- sqrt(W) J */\n      if (swts)\n        {\n          const size_t n = swts->size;\n          size_t i;\n\n          for (i = 0; i < n; ++i)\n            {\n              double swi = gsl_vector_get(swts, i);\n              gsl_vector_view v = gsl_matrix_row(df, i);\n\n              gsl_vector_scale(&v.vector, swi);\n            }\n        }\n    }\n  else\n    {\n      /* use finite difference Jacobian approximation */\n      status = gsl_multifit_nlinear_df(h, fdtype, x, swts, fdf, f, df, work);\n    }\n\n  return status;\n}\n\n/*\ngsl_multifit_nlinear_eval_fvv()\n  Compute second direction derivative vector yvv with user\ncallback function, and apply weighting transform if given:\n\nyvv~ = sqrt(W) yvv\n\nInputs: h    - step size for finite difference, if needed\n        x    - model parameters, size p\n        v    - unscaled geodesic velocity vector, size p\n        f    - residual vector f(x), size n\n        J    - Jacobian matrix J(x), n-by-p\n        swts - weight matrix sqrt(W) = sqrt(diag(w1,w2,...,wn))\n               set to NULL for unweighted fit\n        fdf  - callback function\n        yvv  - (output) (weighted) second directional derivative vector\n               yvv_i = sqrt(w_i) fvv_i where f_i is unweighted\n        work - workspace, size p\n*/\n\nint\ngsl_multifit_nlinear_eval_fvv(const double h,\n                              const gsl_vector *x,\n                              const gsl_vector *v,\n                              const gsl_vector *f,\n                              const gsl_matrix *J,\n                              const gsl_vector *swts,\n                              gsl_multifit_nlinear_fdf *fdf,\n                              gsl_vector *yvv, gsl_vector *work)\n{\n  int status;\n  \n  if (fdf->fvv != NULL)\n    {\n      /* call user-supplied function */\n      status = ((*((fdf)->fvv)) (x, v, fdf->params, yvv));\n      ++(fdf->nevalfvv);\n\n      /* yvv <- sqrt(W) yvv */\n      if (swts)\n        gsl_vector_mul(yvv, swts);\n    }\n  else\n    {\n      /* use finite difference approximation */\n      status = gsl_multifit_nlinear_fdfvv(h, x, v, f, J,\n                                          swts, fdf, yvv, work);\n    }\n\n  return status;\n}\n", "meta": {"hexsha": "fc0c1134b1e440e6d66d3f4711014dee62400cef", "size": 13952, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/multifit_nlinear/fdf.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/multifit_nlinear/fdf.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/multifit_nlinear/fdf.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 27.25, "max_line_length": 87, "alphanum_fraction": 0.5884461009, "num_tokens": 3737, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4301473485858429, "lm_q2_score": 0.042722201050615215, "lm_q1q2_score": 0.018376841507673446}}
{"text": "//\n// Created by pedram pakseresht on 2/18/21.\n//\n\nstatic char help[] = \"settling in quiescent fluid\";\n\n#include <petsc.h>\n#include \"incompressibleFlow.h\"\n#include \"mesh.h\"\n#include \"particleInertial.h\"\n#include \"particles.h\"\n#include \"particleInitializer.h\"\n#include \"petscviewer.h\"\n\n\nstatic PetscErrorCode uniform_u(PetscInt Dim, PetscReal time, const PetscReal *X, PetscInt Nf, PetscScalar *u, void *ctx) {\n    PetscInt d;\n    for (d = 0; d < Dim; ++d)\n        u[d] = 0.0;\n    return 0;\n\n}\n\nstatic PetscErrorCode uniform_u_t(PetscInt Dim, PetscReal time, const PetscReal *X, PetscInt Nf, PetscScalar *u, void *ctx) {\n    PetscInt d;\n    for (d = 0; d < Dim; ++d)\n        u[d] = 0.0;\n    return 0;\n}\n\nstatic PetscErrorCode uniform_p(PetscInt Dim, PetscReal time, const PetscReal *X, PetscInt Nf, PetscScalar *p, void *ctx) {\n    p[0] = 0.0;\n    return 0;\n}\n\nstatic PetscErrorCode uniform_T(PetscInt Dim, PetscReal time, const PetscReal *X, PetscInt Nf, PetscScalar *T, void *ctx) {\n    T[0] = 0.0;\n    return 0;\n}\nstatic PetscErrorCode uniform_T_t(PetscInt Dim, PetscReal time, const PetscReal *X, PetscInt Nf, PetscScalar *T, void *ctx) {\n    T[0] = 0.0;\n    return 0;\n}\n\nstatic PetscErrorCode SetInitialConditions(TS ts, Vec u) {\n\n    PetscErrorCode (*initFuncs[3])(PetscInt dim, PetscReal time, const PetscReal x[], PetscInt Nf, PetscScalar u[], void *ctx) = {uniform_u,uniform_p,uniform_T};\n    // u here is the solution vector including velocity, temperature and pressure fields.\n    DM dm;\n    PetscReal t;\n    PetscErrorCode ierr;\n    PetscFunctionBegin;\n\n    ierr = TSGetDM(ts, &dm);\n    CHKERRQ(ierr);\n    ierr = TSGetTime(ts, &t);\n\n    CHKERRQ(ierr);\n\n    ierr = DMProjectFunction(dm, 0.0, initFuncs, NULL, INSERT_ALL_VALUES, u);\n    CHKERRQ(ierr);\n    // get the flow to apply the completeFlowInitialization method\n    ierr = IncompressibleFlow_CompleteFlowInitialization(dm, u);\n    CHKERRQ(ierr);\n\n    PetscFunctionReturn(0);\n}\n\nstatic PetscErrorCode MonitorFlowAndParticleError(TS ts, PetscInt step, PetscReal crtime, Vec u, void *ctx) {\n    // PetscErrorCode (*exactFuncs[3])(PetscInt dim, PetscReal time, const PetscReal x[], PetscInt Nf, PetscScalar *u, void *ctx);\n    // void *ctxs[3];\n    DM dm;\n    PetscDS ds;\n    Vec v;\n    PetscReal ferrors[3];\n    PetscInt f;\n    PetscErrorCode ierr;\n    PetscInt num;\n\n    PetscFunctionBeginUser;\n    ierr = TSGetDM(ts, &dm);\n    CHKERRQ(ierr);\n    ierr = DMGetDS(dm, &ds);\n    CHKERRQ(ierr);\n\n    // get the particle data from the context\n    ParticleData particlesData = (ParticleData)ctx;\n    PetscInt particleCount;\n    ierr = DMSwarmGetSize(particlesData->dm, &particleCount);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n    // compute the average particle location\n    const PetscReal *coords;\n    PetscInt dims;\n    PetscReal avg[3] = {0.0, 0.0, 0.0};\n    ierr = DMSwarmGetField(particlesData->dm, DMSwarmPICField_coor, &dims, NULL, (void **)&coords);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    for (PetscInt p = 0; p < particleCount; p++) {\n        for (PetscInt n = 0; n < dims; n++) {\n            avg[n] += coords[p * dims + n] / particleCount;  // PetscReal\n        }\n    }\n    ierr = DMSwarmRestoreField(particlesData->dm, DMSwarmPICField_coor, &dims, NULL, (void **)&coords);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n    ierr = PetscPrintf(PETSC_COMM_WORLD,\n                       \"Timestep: %04d time = %-8.4g \\t L_2 Error: [%2.3g, %2.3g, %2.3g] ParticleCount: %d\\n\",\n                       (int)step,\n                       (double)crtime,\n                       (double)ferrors[0],\n                       (double)ferrors[1],\n                       (double)ferrors[2],\n                       particleCount,\n                       (double)avg[0],\n                       (double)avg[1]);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    ierr = PetscPrintf(PETSC_COMM_WORLD, \"Avg Particle Location: [%2.3g, %2.3g, %2.3g]\\n\", (double)avg[0], (double)avg[1], (double)avg[2]);\n\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n    ierr = VecViewFromOptions(u, NULL, \"-vec_view\");\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n    ierr = DMSetOutputSequenceNumber(particlesData->dm, step, crtime);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n    if (step == 0) {\n        ierr = ParticleViewFromOptions(particlesData, \"-particle_init\");\n        CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    } else {\n        ierr = ParticleViewFromOptions(particlesData, \"-particle_view\");\n        CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    }\n\n    PetscFunctionReturn(0);\n}\n\nstatic PetscErrorCode ParticleInertialInitialize(ParticleData particles) {\n\n    PetscFunctionBeginUser;\n    PetscErrorCode  ierr;\n    Vec vel,diam,dens;\n    DM particleDm = particles->dm;\n\n    // input parameters required for particles\n    PetscScalar partVel = 0.0;\n    PetscScalar partDiam = 0.22;\n    PetscScalar partDens = 90.0;\n    PetscScalar fluidDens = 1.0;\n    PetscScalar fluidVisc = 1.0;\n    PetscScalar gravity[3] = {0.0,1.0,0.0};\n\n    ierr = DMSwarmCreateGlobalVectorFromField(particleDm,ParticleVelocity, &vel);CHKERRQ(ierr);\n    ierr = DMSwarmCreateGlobalVectorFromField(particleDm,ParticleDiameter, &diam);CHKERRQ(ierr);\n    ierr = DMSwarmCreateGlobalVectorFromField(particleDm,ParticleDensity, &dens);CHKERRQ(ierr);\n    // set particle velocity, diameter and density\n    ierr = VecSet(vel, partVel);CHKERRQ(ierr);\n    ierr = VecSet(diam, partDiam);CHKERRQ(ierr);\n    ierr = VecSet(dens, partDens);CHKERRQ(ierr);\n    ierr = DMSwarmDestroyGlobalVectorFromField(particleDm,ParticleVelocity, &vel);CHKERRQ(ierr);\n    ierr = DMSwarmDestroyGlobalVectorFromField(particleDm,ParticleDiameter, &diam);CHKERRQ(ierr);\n    ierr = DMSwarmDestroyGlobalVectorFromField(particleDm,ParticleDensity, &dens);CHKERRQ(ierr);\n\n    InertialParticleParameters *data;\n    PetscNew(&data);\n    particles->data =data;\n\n    // set fluid parameters\n    data->fluidDensity = fluidDens;\n    data->fluidViscosity = fluidVisc;\n    data->gravityField[0] = gravity[0];\n    data->gravityField[1] = gravity[1];\n    data->gravityField[2] = gravity[2];\n    PetscFunctionReturn(0);\n\n}\n\n\nint main( int argc, char *argv[] )\n{\n\n    DM dm;     // domain definition\n    TS ts;     // time-stepper\n    PetscErrorCode ierr;\n\n    PetscBag parameterBag; // constant flow parameters\n    Vec flowField;         // flow solution vector\n    FlowData flowData;\n\n\n    PetscReal t;\n    PetscInt Dim = 2;\n    PetscReal dt = 0.05;       // dt for time stepper\n    PetscInt max_steps = 10; // maximum time steps\n\n    PetscReal Re = 0.1;       // Reynolds number\n    PetscReal St = 1.0;       // Strouhal number\n    PetscReal Pe = 1.0;       // Peclet number\n    PetscReal Mu = 1.0;      // viscosity\n    PetscReal K_input = 1.0;  // thermal conductivity\n    PetscReal Cp = 1.0;    // heat capacity\n    // PetscInt Np=10;\n\n\n    // initialize Petsc ...\n    ierr = PetscInitialize(&argc, &argv, NULL, \"\");CHKERRQ(ierr);\n    ierr = PetscPrintf(PETSC_COMM_WORLD, \"Settling particle in a quiescent fluid \\n\");CHKERRQ(ierr);\n\n    // setup the ts\n    ierr = TSCreate(PETSC_COMM_WORLD, &ts);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    ierr = CreateMesh(PETSC_COMM_WORLD, &dm, PETSC_TRUE, Dim);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    ierr = TSSetDM(ts, dm);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    ierr = TSSetExactFinalTime(ts, TS_EXACTFINALTIME_MATCHSTEP);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n\n    //output the mesh\n    ierr = DMViewFromOptions(dm, NULL, \"-dm_view\");\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n    // Setup the flow data\n    ierr = FlowCreate(&flowData);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n    // setup problem\n    ierr = IncompressibleFlow_SetupDiscretization(flowData, dm);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n    IncompressibleFlowParameters flowParameters;\n\n    // changing non-dimensional parameters manually here ...\n    flowParameters.strouhal = St;\n    flowParameters.reynolds = Re;\n    flowParameters.peclet = Pe;\n    flowParameters.mu = Mu;\n    flowParameters.k = K_input;\n    flowParameters.cp = Cp;\n\n    // print out the parameters\n    /*\n    ierr = PetscPrintf(PETSC_COMM_WORLD, \"*** non-dimensional parameters ***\\n\");CHKERRQ(ierr);\n    ierr = PetscPrintf(PETSC_COMM_WORLD, \"St=%g\\n\", flowParameters.strouhal);CHKERRQ(ierr);\n    ierr = PetscPrintf(PETSC_COMM_WORLD, \"Re=%g\\n\", flowParameters.reynolds);CHKERRQ(ierr);\n    ierr = PetscPrintf(PETSC_COMM_WORLD, \"Pe=%g\\n\", flowParameters.peclet);CHKERRQ(ierr);\n    ierr = PetscPrintf(PETSC_COMM_WORLD, \"Mu=%g\\n\", flowParameters.mu);CHKERRQ(ierr);\n    ierr = PetscPrintf(PETSC_COMM_WORLD, \"K=%g\\n\", flowParameters.k);CHKERRQ(ierr);\n    ierr = PetscPrintf(PETSC_COMM_WORLD, \"Cp=%g\\n\", flowParameters.cp);CHKERRQ(ierr);\n    */\n\n    // Start the problem setup\n    PetscScalar constants[TOTAL_INCOMPRESSIBLE_FLOW_PARAMETERS];\n    ierr = IncompressibleFlow_PackParameters(&flowParameters, constants);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    ierr = IncompressibleFlow_StartProblemSetup(flowData, TOTAL_INCOMPRESSIBLE_FLOW_PARAMETERS, constants);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n\n    // Override problem with source terms, boundary, and set the exact solution\n    PetscDS prob;\n    ierr = DMGetDS(dm, &prob);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n    // Setup Boundary Conditions\n    // Note: DM_BC_ESSENTIAL is a Dirichlet BC.\n    PetscInt id;\n    id = 3;\n    ierr = PetscDSAddBoundary(\n        prob, DM_BC_ESSENTIAL, \"top wall velocity\", \"marker\", VEL, 0, NULL, (void (*)(void))uniform_u, (void (*)(void))uniform_u_t, 1, &id, NULL);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n    id = 1;\n    ierr = PetscDSAddBoundary(\n        prob, DM_BC_ESSENTIAL, \"bottom wall velocity\", \"marker\", VEL, 0, NULL, (void (*)(void))uniform_u, (void (*)(void))uniform_u_t, 1, &id, NULL);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    id = 2;\n    ierr = PetscDSAddBoundary(\n        prob, DM_BC_ESSENTIAL, \"right wall velocity\", \"marker\", VEL, 0, NULL, (void (*)(void))uniform_u, (void (*)(void))uniform_u_t, 1, &id, NULL);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    id = 4;\n    ierr = PetscDSAddBoundary(\n        prob, DM_BC_ESSENTIAL, \"left wall velocity\", \"marker\", VEL, 0, NULL, (void (*)(void))uniform_u, (void (*)(void))uniform_u_t, 1, &id, NULL);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    id = 3;\n    ierr = PetscDSAddBoundary(\n        prob, DM_BC_ESSENTIAL, \"top wall temp\", \"marker\", TEMP, 0, NULL, (void (*)(void))uniform_T, (void (*)(void))uniform_T_t, 1, &id, NULL);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    id = 1;\n    ierr = PetscDSAddBoundary(\n        prob, DM_BC_ESSENTIAL, \"bottom wall temp\", \"marker\", TEMP, 0, NULL, (void (*)(void))uniform_T, (void (*)(void))uniform_T_t, 1, &id, parameterBag);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    id = 2;\n    ierr = PetscDSAddBoundary(\n        prob, DM_BC_ESSENTIAL, \"right wall temp\", \"marker\", TEMP, 0, NULL, (void (*)(void))uniform_T, (void (*)(void))uniform_T_t, 1, &id, parameterBag);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    id = 4;\n    ierr = PetscDSAddBoundary(\n        prob, DM_BC_ESSENTIAL, \"left wall temp\", \"marker\", TEMP, 0, NULL, (void (*)(void))uniform_T, (void (*)(void))uniform_T_t, 1, &id, parameterBag);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n\n    ierr = IncompressibleFlow_CompleteProblemSetup(flowData, ts);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n    // Name the flow field\n    ierr = PetscObjectSetName(((PetscObject)flowData->flowField), \"Numerical Solution\");\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n\n    ierr = SetInitialConditions(ts, flowData->flowField);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n\n    ierr = TSGetTime(ts, &t);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n    //  *** added by Pedram for dt and number of time steps ***\n    ierr = TSSetTimeStep(ts,dt);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n    ierr = TSSetMaxSteps(ts,max_steps);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    // ***********************************\n\n    ierr = DMSetOutputSequenceNumber(dm, 0, t);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n    // checks for convergence ...\n    ierr = DMTSCheckFromOptions(ts, flowData->flowField);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n\n    ParticleData particles;\n\n    // Setup the particle domain\n    ierr = ParticleInertialCreate(&particles, Dim);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n    // link the flow to the particles\n    ierr = ParticleInitializeFlow(particles, flowData);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n    // name the particle domain\n    ierr = PetscObjectSetOptionsPrefix((PetscObject)(particles->dm), \"particles_\");\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    ierr = PetscObjectSetName((PetscObject)particles->dm, \"Particles\");\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n    // initialize the particles position\n    ierr = ParticleInitialize(dm, particles->dm);CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    // initialize inertial particles velocity, diameter and density\n    ierr = ParticleInertialInitialize(particles);CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n    //ierr = ParticleInertialInitialize(particles->dm);CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n    // setup the flow monitor to also check particles\n    ierr = TSMonitorSet(ts, MonitorFlowAndParticleError, particles, NULL);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    ierr = TSSetFromOptions(ts);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n\n    // Setup particle position integrator\n    TS particleTs;\n    ierr = TSCreate(PETSC_COMM_WORLD, &particleTs);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    ierr = PetscObjectSetOptionsPrefix((PetscObject)particleTs, \"particle_\");\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n    ierr = ParticleInertialSetupIntegrator(particles, particleTs, flowData);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    // ierr = VecView(particleVelocity,PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);\n\n\n    // Solve the one way coupled system\n    ierr = TSSolve(ts, flowData->flowField);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n\n    // Cleanup\n    ierr = DMDestroy(&dm);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    ierr = TSDestroy(&ts);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    ierr = TSDestroy(&particleTs);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    ierr = FlowDestroy(&flowData);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    ierr = ParticleInertialDestroy(&particles);\n    CHKERRABORT(PETSC_COMM_WORLD, ierr);\n    ierr = PetscFinalize();\n    exit(ierr);\n\n}", "meta": {"hexsha": "c347bce39f98b175a932f3fcc78c144db2ad0083", "size": 14347, "ext": "c", "lang": "C", "max_stars_repo_path": "quiescentFluid.c", "max_stars_repo_name": "pakserep/ablateClient", "max_stars_repo_head_hexsha": "c7bb7cf4a4ec706170efd7c06bf8589e30ece47b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "quiescentFluid.c", "max_issues_repo_name": "pakserep/ablateClient", "max_issues_repo_head_hexsha": "c7bb7cf4a4ec706170efd7c06bf8589e30ece47b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "quiescentFluid.c", "max_forks_repo_name": "pakserep/ablateClient", "max_forks_repo_head_hexsha": "c7bb7cf4a4ec706170efd7c06bf8589e30ece47b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.2297979798, "max_line_length": 161, "alphanum_fraction": 0.6783996654, "num_tokens": 4116, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.49218813572079556, "lm_q2_score": 0.03732689028911683, "lm_q1q2_score": 0.01837185254365508}}
{"text": "/* multiset/multiset.c\n * based on combination/combination.c by Szymon Jaroszewicz\n * based on permutation/permutation.c by Brian Gough\n *\n * Copyright (C) 2001 Szymon Jaroszewicz\n * Copyright (C) 2009 Rhys Ulerich\n *\n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n *\n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include <config.h>\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_multiset.h>\n\nsize_t\ngsl_multiset_n (const gsl_multiset * c)\n{\n  return c->n ;\n}\n\nsize_t\ngsl_multiset_k (const gsl_multiset * c)\n{\n  return c->k ;\n}\n\nsize_t *\ngsl_multiset_data (const gsl_multiset * c)\n{\n  return c->data ;\n}\n\nint\ngsl_multiset_valid (gsl_multiset * c)\n{\n  const size_t n = c->n ;\n  const size_t k = c->k ;\n\n  size_t i, j ;\n\n  for (i = 0; i < k; i++)\n    {\n      const size_t ci = c->data[i];\n\n      if (ci >= n)\n        {\n          GSL_ERROR(\"multiset index outside range\", GSL_FAILURE) ;\n        }\n\n      for (j = 0; j < i; j++)\n        {\n          if (c->data[j] > ci)\n            {\n              GSL_ERROR(\"multiset indices not in increasing order\",\n                        GSL_FAILURE) ;\n            }\n        }\n    }\n\n  return GSL_SUCCESS;\n}\n\n\nint\ngsl_multiset_next (gsl_multiset * c)\n{\n  /* Replaces c with the next multiset (in the standard lexicographical\n   * ordering).  Returns GSL_FAILURE if there is no next multiset.\n   */\n  const size_t n = c->n;\n  const size_t k = c->k;\n  size_t *data = c->data;\n  size_t i;\n\n  if(k == 0)\n    {\n      return GSL_FAILURE;\n    }\n  i = k - 1;\n\n  while(i > 0 && data[i] == n-1)\n    {\n      --i;\n    }\n\n  if (i == 0 && data[0] == n-1)\n    {\n      return GSL_FAILURE;\n    }\n\n  ++data[i];\n\n  while(i < k-1)\n    {\n      data[i+1] = data[i];\n      ++i;\n    }\n\n  return GSL_SUCCESS;\n}\n\nint\ngsl_multiset_prev (gsl_multiset * c)\n{\n  /* Replaces c with the previous multiset (in the standard\n   * lexicographical ordering).  Returns GSL_FAILURE if there is no\n   * previous multiset.\n   */\n  const size_t n = c->n;\n  const size_t k = c->k;\n  size_t *data = c->data;\n  size_t i;\n\n  if(k == 0)\n    {\n      return GSL_FAILURE;\n    }\n  i = k - 1;\n\n  while(i > 0 && data[i-1] == data[i])\n    {\n      --i;\n    }\n\n  if(i == 0 && data[i] == 0)\n    {\n      return GSL_FAILURE;\n    }\n\n  data[i]--;\n\n  if (data[i] < n-1)\n    {\n      while (i < k-1) {\n        data[++i] = n - 1;\n      }\n    }\n\n  return GSL_SUCCESS;\n}\n\nint\ngsl_multiset_memcpy (gsl_multiset * dest, const gsl_multiset * src)\n{\n   const size_t src_n = src->n;\n   const size_t src_k = src->k;\n   const size_t dest_n = dest->n;\n   const size_t dest_k = dest->k;\n\n   if (src_n != dest_n || src_k != dest_k)\n     {\n       GSL_ERROR (\"multiset lengths are not equal\", GSL_EBADLEN);\n     }\n\n   {\n     size_t j;\n\n     for (j = 0; j < src_k; j++)\n       {\n         dest->data[j] = src->data[j];\n       }\n   }\n\n   return GSL_SUCCESS;\n}\n", "meta": {"hexsha": "c1a0f80b4cb0e20bfa2b787fc0ded3d4444269a2", "size": 3438, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/multiset/multiset.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/multiset/multiset.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/multiset/multiset.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 19.3146067416, "max_line_length": 81, "alphanum_fraction": 0.5872600349, "num_tokens": 1035, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4035668537353746, "lm_q2_score": 0.04535258555427004, "lm_q1q2_score": 0.01830280026090116}}
{"text": "/* sum/gsl_sum.h\n *\n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman, Brian Gough\n *\n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n *\n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Author:  G. Jungman */\n\n\n#ifndef __GSL_SUM_H__\n#define __GSL_SUM_H__\n\n#include <stdlib.h>\n#include <gsl/gsl_types.h>\n\n#undef __BEGIN_DECLS\n#undef __END_DECLS\n#ifdef __cplusplus\n# define __BEGIN_DECLS extern \"C\" {\n# define __END_DECLS }\n#else\n# define __BEGIN_DECLS          /* empty */\n# define __END_DECLS            /* empty */\n#endif\n\n__BEGIN_DECLS\n\n/*  Workspace for Levin U Transform with error estimation,\n *   \n *   size        = number of terms the workspace can handle\n *   sum_plain   = simple sum of series\n *   q_num       = backward diagonal of numerator; length = size\n *   q_den       = backward diagonal of denominator; length = size\n *   dq_num      = table of numerator derivatives; length = size**2\n *   dq_den      = table of denominator derivatives; length = size**2\n *   dsum        = derivative of sum wrt term i; length = size\n */\n\ntypedef struct\n{\n  size_t size;\n  size_t i;                     /* position in array */\n  size_t terms_used;            /* number of calls */\n  double sum_plain;\n  double *q_num;\n  double *q_den;\n  double *dq_num;\n  double *dq_den;\n  double *dsum;\n}\ngsl_sum_levin_u_workspace;\n\nGSL_EXPORT gsl_sum_levin_u_workspace *gsl_sum_levin_u_alloc (size_t n);\nGSL_EXPORT void gsl_sum_levin_u_free (gsl_sum_levin_u_workspace * w);\n\n/* Basic Levin-u acceleration method.\n *\n *   array       = array of series elements\n *   n           = size of array\n *   sum_accel   = result of summation acceleration\n *   err         = estimated error\n *\n * See [Fessler et al., ACM TOMS 9, 346 (1983) and TOMS-602]\n */\n\nGSL_EXPORT int gsl_sum_levin_u_accel (const double *array,\n                                      const size_t n,\n                                      gsl_sum_levin_u_workspace * w,\n                                      double *sum_accel, double *abserr);\n\n/* Basic Levin-u acceleration method with constraints on the terms\n * used,\n *\n *   array       = array of series elements\n *   n           = size of array\n *   min_terms   = minimum number of terms to sum\n *   max_terms   = maximum number of terms to sum\n *   sum_accel   = result of summation acceleration\n *   err         = estimated error\n *\n * See [Fessler et al., ACM TOMS 9, 346 (1983) and TOMS-602]\n */\n\nGSL_EXPORT int gsl_sum_levin_u_minmax (const double *array,\n                                       const size_t n,\n                                       const size_t min_terms,\n                                       const size_t max_terms,\n                                       gsl_sum_levin_u_workspace * w,\n                                       double *sum_accel, double *abserr);\n\n/* Basic Levin-u step w/o reference to the array of terms.\n * We only need to specify the value of the current term\n * to execute the step. See TOMS-745.\n *\n * sum = t0 + ... + t_{n-1} + term;  term = t_{n}\n *\n *   term   = value of the series term to be added\n *   n      = position of term in series (starting from 0)\n *   sum_accel = result of summation acceleration\n *   sum_plain = simple sum of series\n */\n\nGSL_EXPORT\nint\ngsl_sum_levin_u_step (const double term,\n                      const size_t n,\n                      const size_t nmax,\n                      gsl_sum_levin_u_workspace * w,\n                      double *sum_accel);\n\n/* The following functions perform the same calculation without\n   estimating the errors. They require O(N) storage instead of O(N^2).\n   This may be useful for summing many similar series where the size\n   of the error has already been estimated reliably and is not\n   expected to change.  */\n\ntypedef struct\n{\n  size_t size;\n  size_t i;                     /* position in array */\n  size_t terms_used;            /* number of calls */\n  double sum_plain;\n  double *q_num;\n  double *q_den;\n  double *dsum;\n}\ngsl_sum_levin_utrunc_workspace;\n\nGSL_EXPORT gsl_sum_levin_utrunc_workspace *gsl_sum_levin_utrunc_alloc (size_t n);\nGSL_EXPORT void gsl_sum_levin_utrunc_free (gsl_sum_levin_utrunc_workspace * w);\n\nGSL_EXPORT int gsl_sum_levin_utrunc_accel (const double *array,\n                                           const size_t n,\n                                           gsl_sum_levin_utrunc_workspace * w,\n                                           double *sum_accel, double *abserr_trunc);\n\nGSL_EXPORT int gsl_sum_levin_utrunc_minmax (const double *array,\n                                            const size_t n,\n                                            const size_t min_terms,\n                                            const size_t max_terms,\n                                            gsl_sum_levin_utrunc_workspace * w,\n                                            double *sum_accel, double *abserr_trunc);\n\nGSL_EXPORT int gsl_sum_levin_utrunc_step (const double term,\n                                          const size_t n,\n                                          gsl_sum_levin_utrunc_workspace * w,\n                                          double *sum_accel);\n\n__END_DECLS\n\n#endif /* __GSL_SUM_H__ */\n", "meta": {"hexsha": "187192a095f7a5396aa3ef346a1fd6069338405d", "size": 5795, "ext": "h", "lang": "C", "max_stars_repo_path": "src/core/gsl/include/gsl/gsl_sum.h", "max_stars_repo_name": "dynaryu/vaws", "max_stars_repo_head_hexsha": "f6ed9b75408f7ce6100ed59b7754f745e59be152", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/core/gsl/include/gsl/gsl_sum.h", "max_issues_repo_name": "dynaryu/vaws", "max_issues_repo_head_hexsha": "f6ed9b75408f7ce6100ed59b7754f745e59be152", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/core/gsl/include/gsl/gsl_sum.h", "max_forks_repo_name": "dynaryu/vaws", "max_forks_repo_head_hexsha": "f6ed9b75408f7ce6100ed59b7754f745e59be152", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.1212121212, "max_line_length": 85, "alphanum_fraction": 0.6041415013, "num_tokens": 1354, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48438008427698437, "lm_q2_score": 0.03732688734412946, "lm_q1q2_score": 0.018080400837546928}}
{"text": "#include \"../include/paralleltt.h\"\n#include <math.h>\n\n#include <stdlib.h>\n#include <stdio.h>\n#include <mpi.h>\n#include <cblas.h>\n#include <string.h>\n#include <lapacke.h>\n\n#define min(a,b) ((a)>(b)?(b):(a))\n#define abs(a) ((a)>(0)?(a):(-a))\n\n#ifndef HEAD\n#define HEAD (int) 0\n#endif\n\nmatrix_tt* matrix_tt_init(const int m, const int n)\n{\n    matrix_tt* A = (matrix_tt*) malloc(sizeof(matrix_tt));\n    A->m = m;\n    A->n = n;\n    A->transpose = 0;\n    A->offset = 0;\n    A->lda = m;\n    A->X_size = (long) m*n;\n    A->X = (double*) malloc(A->X_size*sizeof(double));\n\n    return A;\n}\n\nvoid matrix_tt_wrap_update(matrix_tt* A, int m, int n, double* X)\n{\n    A->m = m;\n    A->n = n;\n    A->transpose = 0;\n    A->offset = 0;\n    A->lda = m;\n    A->X_size = (long) m*n;\n    A->X = X;\n}\n\nmatrix_tt* matrix_tt_wrap(int m, int n, double* X)\n{\n    matrix_tt* A = (matrix_tt*) malloc(sizeof(matrix_tt));\n    A->m = m;\n    A->n = n;\n    A->transpose = 0;\n    A->offset = 0;\n    A->lda = m;\n    A->X_size = (long) m*n;\n    A->X = X;\n    return A;\n}\n\nmatrix_tt* matrix_tt_copy(const matrix_tt* A)\n{\n    matrix_tt* B = (matrix_tt*) malloc(sizeof(matrix_tt));\n    int m = A->m; int n = A->n; int X_size = A->X_size;\n    B->m = m;\n    B->n = n;\n    B->transpose = A->transpose;\n    B->offset = A->offset;\n    B->lda = A->lda;\n    B->X_size = X_size;\n    B->X = (double*) malloc(X_size * sizeof(double));\n    memcpy(B->X, A->X, X_size * sizeof(double));\n\n    return B;\n}\n\n// Copy from matrix A to matrix B\nvoid matrix_tt_copy_data(matrix_tt* B, const matrix_tt* A)\n{\n    int BT = (B->transpose == 0) ? 0 : 1;\n    int AT = (A->transpose == 0) ? 0 : 1;\n    if (BT == AT){\n        if ((B->m != A->m) || (B->n != A->n)){\n            printf(\"matrix_tt_copy_data: B (%d x %d) is not the same size as A (%d x %d)\\n\", B->n, B->m, A->n, A->m);\n            return;\n        }\n        for (int jj = 0; jj < B->n; ++jj){\n            memcpy((B->X) + (B->offset) + (B->lda)*jj, (A->X) + (A->offset) + jj*(A->lda), (B->m)*sizeof(double));\n        }\n    }\n    else{\n        if ((B->m != A->n) || (B->n != A->m)){\n            printf(\"matrix_tt_copy_data: B (%d x %d, transpose = %d) is not the same size as A (%d x %d, transpose = %d)\\n\",\n                    B->n, B->m, B->transpose, A->n, A->m, A->transpose);\n            return;\n        }\n        for (int jj = 0; jj < B->n; ++jj){\n            double* BX = (B->X) + (B->offset) + (B->lda)*jj;\n            double* AX = (A->X) + (A->offset) + jj;\n            for (int ii = 0; ii < B->m; ++ii){\n                BX[ii] = AX[ii*(A->lda)];\n            }\n        }\n    }\n}\n\nmatrix_tt* submatrix_copy(const matrix_tt* A)\n{\n    matrix_tt* B = (matrix_tt*) malloc(sizeof(matrix_tt));\n    int m = A->m; int n = A->n; int X_size = m*n;\n    B->m = m;\n    B->n = n;\n    B->transpose = A->transpose;\n    B->offset = 0;\n    B->lda = m;\n    B->X_size = X_size;\n    B->X = (double*) malloc(X_size * sizeof(double));\n    matrix_tt_copy_data(B, A);\n\n    return(B);\n}\n\n// NOTE: reshape and submatrix will not work well together.\nvoid matrix_tt_reshape(int m, int n, matrix_tt* A)\n{\n    long new_size = (long) m*n;\n    if (new_size > A->X_size){\n        printf(\"Reshape failed: m*n=%ld is too large for X_size=%ld\\n\", (long) new_size, A->X_size);\n    }\n    else{\n        A->m = m;\n        A->n = n;\n        A->offset = 0;\n        A->lda = m;\n    }\n}\n\n// In matlab notation, returns A[ii1:ii2-1, jj1:jj2-1]\nmatrix_tt* submatrix(const matrix_tt* A, int ii1, int ii2, int jj1, int jj2)\n{\n    int mA = A->m; int nA = A->n; int lda = A->lda;\n    if ((ii1 < 0) || (ii2 < ii1) || (mA < ii2) || (jj1 < 0) || (jj2 < jj1) || (nA < jj2)){\n        printf(\"Cannot take the A[%d:%d,%d:%d] of a %d by %d matrix (Matlab notation)\\n\", ii1, ii2-1, jj1, jj2-1, mA, nA);\n    }\n    matrix_tt* B = (matrix_tt*) malloc(sizeof(matrix_tt));\n\n    B->m = ii2 - ii1;\n    B->n = jj2 - jj1;\n    B->transpose = A->transpose;\n    B->offset = ii1 + jj1*lda;\n    B->lda = lda;\n    B->X_size = A->X_size;\n    B->X = A->X + A->offset;\n\n    return B;\n}\n\n// Updates the indices of the submatrix A\nvoid submatrix_update(matrix_tt* A, int ii1, int ii2, int jj1, int jj2)\n{\n    A->m = ii2 - ii1;\n    A->n = jj2 - jj1;\n    A->offset = ii1 + jj1*(A->lda);\n}\n\n\n// Get an element of the matrix\ndouble matrix_tt_element(const matrix_tt* A, int ii, int jj)\n{\n    return A->X[A->offset + ii + (A->lda)*jj];\n}\n\nvoid matrix_tt_free(matrix_tt* A)\n{\n    free(A->X); A->X = NULL;\n    free(A);\n    return;\n}\n\nvoid matrix_tt_print(const matrix_tt* A, int just_the_matrix)\n{\n    int m = A->m; int n = A->n; int T = A->transpose;\n    int offset = A->offset; int lda = A->lda;\n\n    if (!just_the_matrix){\n        printf(\"Size of matrix: m=%d, n=%d\\n\", m, n);\n        printf(\"Transpose=%d, offset=%d, lda=%d\\n\", T, offset, lda);\n        printf(\"X_size=%ld\\n\", A->X_size);\n        printf(\"X\");\n        if (T){ printf(\"^T\"); }\n        printf(\" is \\n\");\n    }\n\n    int mloop = T ? m : n;\n    int nloop = T ? n : m;\n    printf(\"[\");\n    for (int jj = 0; jj < nloop; ++jj){\n        for (int ii = 0; ii < mloop; ++ii){\n            if (!T){ printf(\"%f\",A->X[lda*ii + jj + offset]); }\n            else{    printf(\"%f\",A->X[lda*jj + ii + offset]); }\n            if (ii < mloop-1){ printf(\", \"); }\n        }\n\n        if (jj == nloop - 1){\n            printf(\"]\\n\");\n        }\n        else{\n            printf(\",\\n \");\n        }\n    }\n}\n\n\ndouble frobenius_norm(matrix_tt* A){\n    double norm = 0;\n    if (A->m == A->lda){\n        norm = cblas_dnrm2(A->m * A->n, A->offset + A->X, 1);\n    }\n    else{\n        for (int ii = 0; ii < A->n; ++ii){\n            double tmp = cblas_dnrm2(A->m, A->offset + (A->lda)*ii + A->X, 1);\n            norm = sqrt(norm*norm + tmp*tmp);\n        }\n    }\n    return norm;\n}\n\n\n\n// Performs the operation C = alpha*A*B + beta*C, where A and B are appropriately transposed\nint matrix_tt_dgemm(const matrix_tt* A, const matrix_tt* B, matrix_tt* C, const double alpha, const double beta)\n{\n    int mA = A->m; int nA = A->n;\n    int mB = B->m; int nB = B->n;\n    int m_check = C->m; int n_check = C->n; int k_check;\n\n    int m; int n; int k;\n    CBLAS_TRANSPOSE TransA;\n    CBLAS_TRANSPOSE TransB;\n    if (A->transpose == 0){\n        TransA = CblasNoTrans;\n        m = mA;\n        k = nA;\n    }\n    else{\n        TransA = CblasTrans;\n        m = nA;\n        k = mA;\n    }\n\n\n    if (B->transpose == 0){\n        TransB = CblasNoTrans;\n        k_check = mB;\n        n = nB;\n    }\n    else{\n        TransB = CblasTrans;\n        k_check = nB;\n        n = mB;\n    }\n\n    if ((m != m_check) || (n != n_check) || (k != k_check)){\n        printf(\"Dimensions of input arrays do not match:\\n\");\n        printf(\"A: m=%d, n=%d, tranpose=%d\\n\",mA,nA,A->transpose);\n        printf(\"B: m=%d, n=%d, tranpose=%d\\n\",mB,nB,B->transpose);\n        printf(\"C: m=%d, n=%d, tranpose=%d\\n\",m_check,n_check,C->transpose);\n        return 1;\n    }\n\n    C->transpose = 0;\n\n    cblas_dgemm(CblasColMajor, TransA, TransB,\n                m, n, k,\n                alpha,\n                A->X + A->offset, A->lda,\n                B->X + B->offset, B->lda,\n                beta,\n                C->X + C->offset, C->lda);\n\n    return 0;\n}\n\n// Solves the least squares problem Ax = b\n// At the end, it just copies the result into x. This probably isn't the most efficient way to do this\nvoid matrix_tt_dgels(matrix_tt* x, matrix_tt* A, const matrix_tt* b)\n{\n    if (x->transpose != 0){\n        printf(\"matrix_tt_least_squares: x cannot be transposed for dgels\\n\");\n        return;\n    }\n\n    if (b->transpose != 0){\n        printf(\"matrix_tt_least_squares: b cannot be transposed for dgels\\n\");\n        return;\n    }\n\n    int nrhs = x->n;\n    char TransA;\n    int m_check;\n    int n_check;\n\n\n    if (A->transpose == 0){\n        TransA = 'N';\n        m_check = A->m;\n        n_check = A->n;\n    }\n    else{\n        TransA = 'T';\n        m_check = A->n;\n        n_check = A->m;\n    }\n\n    if (n_check != x->m){\n        printf(\"right index of A (%d) does not match left index of x (%d)\\n\", n_check, x->m);\n    }\n    if (m_check != b->m){\n        printf(\"left index of A (%d) does not match left index of b (%d)\\n\", m_check, b->m);\n    }\n    if (x->n != b->n){\n        printf(\"right index of x (%d) does not match right index of b (%d)\\n\", x->n, b->n);\n    }\n\n    int m = A->m;\n    int n = A->n;\n\n    int info = LAPACKE_dgels(LAPACK_COL_MAJOR, TransA, m, n, nrhs, A->X + A->offset, A->lda, b->X + b->offset, b->lda);\n\n    matrix_tt* result = submatrix(b, 0, x->m, 0, x->n);\n    matrix_tt_copy_data(x, result);\n    free(result);\n}\n\n\n// Input:\n//   Q - the matrix you want to take the QR\n// Output:\n//   Q - the Q matrix of QR\n//   R - (input is NULL) ? nothing : the R matrix of QR\n\n// NOTE: Currently assumes R and Q are not transposed\nint matrix_tt_truncated_qr(matrix_tt* Q, matrix_tt* R, int r)\n{\n    int Qm = Q->m; int Qn = Q->n; double* QX = Q->X;\n    int Qtranspose = Q->transpose; long Qoffset = Q->offset; int Qlda = Q->lda;\n\n    lapack_int info;\n\n\n    if (Qtranspose == 0){\n        if (r > Qn)\n        {\n            printf(\"ERROR: (matrix_tt_truncated_qr) r = %d is too large for Q->n = %d \\n\", r, Qn);\n            return 1;\n        }\n        // The QR step\n        double* tau = (double*) malloc(sizeof(double)*min(Qm,Qn));\n        info = LAPACKE_dgeqrf(LAPACK_COL_MAJOR, Qm, Qn, QX + Qoffset, Qlda, tau);\n\n        if (R != NULL){\n            int Rm = R->m; int Rn = R->n; double* RX = R->X;\n            int Rtranspose = R->transpose; long Roffset = R->offset; int Rlda = R->lda;\n\n            if ((Rm != r) || (Rn != r)){\n                printf(\"ERROR: (matrix_tt_truncated_qr) R->m = %d or R->n = %d is not equal to r = %d\\n\", Rm, Rn, r);\n                return 1;\n            }\n            if (Rtranspose != 0){\n                printf(\"ERROR: (matrix_tt_truncated_qr) Only defined for R->transpose = 0\\n\");\n                return 1;\n            }\n\n            for (int jj = 0; jj < r; ++jj){\n                int r_col_length = (Qm < jj+1) ? (Qm) : jj+1;\n                memcpy(RX + Roffset + jj*Rlda, QX + Qoffset + jj*Qlda, r_col_length*sizeof(double));\n                memset(RX + Roffset + jj*Rlda + r_col_length, 0, (r-r_col_length)*sizeof(double));\n            }\n        }\n\n        if (r > Qm){\n            LAPACKE_dorgqr(LAPACK_COL_MAJOR, Qm, Qm, Qm, QX + Qoffset, Qlda, tau);\n            matrix_tt* Q_sub = submatrix(Q, 0, Qm, Qm, r);\n            matrix_tt_fill_zeros(Q_sub);\n            free(Q_sub);\n        }\n        else{\n            LAPACKE_dorgqr(LAPACK_COL_MAJOR, Qm, r, r, QX + Qoffset, Qlda, tau);\n        }\n\n        Q->n = r;\n\n        free(tau);       tau = NULL;\n    }\n    else{\n        if (r > Qm)\n        {\n            printf(\"ERROR: (matrix_tt_truncated_qr) r = %d is too large for Q->n = %d \\n\", r, Qn);\n            return 1;\n        }\n        // The LQ step\n        printf(\"Performing LQ\\n\");\n        double* tau = (double*) malloc(sizeof(double)*min(Qm,Qn));\n        info = LAPACKE_dgelqf(LAPACK_COL_MAJOR, Qm, Qn, QX + Qoffset, Qlda, tau);\n        printf(\"\\nRight after LQ, Q = \\n\");\n        matrix_tt_print(Q, 1);\n\n        if (R != NULL){\n            int Rm = R->m; int Rn = R->n; double* RX = R->X;\n            int Rtranspose = R->transpose; long Roffset = R->offset; int Rlda = R->lda;\n\n            if ((Rm != r) || (Rn != r)){\n                printf(\"ERROR: (matrix_tt_truncated_qr) R->m = %d or R->n = %d is not equal to r = %d\\n\", Rm, Rn, r);\n                return 1;\n            }\n            if (Rtranspose == 0){\n                printf(\"ERROR: (matrix_tt_truncated_qr) Only defined for R->transpose = Q->transpose\\n\");\n                return 1;\n            }\n\n            int ncols = (r > Qm) ? Qm : r;\n            for (int jj = 0; jj < r; ++jj){\n                if (jj < Qm){\n                    memcpy(RX + Roffset + jj*Rlda + jj, QX + Qoffset + jj*Qlda + jj, (Qm - jj)*sizeof(double));\n                    memset(RX + Roffset + jj*Rlda, 0, jj*sizeof(double));\n                }\n            }\n\n        }\n\n        if (r > Qn){\n            printf(\"Doing first dorglq\\n\");\n            LAPACKE_dorglq(LAPACK_COL_MAJOR, Qn, Qn, Qn, QX + Qoffset, Qlda, tau);\n            matrix_tt* Q_sub = submatrix(Q, Qn, r, 0, Qn);\n            matrix_tt_fill_zeros(Q_sub);\n            free(Q_sub);\n        }\n        else{\n            printf(\"Doing second dorglq\\n\");\n            LAPACKE_dorglq(LAPACK_COL_MAJOR, Qm, Qn, Qm, QX + Qoffset, Qlda, tau);\n        }\n\n        Q->m = r;\n\n        free(tau);       tau = NULL;\n    }\n\n    return 0;\n}/**/\n\nvoid matrix_tt_group_reduce(MPI_Comm comm, int rank, matrix_tt* A, matrix_tt* buf, int head, int* group_ranks, int nranks)\n{\n    int in_the_group = 0;\n    for (int ii = 0; ii < nranks; ++ii){\n        if (rank == group_ranks[ii]){\n            in_the_group = 1;\n        }\n    }\n\n    if (in_the_group){\n        int buf_assigned = 0;\n        if (!buf){\n            buf_assigned = 1;\n            buf = matrix_tt_init(A->m, A->n);\n        }\n\n        if ((buf->m < A->m) || (buf->n < A->n)){\n            printf(\"buf (%d x %d) must be larger than A (%d x %d)\\n\", buf->m, buf->n, A->m, A->n);\n        }\n\n        int send = -1;\n        int recv = -1;\n        while (nranks > 1){\n            int half_nranks = (nranks + 1) / 2;\n            for (int ii = 0; ii < half_nranks; ++ii){\n                if (ii + half_nranks >= nranks){\n                    recv = group_ranks[ii];\n                    send = -1;\n                }\n                else if (group_ranks[ii + half_nranks] == head){\n                    recv = head;\n                    send = group_ranks[ii];\n                }\n                else{\n                    recv = group_ranks[ii];\n                    send = group_ranks[ii + half_nranks];\n                }\n\n                if (rank == send){\n                    matrix_tt_send(comm, A, recv);\n                }\n                else if ((rank == recv) && (send != -1)){\n                    matrix_tt_recv(comm, buf, send);\n                    for (int jj = 0; jj < A->n; ++jj){\n//                        MPI_Recv(buf->X + buf->offset, A->m, MPI_DOUBLE, send, 0, comm, MPI_STATUS_IGNORE);\n                        long A_offset = A->offset + jj * (A->lda);\n                        long buf_offset = buf->offset +  jj * (buf->lda);\n                        for (int kk = 0; kk < A->m; ++kk){\n                            A->X[A_offset + kk] = A->X[A_offset + kk] + buf->X[buf_offset + kk];\n                        }\n                    }\n                }\n                group_ranks[ii] = recv;\n            }\n            nranks = half_nranks;\n        }\n\n        if (buf_assigned){\n            matrix_tt_free(buf);\n        }\n    }\n\n}\n\n\n// buf just has to be size A->lda x 1 or more\nvoid matrix_tt_reduce(MPI_Comm comm, int rank, matrix_tt* A, matrix_tt* buf, int head)\n{\n    if (buf == NULL){\n        matrix_tt* buf = matrix_tt_init(A->m, 1);\n        matrix_tt_reduce(comm, rank, A, buf, head);\n        matrix_tt_free(buf);\n    }\n    else{\n        int size;\n        MPI_Comm_size(comm, &size);\n\n        if ((head < 0) || (head >= size)){\n            printf(\"matrix_tt_reduce: head = %d is not a valid rank for size = %d\\n\", head, size);\n        }\n\n        if (buf->lda < A->m){\n            printf(\"buf->lda = %d must be larger than A->m = %d\\n\", buf->lda, A->m);\n        }\n\n        int* activated_ranks = (int*) calloc(size, sizeof(int));\n        for (int ii = 0; ii < size; ++ii){\n            activated_ranks[ii] = ii;\n        }\n        int send = -1;\n        int recv = -1;\n        while (size > 1){\n            int half_size = (size + 1) / 2;\n            for (int ii = 0; ii < half_size; ++ii){\n                if (ii + half_size >= size){\n                    recv = activated_ranks[ii];\n                    send = -1;\n                }\n                else if (activated_ranks[ii + half_size] == head){\n                    recv = head;\n                    send = activated_ranks[ii];\n                }\n                else{\n                    recv = activated_ranks[ii];\n                    send = activated_ranks[ii + half_size];\n                }\n\n                if (rank == send){\n                    for (int jj = 0; jj < A->n; ++jj){\n                        MPI_Send(A->X + A->offset + A->lda * jj, A->m, MPI_DOUBLE, recv, 0, comm);\n                    }\n                }\n                else if ((rank == recv) && (send != -1)){\n                    for (int jj = 0; jj < A->n; ++jj){\n                        MPI_Recv(buf->X + buf->offset, A->m, MPI_DOUBLE, send, 0, comm, MPI_STATUS_IGNORE);\n                        long A_offset = A->offset + jj * (A->lda);\n                        for (int kk = 0; kk < A->m; ++kk){\n                            A->X[A_offset + kk] = A->X[A_offset + kk] + buf->X[buf->offset + kk];\n                        }\n                    }\n                }\n                activated_ranks[ii] = recv;\n            }\n            size = half_size;\n        }\n        free(activated_ranks);\n    }\n}\n\nvoid matrix_tt_allreduce(MPI_Comm comm, matrix_tt* A)\n{\n    for (int jj = 0; jj < A->n; ++jj){\n        MPI_Allreduce(MPI_IN_PLACE, A->X + A->offset + jj*(A->lda), A->m, MPI_DOUBLE, MPI_SUM, comm);\n    }\n}\n\nvoid matrix_tt_broadcast(MPI_Comm comm, matrix_tt* buf)\n{\n    int count = buf->m * buf->n;\n    MPI_Bcast(buf->X, count, MPI_DOUBLE, HEAD, comm);\n}\n\nvoid matrix_tt_send(MPI_Comm comm, matrix_tt* buf, int dest){\n    MPI_Datatype buf_type;\n    MPI_Type_vector(buf->n, buf->m, buf->lda, MPI_DOUBLE, &buf_type);\n    MPI_Type_commit(&buf_type);\n    MPI_Send(buf->X + buf->offset, 1, buf_type, dest, 0, comm);\n    MPI_Type_free(&buf_type);\n}\n\nvoid matrix_tt_recv(MPI_Comm comm, matrix_tt* buf, int source){\n    MPI_Datatype buf_type;\n    MPI_Type_vector(buf->n, buf->m, buf->lda, MPI_DOUBLE, &buf_type);\n    MPI_Type_commit(&buf_type);\n    MPI_Recv(buf->X + buf->offset, 1, buf_type, source, 0, comm, MPI_STATUS_IGNORE);\n    MPI_Type_free(&buf_type);\n}\n\n// Column khatri-rao product C = A x B\nvoid khatri_rao(const matrix_tt* restrict A, const matrix_tt* restrict B, matrix_tt* restrict C){\n    int n = A->n;\n    int m_A = A->m;\n\n    int n_B = B->n;\n    int m_B = B->m;\n\n    int n_C = C->n;\n    int m_C = C->m;\n\n    if ((n != n_B) || (n != n_C) || (m_A*m_B != m_C)){\n        printf(\"khatri_rao: the sizes dont work!\\n\");\n        printf(\"A is %d x %d\\n\", m_A, n);\n        printf(\"B is %d x %d\\n\", m_B, n_B);\n        printf(\"C is %d x %d\\n\", m_C, n_C);\n    }\n\n    for (int kk = 0; kk < n; ++kk){\n        for (int ii = 0; ii < m_B; ++ii){\n            double Bii = B->X[kk*m_B + ii];\n            for (int jj = 0; jj < m_A; ++jj){\n                C->X[kk*m_C + ii*m_B + jj] = Bii * A->X[kk*m_A + jj];\n            }\n        }\n    }\n}\n\n// Recursively KR multiply the list of matrices A\nvoid list_khatri_rao(int d_kr, matrix_tt** A, matrix_tt* Omega){\n    if (d_kr == 1){\n        for (int ii = 0; ii < A[0]->X_size; ++ii){\n            Omega->X[ii] = A[0]->X[ii];\n        }\n        return;\n    }\n\n    if (d_kr == 2){\n        khatri_rao(A[0], A[1], Omega);\n    }\n    else{\n        int m_B = 1;\n        int n_B = Omega->n;\n        for (int ii = 0; ii < d_kr-1; ++ii){\n            m_B = m_B * A[ii]->m;\n        }\n\n        matrix_tt* B = matrix_tt_init(m_B, n_B);\n        list_khatri_rao(d_kr - 1, A, B);\n        khatri_rao(B, A[d_kr - 1], Omega);\n        matrix_tt_free(B); B = NULL;\n    }\n\n}\n\n\nvoid matrix_tt_dlarnv(matrix_tt* A){\n    int r1 = rand()%4096, r2 = rand()%4096, r3 = rand()%4096, r4 = rand()%4096;\n    int iseed[4] = {r1, r2, r3, r4+(r4%2 == 0?1:0)};\n    LAPACKE_dlarnv(3, iseed, (A->n) * (A->m), A->X);\n}\n\n\nvoid matrix_tt_fill_zeros(matrix_tt* A)\n{\n    for (int jj = 0; jj < A->n; ++jj){\n        memset(A->X + A->offset + jj*A->lda, 0, A->m * sizeof(double));\n    }\n}\n\n// Takes a matrix in row major and transforms it to column major\nvoid row_to_col_major(const matrix_tt* mat_row, matrix_tt* mat_col)\n{\n    int m = mat_col->m;\n    int n = mat_col->n;\n    if ((m != mat_row->n) || (n != mat_row->m)){\n        printf(\"The dimensions don't work out! mat_row should have the dimensions of mat_col transposed\\n\");\n        printf(\"mat_row->m = %d, mat_row->n = %d\\n\", mat_row->m, mat_row->n);\n        printf(\"mat_col->m = %d, mat_col->n = %d\\n\", mat_col->m, mat_col->n);\n    }\n\n    for (int ii = 0; ii < m; ++ii){\n        for (int jj = 0; jj < n; ++jj){\n            mat_col->X[jj * (mat_col->lda) + ii + mat_col->offset] = mat_row->X[ii * (mat_row->lda) + jj + mat_row->offset];\n        }\n    }\n}\n", "meta": {"hexsha": "da3056e2c74e7cf9beb79b1748d71c7e45554294", "size": 20410, "ext": "c", "lang": "C", "max_stars_repo_path": "src/matrix_tt.c", "max_stars_repo_name": "SidShi/Parallel_TT_sketching", "max_stars_repo_head_hexsha": "e2c00c289d75d3ac1df32ed2b95af579a517fcbf", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/matrix_tt.c", "max_issues_repo_name": "SidShi/Parallel_TT_sketching", "max_issues_repo_head_hexsha": "e2c00c289d75d3ac1df32ed2b95af579a517fcbf", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/matrix_tt.c", "max_forks_repo_name": "SidShi/Parallel_TT_sketching", "max_forks_repo_head_hexsha": "e2c00c289d75d3ac1df32ed2b95af579a517fcbf", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.5369030391, "max_line_length": 124, "alphanum_fraction": 0.4853993141, "num_tokens": 6462, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.399811640739795, "lm_q2_score": 0.04468087440696542, "lm_q1q2_score": 0.01786393370633756}}
{"text": "/* -*- mode: C; c-basic-offset: 4 -*- */\n/* ex: set shiftwidth=4 tabstop=4 expandtab: */\n/*\n * Copyright (c) 2013, Georgia Tech Research Corporation\n * Copyright (c) 2015, Rice University\n * Copyright (c) 2018-2019, Colorado School of Mines\n * All rights reserved.\n *\n * Author(s): Neil T. Dantam <ntd@gatech.edu>\n * Georgia Tech Humanoid Robotics Lab\n * Under Direction of Prof. Mike Stilman <mstilman@cc.gatech.edu>\n *\n *\n * This file is provided under the following \"BSD-style\" License:\n *\n *\n *   Redistribution and use in source and binary forms, with or\n *   without modification, are permitted provided that the following\n *   conditions are met:\n *\n *   * Redistributions of source code must retain the above copyright\n *     notice, this list of conditions and the following disclaimer.\n *\n *   * Redistributions in binary form must reproduce the above\n *     copyright notice, this list of conditions and the following\n *     disclaimer in the documentation and/or other materials provided\n *     with the distribution.\n *\n *   * Neither the name of the Rice University nor the names of its\n *     contributors may be used to endorse or promote products derived\n *     from this software without specific prior written permission.\n *\n *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND\n *   CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES,\n *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\n *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR\n *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF\n *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED\n *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\n *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN\n *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n *   POSSIBILITY OF SUCH DAMAGE.\n *\n */\n\n#include <nlopt.h>\n#include \"amino.h\"\n#include \"amino/diffeq.h\"\n\n\n\n/* static double */\n/* s_nlobj_jpinv(unsigned n, const double *q, double *dq, void *vcx) */\n/* { */\n/*     struct kin_solve_cx *cx = (struct kin_solve_cx*)vcx; */\n/*     void *ptrtop = aa_mem_region_ptr(cx->reg); */\n\n/*     struct aa_dvec vq = AA_DVEC_INIT(n,(double*)q,1); */\n/*     aa_rx_fk_sub(cx->fk, cx->ssg, &vq); */\n/*     double *E_act = aa_rx_fk_ref(cx->fk, cx->frame); */\n\n\n/*     if( dq ) { */\n/*         struct aa_dvec v_dq = AA_DVEC_INIT(n,dq,1); */\n/*         s_ksol_jpinv(cx,q, &v_dq); */\n/*         aa_dvec_scal(-1,&v_dq); */\n/*     } */\n\n/*     double x = s_serr( E_act, cx->TF_ref->data ); */\n\n/*     aa_mem_region_pop(cx->reg, ptrtop); */\n/*     return x; */\n\n/* } */\n\nstatic double s_nlobj_dq_fd_helper( void *vcx, const struct aa_dvec *x)\n{\n    struct kin_solve_cx *cx = (struct kin_solve_cx*)vcx;\n    void *ptrtop = aa_mem_region_ptr(cx->reg);\n    assert(1 == x->inc);\n\n    aa_rx_fk_sub(cx->fk, cx->ssg, x);\n    double *E_act = aa_rx_fk_ref(cx->fk, cx->frame);\n\n    double S_act[8], S_ref[8], S_err[8], S_ln[8];\n    aa_tf_qutr2duqu(E_act, S_act);\n    aa_tf_qutr2duqu(cx->TF_ref->data, S_ref);\n    aa_tf_duqu_cmul(S_act,S_ref,S_err);\n    aa_tf_duqu_minimize(S_err);\n    aa_tf_duqu_ln(S_err, S_ln);\n    double result = aa_la_dot(8,S_ln,S_ln);\n\n    aa_mem_region_pop(cx->reg, ptrtop);\n    return result;\n}\n\nAA_API double\naa_rx_ik_opt_err_dqln_fd( void *vcx, const double *q, double *dq )\n{\n    struct kin_solve_cx *cx = (struct kin_solve_cx*)vcx;\n    size_t n = aa_rx_sg_sub_config_count(cx->ssg);\n\n    struct aa_dvec vq = AA_DVEC_INIT(n,(double*)q,1);\n    double x = s_nlobj_dq_fd_helper(vcx, &vq);\n\n    if( dq ) {\n        struct aa_dvec vdq = AA_DVEC_INIT(n,dq,1);\n        // TODO: make epsilon a parameter\n        double eps = 1e-6;\n        aa_de_grad_fd( s_nlobj_dq_fd_helper, vcx,\n                       &vq, eps, &vdq );\n    }\n\n    return x;\n}\n\nstatic void\nmv_block_helper (const double *A, const double *x, double *y)\n{\n    cblas_dgemv(CblasColMajor, CblasTrans, 8, 4,\n                1, A, 8, x, 1,\n                0, y, 1);\n    cblas_dgemv(CblasColMajor, CblasTrans, 4, 4,\n                1, A, 8, x+4, 1,\n                0, y+4, 1);\n}\n\nstatic void\nduqu_rmul_helper( const double *Sr, const double *x, double *y )\n{\n    double M[8*8];\n    aa_tf_duqu_matrix_r(Sr,M,8);\n    mv_block_helper(M, x, y);\n}\n\n\nAA_API double\naa_rx_ik_opt_err_dqln( void *vcx, double *q, double *dq ) {\n    struct kin_solve_cx *cx = (struct kin_solve_cx*)vcx;\n    void *ptrtop = aa_mem_region_ptr(cx->reg);\n\n    size_t n = aa_rx_sg_sub_config_count(cx->ssg);\n    struct aa_dvec vq = AA_DVEC_INIT(n,(double*)q,1);\n    aa_rx_fk_sub(cx->fk, cx->ssg, &vq );\n    double *E_act = aa_rx_fk_ref(cx->fk, cx->frame);\n\n\n    double S_act[8], S_ref[8], S_err[8], S_ln[8];\n    aa_tf_qutr2duqu(E_act, S_act);\n    aa_tf_qutr2duqu(cx->TF_ref->data, S_ref);\n    aa_tf_duqu_cmul(S_act,S_ref,S_err);\n    // Apply a negative factor in gradient when we have to minimze the\n    // error quaternion\n    int needs_min = (S_err[AA_TF_DUQU_REAL_W] < 0 );\n    if( needs_min ) {\n        for( size_t i = 0; i < 8; i ++ ) S_err[i] *= -1;\n    } else {\n    }\n    aa_tf_duqu_ln(S_err, S_ln);\n    double result = aa_la_dot(8,S_ln,S_ln);\n\n    if( dq ) {\n        if( needs_min ) {\n            for( size_t i = 0; i < 8; i ++ ) S_ln[i] *= -1;\n        }\n        struct aa_dvec v_dq = AA_DVEC_INIT(n,dq,1);\n\n        /*\n         * g_sumsq * J_ln*[S_ref]_r*J_conj*J_S\n         * -> J_ln^T g_sumsq * [S_ref]_r*J_conj*J_S\n         * -> [S_ref]_r^T (J_ln^T g_sumsq) *J_conj*J_S\n         * -> J_conj^T*[S_ref]_r^T (J_ln^T g_sumsq) * J_S\n         * -> J_S^T J_conj^T * [S_ref]_r^T * J_ln^T g_sumsq\n         */\n\n        double a[8], b[8], dJ[8*8];\n        struct aa_dmat vJ_8x8 = AA_DMAT_INIT(8,8,dJ,8);\n        struct aa_dmat *J_8x8 = &vJ_8x8;\n\n        {\n            struct aa_dmat *J_ln = J_8x8;\n            aa_tf_duqu_ln_jac(S_err,J_ln);\n            /*\n             *  struct aa_dvec v_S_ln = AA_DVEC_INIT(8,S_ln,1);\n             * //aa_dmat_gemv( CblasTrans, 2, J_8x8, &v_S_ln, 0, &va );\n             *\n             * Avoid multiplying by the zero block:\n             *\n             * J_ln = [J_r   0]     J_ln^T = [J_r^T J_d^T]\n             *        [J_d J_r]              [  0   J_r^T]\n             *\n             * J_ln^T * del(S_ln^T*S_ln)^T = 2*J_ln^T S_ln\n             *\n             * 2*J_ln^T S_ln = 2*[J_r^T  J_d^T] (S_ln_r)\n             *                   [   0   J_r^T] (S_ln_d)\n             *\n             */\n            mv_block_helper(dJ, S_ln, a);\n        }\n\n\n        /*\n         * dS/dphi = [S]_R V J\n         * g [S]_R V J\n         * -> [S]_R^T g V J\n         * -> V^T [S]_R^T g J\n         * -> J^T V [S]_R^T g\n         */\n\n        duqu_rmul_helper( S_ref, a, b );\n        aa_tf_duqu_conj1(b);\n\n        duqu_rmul_helper( S_act, b, a );  /* TODO: Pure result, some\n                                           * extra multiplies here. */\n        // a is now a pure dual quaternion\n        {\n            double c[6];\n            struct aa_dvec vc = AA_DVEC_INIT(6,c,1);\n            // Using Twist Jacobian\n            aa_tf_duqu2pure(a,c);\n            struct aa_dmat *Jtw = aa_rx_sg_sub_jac_twist_get(cx->ssg, cx->reg, cx->fk);\n            aa_dmat_gemv( CblasTrans, 1, Jtw, &vc, 0, &v_dq );\n\n            // Using Velocity Jacobian\n            /* aa_tf_cross_a(a+AA_TF_DUQU_DUAL_XYZ,E_act+AA_TF_QUTR_V,a); */\n            /* aa_tf_duqu2pure(a,c); */\n            /* struct aa_dmat *J_vel = aa_rx_sg_sub_get_jacobian(cx->ssg,cx->reg,cx->TF); */\n            /* aa_dmat_gemv( CblasTrans, 1, J_vel, &vc, 0, &v_dq ); */\n\n        }\n\n\n        /* { */\n        /*     struct aa_dvec *v_dq_fd = aa_dvec_alloc(cx->reg,n); */\n        /*     double eps = 1e-6; */\n        /*     aa_de_grad_fd( s_nlobj_dq_fd_helper, vcx, */\n        /*                    &vq, eps, v_dq_fd ); */\n\n\n        /*     printf(\"--\\n\"); */\n        /*     printf(\"needs min: %d\\n\", needs_min); */\n        /*     printf(\"ad: \"); */\n        /*     aa_dump_vec(stdout,v_dq_fd->data,n); */\n        /*     printf(\"an: \"); */\n        /*     aa_dump_vec(stdout,dq,n); */\n\n        /*     assert( aa_dvec_ssd(v_dq_fd, &v_dq) < 1e-3 ); */\n        /* } */\n    }\n\n    aa_mem_region_pop(cx->reg, ptrtop);\n    return result;\n}\n\nstatic double s_nlobj_qv_fd_trans_helper( void *vcx, const struct aa_dvec *x)\n{\n    struct kin_solve_cx *cx = (struct kin_solve_cx*)vcx;\n    assert(1 == x->inc);\n\n    aa_rx_fk_sub(cx->fk, cx->ssg, x);\n    double *E_act = aa_rx_fk_ref(cx->fk, cx->frame);\n    double *v_act = E_act + AA_TF_QUTR_V;\n\n    double *E_ref = cx->TF_ref->data;\n    double *v_ref = E_ref + AA_TF_QUTR_V;\n\n    double E_err[7];\n    double *v_err = E_err + AA_TF_QUTR_V;\n\n\n    for(size_t i = 0; i < 3; i ++ ) v_err[i] = v_act[i] - v_ref[i];\n\n    double result = aa_tf_vdot(v_err,v_err);\n\n    return result;\n}\n\nAA_API double\naa_rx_ik_opt_err_trans_fd( void *vcx, const double *q, double *dq )\n{\n    struct kin_solve_cx *cx = (struct kin_solve_cx*)vcx;\n    size_t n = aa_rx_sg_sub_config_count(cx->ssg);\n\n    struct aa_dvec vq = AA_DVEC_INIT(n,(double*)q,1);\n    double x = s_nlobj_qv_fd_trans_helper(vcx, &vq);\n\n    if( dq ) {\n        struct aa_dvec vdq = AA_DVEC_INIT(n,dq,1);\n        // TODO: make epsilon a parameter\n        double eps = 1e-6;\n        aa_de_grad_fd( s_nlobj_qv_fd_trans_helper, vcx,\n                       &vq, eps, &vdq );\n    }\n    /* fprintf(stdout, \"fd error: %2.2f\\n\", x);  */\n    return x;\n}\n\nstatic double s_nlobj_qv_fd_helper( void *vcx, const struct aa_dvec *x)\n{\n    struct kin_solve_cx *cx = (struct kin_solve_cx*)vcx;\n    void *ptrtop = aa_mem_region_ptr(cx->reg);\n    assert(1 == x->inc);\n\n    aa_rx_fk_sub(cx->fk, cx->ssg, x);\n    double *E_act = aa_rx_fk_ref(cx->fk, cx->frame);\n    double *v_act = E_act + AA_TF_QUTR_V;\n    double *q_act = E_act + AA_TF_QUTR_Q;\n\n    double *E_ref = cx->TF_ref->data;\n    double *v_ref = E_ref + AA_TF_QUTR_V;\n    double *q_ref = E_ref + AA_TF_QUTR_Q;\n\n    double E_err[7];\n    double *v_err = E_err + AA_TF_QUTR_V;\n    double *q_err = E_err + AA_TF_QUTR_Q;\n\n    aa_tf_qcmul(q_act,q_ref,q_err);\n\n    double q_ln[4];\n    aa_tf_qminimize(q_err);\n    aa_tf_duqu_ln(q_err, q_ln);\n\n    for(size_t i = 0; i < 3; i ++ ) v_err[i] = v_act[i] - v_ref[i];\n\n    double result = ( aa_tf_qdot(q_ln,q_ln)\n                      +\n                      aa_tf_vdot(v_err,v_err) );\n\n    aa_mem_region_pop(cx->reg, ptrtop);\n    return result;\n}\n\n\nAA_API double\naa_rx_ik_opt_err_qlnpv_fd( void *vcx, const double *q, double *dq )\n{\n    struct kin_solve_cx *cx = (struct kin_solve_cx*)vcx;\n    size_t n = aa_rx_sg_sub_config_count(cx->ssg);\n\n    struct aa_dvec vq = AA_DVEC_INIT(n,(double*)q,1);\n    double x = s_nlobj_qv_fd_helper(vcx, &vq);\n\n    if( dq ) {\n        struct aa_dvec vdq = AA_DVEC_INIT(n,dq,1);\n        // TODO: make epsilon a parameter\n        double eps = 1e-6;\n        aa_de_grad_fd( s_nlobj_qv_fd_helper, vcx,\n                       &vq, eps, &vdq );\n    }\n\n    return x;\n}\n\nAA_API double\naa_rx_ik_opt_err_trans( void *vcx, const double *q, double *dq )\n{\n    struct kin_solve_cx *cx = (struct kin_solve_cx*)vcx;\n    void *ptrtop = aa_mem_region_ptr(cx->reg);\n\n    size_t n = aa_rx_sg_sub_config_count(cx->ssg);\n    struct aa_dvec vq = AA_DVEC_INIT(n,(double*)q,1);\n    aa_rx_fk_sub(cx->fk, cx->ssg, &vq );\n\n    double *E_act = aa_rx_fk_ref(cx->fk, cx->frame);\n    double *v_act = E_act + AA_TF_QUTR_V;\n\n    double *E_ref = cx->TF_ref->data;\n    double *v_ref = E_ref + AA_TF_QUTR_V;\n\n    double E_err[7];\n    double *v_err = E_err + AA_TF_QUTR_V;\n\n    // Apply a negative factor in gradient when we have to minimze the\n    // error quaternion\n\n\n    for(size_t i = 0; i < 3; i ++ ) v_err[i] = v_act[i] - v_ref[i];\n\n    double result = aa_tf_vdot(v_err,v_err);\n\n    if( dq ) {\n\n        struct aa_dvec v_dq = AA_DVEC_INIT(n,dq,1);\n\n        struct aa_dmat *Jvel = aa_rx_sg_sub_jac_vel_get(cx->ssg, cx->reg, cx->fk);\n        struct aa_dmat Jr, Jv;\n        aa_dmat_view_block(&Jv, Jvel, AA_TF_DX_V, 0, 3, Jvel->cols);\n        aa_dmat_view_block(&Jr, Jvel, AA_TF_DX_W, 0, 3, Jvel->cols);\n\n        // Translational Part\n        struct aa_dvec v_v_err = AA_DVEC_INIT(3,v_err,1);\n        aa_dmat_gemv(CblasTrans, 2, &Jv, &v_v_err, 0, &v_dq);\n    }\n\n    aa_mem_region_pop(cx->reg, ptrtop);\n    /* printf(\"err: %f\\n\", result); */\n    return result;\n}\n\nstatic void\nq_rmul_helper( const double *q, const struct aa_dvec *x, struct aa_dvec *y )\n{\n    double dM[4*4];\n    struct aa_dmat M = AA_DMAT_INIT(4,4,dM,4);\n    aa_tf_qmat_r(q,&M);\n    aa_dmat_gemv(CblasTrans, 1, &M, x, 0, y);\n}\n\n\nAA_API double\naa_rx_ik_opt_err_qlnpv( void *vcx, const double *q, double *dq )\n{\n    struct kin_solve_cx *cx = (struct kin_solve_cx*)vcx;\n    void *ptrtop = aa_mem_region_ptr(cx->reg);\n\n    size_t n = aa_rx_sg_sub_config_count(cx->ssg);\n    struct aa_dvec vq = AA_DVEC_INIT(n,(double*)q,1);\n    aa_rx_fk_sub(cx->fk, cx->ssg, &vq );\n\n    double *E_act = aa_rx_fk_ref(cx->fk, cx->frame);\n    double *v_act = E_act + AA_TF_QUTR_V;\n    double *q_act = E_act + AA_TF_QUTR_Q;\n\n    double *E_ref = cx->TF_ref->data;\n    double *v_ref = E_ref + AA_TF_QUTR_V;\n    double *q_ref = E_ref + AA_TF_QUTR_Q;\n\n    double E_err[7];\n    double *v_err = E_err + AA_TF_QUTR_V;\n    double *q_err = E_err + AA_TF_QUTR_Q;\n\n    aa_tf_qcmul(q_act,q_ref,q_err);\n\n    // Apply a negative factor in gradient when we have to minimze the\n    // error quaternion\n    int needs_min = (E_err[AA_TF_QUAT_W] < 0 );\n    if( needs_min ) {\n        for( size_t i = 0; i < 4; i ++ ) E_err[i] *= -1;\n    }\n\n    double q_ln[4];\n    aa_tf_qln(E_err, q_ln);\n\n    for(size_t i = 0; i < 3; i ++ ) v_err[i] = v_act[i] - v_ref[i];\n\n    double result = ( aa_tf_qdot(q_ln,q_ln) +\n                      + aa_tf_vdot(v_err,v_err) );\n\n    if( dq ) {\n\n        struct aa_dvec v_dq = AA_DVEC_INIT(n,dq,1);\n\n        struct aa_dmat *Jvel = aa_rx_sg_sub_jac_vel_get(cx->ssg, cx->reg, cx->fk);\n        struct aa_dmat Jr, Jv;\n        aa_dmat_view_block(&Jv, Jvel, AA_TF_DX_V, 0, 3, Jvel->cols);\n        aa_dmat_view_block(&Jr, Jvel, AA_TF_DX_W, 0, 3, Jvel->cols);\n\n        // Translational Part\n        struct aa_dvec v_v_err = AA_DVEC_INIT(3,v_err,1);\n        aa_dmat_gemv(CblasTrans, 2, &Jv, &v_v_err, 0, &v_dq);\n\n        // Rotational Part\n        if( needs_min ) {\n            for( size_t i = 0; i < 4; i ++ ) q_ln[i] *= -1;\n        }\n\n        double a[4], b[4], dJ[4*4];\n        struct aa_dvec va = AA_DVEC_INIT(4,a,1);\n        struct aa_dvec vb = AA_DVEC_INIT(4,b,1);\n        struct aa_dvec vln = AA_DVEC_INIT(4,q_ln,1);\n        struct aa_dmat vJ_4x4 = AA_DMAT_INIT(4,4,dJ,4);\n        struct aa_dmat *J_4x4 = &vJ_4x4;\n\n        {\n            struct aa_dmat *J_ln = J_4x4;\n            aa_tf_qln_jac(q_err,J_ln);\n            aa_dmat_gemv(CblasTrans, 1, J_ln, &vln, 0, &va);\n        }\n\n        q_rmul_helper( q_ref, &va, &vb );\n        aa_tf_qconj1(b);\n\n        q_rmul_helper( q_act, &vb, &va ); /* TODO: Pure result, some\n                                           * extra multiplies here. */\n\n        // a is now a pure dual quaternion */\n        {\n            struct aa_dvec va3 = AA_DVEC_INIT(3,a,1);\n            aa_dmat_gemv( CblasTrans, 1, &Jr, &va3, 1, &v_dq );\n        }\n\n\n        /* { */\n        /*     struct aa_dvec *v_dq_fd = aa_dvec_alloc(cx->reg,n); */\n        /*     double eps = 1e-6; */\n        /*     aa_de_grad_fd( s_nlobj_qv_fd_helper, vcx, */\n        /*                    &vq, eps, v_dq_fd ); */\n\n\n        /*     printf(\"--\\n\"); */\n        /*     printf(\"needs min: %d\\n\", needs_min); */\n        /*     printf(\"ad: \"); */\n        /*     aa_dump_vec(stdout,v_dq_fd->data,n); */\n        /*     printf(\"an: \"); */\n        /*     aa_dump_vec(stdout,dq,n); */\n\n        /*     assert( aa_dvec_ssd(v_dq_fd, &v_dq) < 1e-3 ); */\n        /* } */\n    }\n\n    aa_mem_region_pop(cx->reg, ptrtop);\n    //printf(\"err: %f\\n\", result);\n    return result;\n}\n\n\n// TODO: weighted error\n\nAA_API double\naa_rx_ik_opt_err_jcenter( void *vcx, const double *q, double *dq )\n{\n    struct kin_solve_cx *cx = (struct kin_solve_cx*)vcx;\n    struct aa_mem_region *reg = cx->reg;\n    void *ptrtop = aa_mem_region_ptr(reg);\n\n    size_t n = aa_rx_sg_sub_config_count(cx->ssg);\n    struct aa_dvec *q_center = aa_dvec_alloc(reg,n);\n    aa_rx_sg_sub_center_configv(cx->ssg,q_center);\n\n    double result = 0;\n\n    if( dq ) { // error and gradient\n        for( size_t i = 0; i < n; i ++ ) {\n            double d = q[i] - AA_DVEC_REF(q_center,i);\n            result += (d*d);\n            dq[i] = d;\n        }\n        //printf(\"--\\n\");\n        //printf(\"q:  \"); aa_dump_vec(stdout,q,n);\n        //printf(\"qc: \"); aa_dump_vec(stdout,q_center->data,n);\n        //printf(\"dq: \"); aa_dump_vec(stdout,dq,n);\n    } else { // error only\n        for( size_t i = 0; i < n; i ++ ) {\n            double d = q[i] - AA_DVEC_REF(q_center,i);\n            result += (d*d);\n        }\n    }\n\n    aa_mem_region_pop(cx->reg, ptrtop);\n\n    return result / 2;\n}\n\nstruct err_cx {\n    void *cx;\n    aa_rx_ik_opt_fun *fun;\n};\n\nstatic double\ns_err_cx_dispatch(unsigned n, const double *q, double *dq, void *vcx)\n{\n    (void)n;\n    struct err_cx *cx = (struct err_cx *)vcx;\n    return cx->fun(cx->cx, q, dq);\n}\n\nstatic int\ns_ik_nlopt( struct kin_solve_cx *cx,\n            struct aa_dvec *q )\n{\n    struct aa_mem_region *reg = cx->reg;\n    void *ptrtop = aa_mem_region_ptr(reg);\n\n    const struct aa_rx_sg_sub *ssg = cx->ssg;\n    const struct aa_rx_sg *sg = cx->ssg->scenegraph;\n\n    if( 1 != cx->q_sub->inc || 1 != cx->q_all->inc ) {\n        return AA_RX_INVALID_PARAMETER;\n    }\n\n    size_t n_sub = cx->q_sub->len;\n    nlopt_algorithm alg = NLOPT_LD_SLSQP;\n    nlopt_opt opt = nlopt_create(alg, (unsigned)n_sub); /* algorithm and dimensionality */\n\n    struct err_cx ocx, eqctcx;\n    ocx.cx = cx;\n    ocx.fun = cx->ik_cx->opts->obj_fun;\n    nlopt_set_min_objective(opt, s_err_cx_dispatch, &ocx);\n\n    if( cx->ik_cx->opts->eqct_fun ) {\n        eqctcx.cx = cx;\n        eqctcx.fun = cx->ik_cx->opts->eqct_fun;\n        nlopt_add_equality_constraint(opt, s_err_cx_dispatch, &eqctcx,\n                                      cx->ik_cx->opts->eqct_tol);\n    }\n\n\n    //nlopt_set_xtol_rel(opt, 1e-4); // TODO: make a parameter\n    if( cx->opts->tol_obj_abs >= 0 )\n        nlopt_set_ftol_abs(opt, cx->opts->tol_obj_abs );\n    if( cx->opts->tol_obj_rel >= 0 )\n        nlopt_set_ftol_rel(opt, cx->opts->tol_obj_rel );\n    if( cx->opts->tol_dq >= 0 )\n        nlopt_set_xtol_rel(opt, cx->opts->tol_dq );\n\n    double *lb = AA_MEM_REGION_NEW_N(reg,double,n_sub);\n    double *ub = AA_MEM_REGION_NEW_N(reg,double,n_sub);\n    { // bounds\n        for( size_t i = 0; i < n_sub; i ++ ) {\n            aa_rx_config_id id = aa_rx_sg_sub_config(ssg,i);\n            if( aa_rx_sg_get_limit_pos(sg, id, lb+i, ub+i) )\n            {\n                lb[i] = -DBL_MAX;\n                ub[i] = DBL_MAX;\n            }\n        }\n    }\n\n\n    nlopt_set_lower_bounds(opt, lb);\n    nlopt_set_upper_bounds(opt, ub);\n    double minf;\n    nlopt_result ores = nlopt_optimize(opt, cx->q_sub->data, &minf);\n    if( cx->opts->debug ) {\n        /* fprintf(\"AMINO IK NLOPT RESULT: %s (%d)\", */\n        /*         nlopt_result_to_string(ores), ores); */\n\n        fprintf(stderr, \"AMINO IK NLOPT RESULT: %d\\n\", ores);\n    }\n    aa_dvec_copy( cx->q_sub, q );\n\n\n    aa_rx_fk_sub(cx->fk, cx->ssg, q);\n    double *E_act = aa_rx_fk_ref(cx->fk, cx->frame);\n    int result = s_check(cx->ik_cx, cx->TF_ref, E_act );\n    nlopt_destroy(opt);\n    aa_mem_region_pop(reg,ptrtop);\n\n    return result;\n\n}\n", "meta": {"hexsha": "a53d432597318d55f5b230e1ee0ee3c89596b329", "size": 19620, "ext": "c", "lang": "C", "max_stars_repo_path": "src/rx/ik_nlopt.c", "max_stars_repo_name": "dyalab/amino", "max_stars_repo_head_hexsha": "e3063ceeeed7d1a3d55fc0d3071c9aacb4466b22", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/rx/ik_nlopt.c", "max_issues_repo_name": "dyalab/amino", "max_issues_repo_head_hexsha": "e3063ceeeed7d1a3d55fc0d3071c9aacb4466b22", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/rx/ik_nlopt.c", "max_forks_repo_name": "dyalab/amino", "max_forks_repo_head_hexsha": "e3063ceeeed7d1a3d55fc0d3071c9aacb4466b22", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.4186046512, "max_line_length": 92, "alphanum_fraction": 0.5811926606, "num_tokens": 6489, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4843800991636032, "lm_q2_score": 0.036769466207539105, "lm_q1q2_score": 0.017810397687800548}}
{"text": "/*\n * Copyright 2020 Makani Technologies LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef SIM_MATH_ODE_SOLVER_GSL_H_\n#define SIM_MATH_ODE_SOLVER_GSL_H_\n\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_odeiv2.h>\n#include <stdint.h>\n\n#include <vector>\n\n#include \"common/macros.h\"\n#include \"sim/math/ode_solver.h\"\n#include \"sim/sim_types.h\"\n\nnamespace sim {\n\n// Wrapper for the GSL ODE library.\nclass GslOdeSolver : public OdeSolver {\n public:\n  explicit GslOdeSolver(const OdeSystem &ode_system,\n                        const SimOdeSolverParams &params);\n  ~GslOdeSolver() {\n    if (ode_driver_ != nullptr) gsl_odeiv2_driver_free(ode_driver_);\n  }\n\n  OdeSolverStatus Integrate(double t0, double tf, const std::vector<double> &x0,\n                            double *t_int, std::vector<double> *x) override;\n\n private:\n  // Static callback function for the GSL ODE solver.\n  //\n  // Args:\n  //   t: Time at which derivative will be evaluated.\n  //   x: Array of length num_states() containing the state at which\n  //       the derivative will be evaluated.\n  //   dx: Array of length num_states() into which the derivative is stored.\n  //   context: Pointer to the OdeSolver class containing the OdeSystem.\n  //\n  // Returns:\n  //   GSL_SUCCESS if the derivative was calculated successfully,\n  //   GSL_FAILURE if the time step was too large, or\n  //   GSL_EBADFUNC if the integration should be aborted immediately.\n  static int32_t GslCallback(double t, const double x[], double dx[],\n                             void *context);\n\n  // Solver parameters.\n  const SimOdeSolverParams &params_;\n\n  // ODE to be solved.\n  const OdeSystem &ode_system_;\n\n  // Parameters for GSL.\n  gsl_odeiv2_system sys_;\n  gsl_odeiv2_driver *ode_driver_;\n\n  DISALLOW_COPY_AND_ASSIGN(GslOdeSolver);\n};\n\n}  // namespace sim\n\n#endif  // SIM_MATH_ODE_SOLVER_GSL_H_\n", "meta": {"hexsha": "0befb4297c5d76acb52df286780b26b54a1f4109", "size": 2362, "ext": "h", "lang": "C", "max_stars_repo_path": "sim/math/ode_solver_gsl.h", "max_stars_repo_name": "leozz37/makani", "max_stars_repo_head_hexsha": "c94d5c2b600b98002f932e80a313a06b9285cc1b", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1178.0, "max_stars_repo_stars_event_min_datetime": "2020-09-10T17:15:42.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T14:59:35.000Z", "max_issues_repo_path": "sim/math/ode_solver_gsl.h", "max_issues_repo_name": "leozz37/makani", "max_issues_repo_head_hexsha": "c94d5c2b600b98002f932e80a313a06b9285cc1b", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2020-05-22T05:22:35.000Z", "max_issues_repo_issues_event_max_datetime": "2020-05-22T05:22:35.000Z", "max_forks_repo_path": "sim/math/ode_solver_gsl.h", "max_forks_repo_name": "leozz37/makani", "max_forks_repo_head_hexsha": "c94d5c2b600b98002f932e80a313a06b9285cc1b", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 107.0, "max_forks_repo_forks_event_min_datetime": "2020-09-10T17:29:30.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-18T09:00:14.000Z", "avg_line_length": 30.6753246753, "max_line_length": 80, "alphanum_fraction": 0.7078746825, "num_tokens": 586, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.476579651063676, "lm_q2_score": 0.03732688975366457, "lm_q1q2_score": 0.017789236094093764}}
{"text": "/*\n * Copyright (c) 2011-2018 The University of Tennessee and The University\n *                         of Tennessee Research Foundation.  All rights\n *                         reserved.\n *\n * @precisions normal z -> s d c\n *\n */\n#include \"dplasma_cores.h\"\n#include \"dplasma_zcores.h\"\n\n#if defined(PARSEC_HAVE_STRING_H)\n#include <string.h>\n#endif  /* defined(PARSEC_HAVE_STRING_H) */\n#if defined(PARSEC_HAVE_STDARG_H)\n#include <stdarg.h>\n#endif  /* defined(PARSEC_HAVE_STDARG_H) */\n#include <stdio.h>\n#ifdef PARSEC_HAVE_LIMITS_H\n#include <limits.h>\n#endif\n#include <stdlib.h>\n\n#include <cblas.h>\n#include <core_blas.h>\n\n#define max(a, b) ((a) > (b) ? (a) : (b))\n#define min(a, b) ((a) < (b) ? (a) : (b))\n#if defined(ADD_)\n#define  DLARFG      zlarfg_\n#else\n#define  DLARFG      zlarfg\n#endif\nextern void DLARFG(int *N, parsec_complex64_t *ALPHA, parsec_complex64_t *X, int *INCX, parsec_complex64_t *TAU);\n\n//static void band_to_trd_vmpi1(int N, int NB, parsec_complex64_t *A, int LDA);\n//static void band_to_trd_vmpi2(int N, int NB, parsec_complex64_t *A, int LDA);\n//static void band_to_trd_v8seq(int N, int NB, parsec_complex64_t *A, int LDA, int INgrsiz, int INthgrsiz);\n//static int  TRD_seqgralgtype(int N, int NB, parsec_complex64_t *A, int LDA, parsec_complex64_t *C, parsec_complex64_t *S, int i, int j, int m, int grsiz, int BAND);\nint  blgchase_ztrdv1(int NT, int N, int NB, parsec_complex64_t *A, parsec_complex64_t *V, parsec_complex64_t *TAU, int sweep, int id, int blktile);\nint  blgchase_ztrdv2(int NT, int N, int NB, parsec_complex64_t *A1, parsec_complex64_t *A2, parsec_complex64_t *V1, parsec_complex64_t *TAU1, parsec_complex64_t *V2, parsec_complex64_t *TAU2, int sweep, int id, int blktile);\n\nint CORE_zlarfx2(int side, int N,\n                parsec_complex64_t V,\n                parsec_complex64_t TAU,\n                parsec_complex64_t *C1, int LDC1,\n                parsec_complex64_t *C2, int LDC2);\n\nint CORE_zlarfx2c(int uplo,\n                parsec_complex64_t V,\n                parsec_complex64_t TAU,\n                parsec_complex64_t *C1,\n                parsec_complex64_t *C2,\n                parsec_complex64_t *C3);\n\nstatic void CORE_zhbtelr(int N, int NB, parsec_complex64_t *A1, int LDA1, parsec_complex64_t *A2, int LDA2, parsec_complex64_t *V1, parsec_complex64_t *TAU1, int st, int ed);\nstatic void CORE_zhbtrce(int N, int NB, parsec_complex64_t *A1, int LDA1, parsec_complex64_t *A2, int LDA2, parsec_complex64_t *V1, parsec_complex64_t *TAU1, parsec_complex64_t *V2, parsec_complex64_t *TAU2, int st, int ed, int edglob);\nstatic void CORE_zhbtlrx(int N, int NB, parsec_complex64_t *A1, int LDA1, parsec_complex64_t *A2, int LDA2, parsec_complex64_t *V1, parsec_complex64_t *TAU1, int st, int ed);\n\nstatic void DLARFX_C(char side, int N, parsec_complex64_t V, parsec_complex64_t TAU, parsec_complex64_t *C, int LDC);\nstatic void TRD_type1bHL(int N, int NB, parsec_complex64_t *A, int LDA, parsec_complex64_t *V, parsec_complex64_t *TAU, int st, int ed);\nstatic void TRD_type2bHL(int N, int NB, parsec_complex64_t *A, int LDA, parsec_complex64_t *V, parsec_complex64_t *TAU, int st, int ed);\nstatic void TRD_type3bHL(int N, int NB, parsec_complex64_t *A, int LDA, parsec_complex64_t *V, parsec_complex64_t *TAU, int st, int ed);\n\n\nint CORE_zlarfx2(int side, int N,\n                parsec_complex64_t V,\n                parsec_complex64_t TAU,\n                parsec_complex64_t *C1, int LDC1,\n                parsec_complex64_t *C2, int LDC2)\n{\n    static parsec_complex64_t zzero = 0.0;\n    int    J;\n    parsec_complex64_t V2, T2, SUM;\n\n    /* Quick return */\n    /*\n    if (N == 0)\n        return PLASMA_SUCCESS;\n    */\n    if (TAU == zzero)\n        return 0;\n\n    /*\n     * Special code for 2 x 2 Householder where V1 = I\n    */\n    if(side==PlasmaLeft){\n        V2 = conj(V);\n        T2 = TAU*conj(V2);\n        for (J = 0; J < N ; J++){\n           SUM         = C1[J*LDC1]   + V2*C2[J*LDC2];\n           C1[J*LDC1]  = C1[J*LDC1]   - SUM*TAU;\n           C2[J*LDC2]  = C2[J*LDC2]   - SUM*T2;\n        }\n    }else if(side==PlasmaRight){\n        V2 = V;\n        T2 = TAU*conj(V2);\n        for (J = 0; J < N ; J++){\n           SUM     = C1[J]   + V2*C2[J];\n           C1[J]   = C1[J]   - SUM*TAU;\n           C2[J]   = C2[J]   - SUM*T2;\n        }\n    }\n\n    return 0;\n}\n\n/***************************************************************************//**\n *\n **/\nint CORE_zlarfx2c(int uplo,\n                parsec_complex64_t V,\n                parsec_complex64_t TAU,\n                parsec_complex64_t *C1,\n                parsec_complex64_t *C2,\n                parsec_complex64_t *C3)\n{\n    static parsec_complex64_t zzero = 0.0;\n    parsec_complex64_t T2, SUM, TEMP;\n\n    /* Quick return */\n    if (TAU == zzero)\n        return 0;\n\n   /*\n    *        Special code for a diagonal block  C1\n    *                                           C2  C3\n    */\n if(uplo==PlasmaLower){   //do the corner Left then Right (used for the lower case tridiag)\n      // L and R for the 2x2 corner\n      //            C(N-1, N-1)  C(N-1,N)        C1  TEMP\n      //            C(N  , N-1)  C(N  ,N)        C2  C3\n      // For Left : use conj(TAU) and V.\n      // For Right: nothing, keep TAU and V.\n      // Left 1 ==> C1\n      //            C2\n      TEMP    = conj(C2[0]); // copy C2 here before modifying it.\n      T2      = conj(TAU)*V;\n      SUM     = C1[0]   + conj(V)*C2[0];\n      C1[0]   = C1[0]   - SUM*conj(TAU);\n      C2[0]   = C2[0]   - SUM*T2;\n      // Left 2 ==> TEMP\n      //            C3\n      SUM     = TEMP    + conj(V)*C3[0];\n      TEMP    = TEMP    - SUM*conj(TAU);\n      C3[0]   = C3[0]   - SUM*T2;\n      // Right 1 ==>  C1 TEMP.  NB: no need to compute corner (2,2)=TEMP\n      T2      = TAU*conj(V);\n      SUM     = C1[0]   + V*TEMP;\n      C1[0]   = C1[0]   - SUM*TAU;\n      // Right 2 ==> C2 C3\n      SUM     = C2[0]   + V*C3[0];\n      C2[0]   = C2[0]   - SUM*TAU;\n      C3[0]   = C3[0]   - SUM*T2;\n }else if(uplo==PlasmaUpper){ // do the corner Right then Left (used for the upper case tridiag)\n      //            C(N-1, N-1)  C(N-1,N)        C1    C2\n      //            C(N  , N-1)  C(N  ,N)        TEMP  C3\n      // For Left : use TAU       and conj(V).\n      // For Right: use conj(TAU) and conj(V).\n      // Right 1 ==> C1 C2\n      V       = conj(V);\n      TEMP    = conj(C2[0]); // copy C2 here before modifying it.\n      T2      = conj(TAU)*conj(V);\n      SUM     = C1[0]   + V*C2[0];\n      C1[0]   = C1[0]   - SUM*conj(TAU);\n      C2[0]   = C2[0]   - SUM*T2;\n      // Right 2 ==> TEMP C3\n      SUM     = TEMP    + V*C3[0];\n      TEMP    = TEMP    - SUM*conj(TAU);\n      C3[0]   = C3[0]   - SUM*T2;\n      // Left 1 ==> C1\n      //            TEMP. NB: no need to compute corner (2,1)=TEMP\n      T2      = TAU*V;\n      SUM     = C1[0]   + conj(V)*TEMP;\n      C1[0]   = C1[0]   - SUM*TAU;\n      // Left 2 ==> C2\n      //            C3\n      SUM     = C2[0]   + conj(V)*C3[0];\n      C2[0]   = C2[0]   - SUM*TAU;\n      C3[0]   = C3[0]   - SUM*T2;\n }\n\n return 0;\n}\n\n\n\n\n\n\n\n\n\n\n\n\n///////////////////////////////////////////////////////////\n//                  DLARFX en C\n///////////////////////////////////////////////////////////\nstatic void DLARFX_C(char side, int N, parsec_complex64_t V, parsec_complex64_t TAU, parsec_complex64_t *C, int LDC)\n{\n parsec_complex64_t T2, SUM, TEMP;\n int    J, pt;\n\n/*\n *        Special code for 2 x 2 Householder\n */\n\n\n T2 = TAU*V;\n if(side=='L'){\n     for (J = 0; J < N ; J++){\n        pt      = LDC*J;\n        SUM     = C[pt]   + V*C[pt+1];\n        C[pt]   = C[pt]   - SUM*TAU;\n        C[pt+1] = C[pt+1] - SUM*T2;\n     }\n }else if(side=='R'){\n     for (J = 0; J < N ; J++){\n        pt      = J+LDC;\n        SUM     = C[J]   + V*C[pt];\n        C[J]    = C[J]   - SUM*TAU;\n        C[pt]   = C[pt]  - SUM*T2;\n     }\n }else if(side=='B'){\n     TEMP    = C[ LDC * (N-2) +1];\n     for (J = 0; J < N-1 ; J++){\n        pt      = LDC*J;\n        SUM     = C[pt]   + V*C[pt+1];\n        C[pt]   = C[pt]   - SUM*TAU;\n        C[pt+1] = C[pt+1] - SUM*T2;\n     }\n     // L and R for the 2x2 corner\n     //            C(1, N-1)  C(1,N)        C(1, N-1)  TEMP\n     //            C(2, N-1)  C(2,N)        C(2, N-1)  C(2,N)\n     // Left 1 ==> C(1,N-1) C(2,N-1) deja fait dans la boucle\n     //pt      = LDC * (N-2);\n     //TEMP    = C[pt+1];\n     //SUM     = C[pt]   + V*C[pt+1];\n     //C[pt]   = C[pt]   - SUM*TAU;\n     //C[pt+1] = C[pt+1] - SUM*T2;\n     // Left 2 ==> TEMP C(2,N)\n     pt      = LDC * (N-1) +1;\n     SUM     = TEMP    + V*C[pt];\n     TEMP    = TEMP    - SUM*TAU;\n     C[pt]   = C[pt]   - SUM*T2;\n     // Right 1 ==>  C(1,N-1) TEMP.  NB: no need to compute corner (2,2)\n     J       = LDC * (N-2);\n     SUM     = C[J]   + V*TEMP;\n     C[J]    = C[J]   - SUM*TAU;\n     // Right 2 ==> C(2,N-1) C(2,N)\n     J      = LDC * (N-2) + 1;\n     pt     = LDC * (N-1) + 1;\n     SUM    = C[J]   + V*C[pt];\n     C[J]   = C[J]   - SUM*TAU;\n     C[pt]  = C[pt]  - SUM*T2;\n }\n}\n///////////////////////////////////////////////////////////\n\n///////////////////////////////////////////////////////////\n#define A1(m,n)   &(A1[((m)-(n)) + LDA1*(n)])\n#define A2(m,n)   &(A2[((m)-(n)) + LDA2*((n)-NB)])\n#define V1(m)     &(V1[m-st])\n#define TAU1(m)   &(TAU1[m-st])\n#define V2(m)     &(V2[m-st])\n#define TAU2(m)   &(TAU2[m-st])\n///////////////////////////////////////////////////////////\n//                  TYPE 1-BAND Householder\n///////////////////////////////////////////////////////////\nstatic void CORE_zhbtelr(int N, int NB, parsec_complex64_t *A1, int LDA1, parsec_complex64_t *A2, int LDA2, parsec_complex64_t *V1, parsec_complex64_t *TAU1, int st, int ed) {\n  int    J1, J2, KDM1, LDX;\n  int    len, len1, len2, t1ed, t2st;\n  int    i, IONE, ITWO;\n  IONE=1;\n  ITWO=2;\n  (void)N;\n\n  KDM1 = NB-1;\n  LDX = LDA2-1;\n  /* **********************************************************************************************\n   *   Annihiliate, then LEFT:\n   * ***********************************************************************************************/\n  for (i = ed; i >= st+1 ; i--){\n     /* generate Householder to annihilate a(i+k-1,i) within the band */\n     *V1(i)          = *A1(i, (st-1));\n     *A1(i, (st-1))  = 0.0;\n     DLARFG( &ITWO, A1((i-1),(st-1)), V1(i), &IONE, TAU1(i) );\n\n     J1   = st;\n     J2   = i-2;\n     t1ed = min(J2,KDM1);\n     t2st = max(J1, NB);\n     len1 = t1ed - J1 +1;\n     len2 = J2 - t2st +1;\n     // printf(\"Type 1L st %d   ed %d    i %d    J1 %d   J2 %d  t1ed %d  t2st %d len1 %d len2 %d \\n\", st, ed, i, J1,J2,t1ed,t2st,len1,len2);\n     /* apply reflector from the left (horizontal row) and from the right for only the diagonal 2x2.*/\n     if(len2>=0){\n        /* part of the left(if len2>0) and the corner are on tile T2 */\n        if(len2>0) CORE_zlarfx2(PlasmaLeft, len2 , *V1(i), conj(*TAU1(i)), A2((i-1), t2st), LDX, A2(i, t2st), LDX);\n        CORE_zlarfx2c(PlasmaLower, *V1(i), *TAU1(i), A2(i-1,i-1), A2(i,i-1), A2(i,i));\n        if(len1>0) CORE_zlarfx2(PlasmaLeft, len1 , *V1(i), conj(*TAU1(i)), A1(i-1, J1), LDX, A1(i, J1), LDX);\n     }else if(len2==-1){\n        /* the left is on tile T1, and only A(i,i) of the corner is on tile T2 */\n        CORE_zlarfx2c(PlasmaLower, *V1(i), *TAU1(i), A1(i-1,i-1), A1(i,i-1), A2(i,i));\n        if(len1>0) CORE_zlarfx2(PlasmaLeft, len1 , *V1(i), conj(*TAU1(i)), A1(i-1, J1), LDX, A1(i, J1), LDX);\n     }else{\n        /* the left and the corner are on tile T1, nothing on tile T2 */\n        CORE_zlarfx2c(PlasmaLower, *V1(i), *TAU1(i), A1(i-1,i-1), A1(i,i-1), A1(i,i)) ;\n        if(len1>0) CORE_zlarfx2(PlasmaLeft, len1 , *V1(i), conj(*TAU1(i)), A1((i-1), J1), LDX, A1(i, J1), LDX);\n     }\n  }\n  /* **********************************************************************************************\n   *   APPLY RIGHT ON THE REMAINING ELEMENT OF KERNEL 1\n   * ***********************************************************************************************/\n  for (i = ed; i >= st+1 ; i--){\n     J1    = i+1;\n     J2    = ed;\n     len   = J2-J1+1;\n     if(len>0){\n        if(i>NB)\n           /* both column (i-1) and i are on tile T2 */\n           CORE_zlarfx2(PlasmaRight, len, *V1(i), *TAU1(i), A2(J1, i-1), LDX, A2(J1, i), LDX);\n        else if(i==NB)\n           /* column (i-1) is on tile T1 while column i is on tile T2 */\n           CORE_zlarfx2(PlasmaRight, len, *V1(i), *TAU1(i), A1(J1, i-1), LDX, A2(J1, i), LDX);\n        else\n           /* both column (i-1) and i are on tile T1 */\n           CORE_zlarfx2(PlasmaRight, len, *V1(i), *TAU1(i), A1(J1, i-1), LDX, A1(J1, i), LDX);\n     }\n  }\n}\n///////////////////////////////////////////////////////////\n\n\n\n\n\n\n\n///////////////////////////////////////////////////////////\n//                  TYPE 2-BAND Householder\n///////////////////////////////////////////////////////////\nstatic void CORE_zhbtrce(int N, int NB, parsec_complex64_t *A1, int LDA1, parsec_complex64_t *A2, int LDA2, parsec_complex64_t *V1, parsec_complex64_t *TAU1, parsec_complex64_t *V2, parsec_complex64_t *TAU2, int st, int ed, int edglob) {\n  int    J1, J2, J3, KDM1, LDX, pt;\n  int    len, len1, len2, t1ed, t2st, iglob;\n  int    i, IONE, ITWO;\n  parsec_complex64_t V,T,SUM;\n  IONE=1;\n  ITWO=2;\n\n  iglob = edglob+1;\n  LDX   = LDA1-1;\n  KDM1  = NB-1;\n  /* **********************************************************************************************\n   *   Right:\n   * ***********************************************************************************************/\n  for (i = ed; i >= st+1 ; i--){\n     /* apply Householder from the right. and create newnnz outside the band if J3 < N */\n     iglob = iglob -1;\n     J1  = ed+1;\n     if((iglob+NB)>= N){\n        J2 = i +(N-iglob-1);\n        J3 = J2;\n     }else{\n        J2 = i + KDM1;\n        J3 = J2+1;\n     }\n     len   = J2-J1+1;\n     /* printf(\"Type 2R st %d   ed %d    i %d   J1 %d   J2 %d  len %d iglob %d  \\n\",st,ed,i,J1,J2,len,iglob);*/\n\n     if(len>0){\n        if(i>NB){\n           /* both column (i-1) and i are on tile T2 */\n           CORE_zlarfx2(PlasmaRight, len, *V1(i), *TAU1(i), A2(J1, i-1), LDX, A2(J1, i), LDX);\n           /* if nonzero element need to be created outside the band (if index < N) then create and eliminate it. */\n           if(J3>J2){\n              /* new nnz at TEMP=V2(i)  */\n              V          = *V1(i);\n              T          = *TAU1(i) * conj(V);\n              SUM        =  V * (*A2(J3, i));\n              *V2(i)     = -SUM * (*TAU1(i));\n              *A2(J3, i) = *A2(J3, i) - SUM * T;\n              /* generate Householder to annihilate a(j+kd,j-1) within the band */\n              DLARFG( &ITWO, A2(J2,i-1), V2(i), &IONE, TAU2(i) );\n           }\n        }else if(i==NB){\n           /* column (i-1) is on tile T1 while column i is on tile T2 */\n           CORE_zlarfx2(PlasmaRight, len, *V1(i), *TAU1(i), A1(J1, i-1), LDX, A2(J1, i), LDX);\n           /* if nonzero element need to be created outside the band (if index < N) then create and eliminate it. */\n           if(J3>J2){\n              /* new nnz at TEMP=V2(i)  */\n              V          = *V1(i);\n              T          = *TAU1(i) * conj(V);\n              SUM        =  V * (*A2(J3, i));\n              *V2(i)     = -SUM * (*TAU1(i));\n              *A2(J3, i) = *A2(J3, i) - SUM * T;\n              /* generate Householder to annihilate a(j+kd,j-1) within the band */\n              DLARFG( &ITWO, A1(J2, i-1), V2(i), &IONE, TAU2(i) );\n           }\n        }else{\n           /* both column (i-1) and i are on tile T1 */\n           CORE_zlarfx2(PlasmaRight, len, *V1(i), *TAU1(i), A1(J1, i-1), LDX, A1(J1, i), LDX);\n           /* if nonzero element need to be created outside the band (if index < N) then create and eliminate it. */\n           if(J3>J2){\n              /* new nnz at TEMP=V2(i)  */\n              V              = *V1(i);\n              T              = *TAU1(i) * conj(V);\n              SUM            =  V * (*A1(J3, i));\n              *V2(i)         = -SUM * (*TAU1(i));\n              *A1(J3, i)    = *A1(J3, i) - SUM * T;\n              /* generate Householder to annihilate a(j+kd,j-1) within the band */\n              DLARFG( &ITWO, A1(J2, i-1), V2(i), &IONE, TAU2(i) );\n           }\n        }\n     }\n  }\n              // if(id==1) return;\n\n  /* **********************************************************************************************\n   *   APPLY LEFT ON THE REMAINING ELEMENT OF KERNEL 1\n   * ***********************************************************************************************/\n  iglob = edglob+1;\n  for (i = ed; i >= st+1 ; i--){\n     iglob = iglob -1;\n     if((iglob+NB)< N){ /* mean that J3>J2 and so a nnz has been created and so a left is required. */\n        J1   = i;\n        J2   = ed;\n        t1ed = min(J2,KDM1);\n        t2st = max(J1, NB);\n        len1 = t1ed - J1 +1;\n        len2 = J2 - t2st +1;\n        pt   = i + KDM1; /* pt correspond to the J2 position of the corresponding right done above */\n        //printf(\"Type 2L st %d   ed %d    i %d    J1 %d   J2 %d  t1ed %d  t2st %d len1 %d len2 %d \\n\", st, ed, i, J1,J2,t1ed,t2st,len1,len2);\n\n        /* apply reflector from the left (horizontal row) and from the right for only the diagonal 2x2.*/\n        if(len2>0){\n           /* part of the left(if len2>0) and the corner are on tile T2 */\n           CORE_zlarfx2(PlasmaLeft, len2 , *V2(i), conj(*TAU2(i)), A2(pt, t2st), LDX, A2(pt+1, t2st), LDX);\n           if(len1>0) CORE_zlarfx2(PlasmaLeft, len1 , *V2(i), conj(*TAU2(i)), A1(pt, J1), LDX, A1(pt+1, J1), LDX);\n        }else if(len1>0){\n           /* the left and the corner are on tile T1, nothing on tile T2 */\n           CORE_zlarfx2(PlasmaLeft, len1 , *V2(i), conj(*TAU2(i)), A1(pt, J1), LDX, A1(pt+1, J1), LDX);\n        }\n     }\n  }\n}\n///////////////////////////////////////////////////////////\n\n\n///////////////////////////////////////////////////////////\n//                  TYPE 1-BAND Householder\n///////////////////////////////////////////////////////////\nstatic void CORE_zhbtlrx(int N, int NB, parsec_complex64_t *A1, int LDA1, parsec_complex64_t *A2, int LDA2, parsec_complex64_t *V1, parsec_complex64_t *TAU1, int st, int ed) {\n  int    J1, J2, KDM1, LDX;\n  int    len, len1, len2, t1ed, t2st;\n  int    i;\n\n  (void)N;\n  KDM1 = NB-1;\n  LDX = LDA2-1;\n  /* **********************************************************************************************\n   *   Annihiliate, then LEFT:\n   * ***********************************************************************************************/\n  for (i = ed; i >= st+1 ; i--){\n     J1   = st;\n     J2   = i-2;\n     t1ed = min(J2,KDM1);\n     t2st = max(J1, NB);\n     len1 = t1ed - J1 +1;\n     len2 = J2 - t2st +1;\n     //printf(\"Type 3L st %d   ed %d    i %d    J1 %d   J2 %d  t1ed %d  t2st %d len1 %d len2 %d \\n\", st, ed, i, J1,J2,t1ed,t2st,len1,len2);\n     /* apply reflector from the left (horizontal row) and from the right for only the diagonal 2x2.*/\n     if(len2>=0){\n        /* part of the left(if len2>0) and the corner are on tile T2 */\n        if(len2>0) CORE_zlarfx2(PlasmaLeft, len2 , *V1(i), conj(*TAU1(i)), A2((i-1), t2st), LDX, A2(i, t2st), LDX);\n        CORE_zlarfx2c(PlasmaLower, *V1(i), *TAU1(i), A2(i-1,i-1), A2(i,i-1), A2(i,i));\n        if(len1>0) CORE_zlarfx2(PlasmaLeft, len1 , *V1(i), conj(*TAU1(i)), A1(i-1, J1), LDX, A1(i, J1), LDX);\n     }else if(len2==-1){\n        /* the left is on tile T1, and only A(i,i) of the corner is on tile T2 */\n        CORE_zlarfx2c(PlasmaLower, *V1(i), *TAU1(i), A1(i-1,i-1), A1(i,i-1), A2(i,i));\n        if(len1>0) CORE_zlarfx2(PlasmaLeft, len1 , *V1(i), conj(*TAU1(i)), A1(i-1, J1), LDX, A1(i, J1), LDX);\n     }else{\n        /* the left and the corner are on tile T1, nothing on tile T2 */\n        CORE_zlarfx2c(PlasmaLower, *V1(i), *TAU1(i), A1(i-1,i-1), A1(i,i-1), A1(i,i)) ;\n        if(len1>0) CORE_zlarfx2(PlasmaLeft, len1 , *V1(i), conj(*TAU1(i)), A1((i-1), J1), LDX, A1(i, J1), LDX);\n     }\n  }\n  /* **********************************************************************************************\n   *   APPLY RIGHT ON THE REMAINING ELEMENT OF KERNEL 1\n   * ***********************************************************************************************/\n  for (i = ed; i >= st+1 ; i--){\n     J1    = i+1;\n     J2    = ed;\n     len   = J2-J1+1;\n     if(len>0){\n        if(i>NB)\n           /* both column (i-1) and i are on tile T2 */\n           CORE_zlarfx2(PlasmaRight, len, *V1(i), *TAU1(i), A2(J1, i-1), LDX, A2(J1, i), LDX);\n        else if(i==NB)\n           /* column (i-1) is on tile T1 while column i is on tile T2 */\n           CORE_zlarfx2(PlasmaRight, len, *V1(i), *TAU1(i), A1(J1, i-1), LDX, A2(J1, i), LDX);\n        else\n           /* both column (i-1) and i are on tile T1 */\n           CORE_zlarfx2(PlasmaRight, len, *V1(i), *TAU1(i), A1(J1, i-1), LDX, A1(J1, i), LDX);\n     }\n  }\n}\n///////////////////////////////////////////////////////////\n#undef A1\n#undef A2\n#undef V1\n#undef TAU1\n#undef V2\n#undef TAU2\n\n\n\n\n\n\n\n\n\n\n\n///////////////////////////////////////////////////////////\n//                  TYPE 1-BAND Householder\n///////////////////////////////////////////////////////////\n//// add -1 because of C\n#define A(m,n)   &(A[((m)-(n)) + LDA*((n)-1)])\n#define V(m)     &(V[m-1])\n#define TAU(m)   &(TAU[m-1])\nstatic void TRD_type1bHL(int N, int NB, parsec_complex64_t *A, int LDA, parsec_complex64_t *V, parsec_complex64_t *TAU, int st, int ed) {\n  int    J1, J2, len, LDX;\n  int    i, IONE, ITWO;\n  IONE=1;\n  ITWO=2;\n  (void)NB;\n\n  if(ed <= st){\n    printf(\"TRD_type 1bH: ERROR st and ed %d  %d \\n\",st,ed);\n    exit(-10);\n  }\n\n  LDX = LDA-1;\n  for (i = ed; i >= st+1 ; i--){\n     // generate Householder to annihilate a(i+k-1,i) within the band\n     *V(i)          = *A(i, (st-1));\n     *A(i, (st-1))  = 0.0;\n     DLARFG( &ITWO, A((i-1),(st-1)), V(i), &IONE, TAU(i) );\n\n     // apply reflector from the left (horizontal row) and from the right for only the diagonal 2x2.\n     J1  = st;\n     J2  = i;\n     len = J2-J1+1;\n     printf(\"voici J1 %d J2 %d len %d \\n\",J1,J2,len);\n     DLARFX_C('B', len , *V(i), *TAU(i), A((i-1),J1   ), LDX);\n  }\n\n  for (i = ed; i >= st+1 ; i--){\n     len = min(ed,N)-i;\n     if(len>0)DLARFX_C('R', len, *V(i), *TAU(i), A((i+1),(i-1)), LDX);\n  }\n\n\n}\n#undef A\n#undef V\n#undef TAU\n///////////////////////////////////////////////////////////\n\n\n\n///////////////////////////////////////////////////////////\n//                  TYPE 2-BAND Householder\n///////////////////////////////////////////////////////////\n//// add -1 because of C\n#define A(m,n)   &(A[((m)-(n)) + LDA*((n)-1)])\n#define V(m)     &(V[m-1])\n#define TAU(m)   &(TAU[m-1])\nstatic void TRD_type2bHL(int N, int NB, parsec_complex64_t *A, int LDA, parsec_complex64_t *V, parsec_complex64_t *TAU, int st, int ed) {\n  int    J1, J2, J3, KDM2, len, LDX;\n  int    i, IONE, ITWO;\n  IONE=1;\n  ITWO=2;\n\n\n  if(ed <= st){\n    printf(\"TRD_type 2H: ERROR st and ed %d  %d \\n\",st,ed);\n    exit(-10);;\n  }\n\n  LDX  = LDA -1;\n  KDM2 = NB-2;\n  for (i = ed; i >= st+1 ; i--){\n     // apply Householder from the right. and create newnnz outside the band if J3 < N\n     J1  = ed+1;\n     J2  = min((i+1+KDM2), N);\n     J3  = min((J2+1), N);\n     len = J2-J1+1;\n     DLARFX_C('R', len, *V(i), *TAU(i), A(J1,(i-1)), LDX);\n\n     // if nonzero element a(j+kd,j-1) has been created outside the band (if index < N) then eliminate it.\n     len    = J3-J2; // soit 1 soit 0\n     if(len>0){\n         //  new nnz at TEMP=V(J3)\n         *V(J3)     =            - *A(J3,(i)) * (*TAU(i)) * (*V(i));\n         *A(J3,(i)) = *A(J3,(i)) + *V(J3)  * (*V(i)); //ATTENTION THIS replacement IS VALID IN FLOAT CASE NOT IN COMPLEX\n         // generate Householder to annihilate a(j+kd,j-1) within the band\n         DLARFG( &ITWO, A(J2,(i-1)), V(J3), &IONE, TAU(J3) );\n     }\n  }\n               //if(id==1) return;\n\n\n  for (i = ed; i >= st+1 ; i--){\n     J2  = min((i+1+KDM2), N);\n     J3  = min((J2+1), N);\n     len    = J3-J2;\n     if(len>0){\n        len = min(ed,N)-i+1;\n        DLARFX_C('L', len , *V(J3), *TAU(J3), A(J2, i), LDX);\n     }\n  }\n\n}\n#undef A\n#undef V\n#undef TAU\n///////////////////////////////////////////////////////////\n\n\n\n///////////////////////////////////////////////////////////\n//                  TYPE 3-BAND Householder\n///////////////////////////////////////////////////////////\n//// add -1 because of C\n#define A(m,n)   &(A[((m)-(n)) + LDA*((n)-1)])\n#define V(m)     &(V[m-1])\n#define TAU(m)   &(TAU[m-1])\nstatic void TRD_type3bHL(int N, int NB, parsec_complex64_t *A, int LDA, parsec_complex64_t *V, parsec_complex64_t *TAU, int st, int ed) {\n  int    J1, J2, len, LDX;\n  int    i;\n  (void)NB;\n\n  if(ed <= st){\n    printf(\"TRD_type 3H: ERROR st and ed %d  %d \\n\",st,ed);\n    exit(-10);\n  }\n\n  LDX = LDA-1;\n  for (i = ed; i >= st+1 ; i--){\n     // apply rotation from the left. faire le DROT horizontal\n     J1  = st;\n     J2  = i;\n     len = J2-J1+1;\n     //len = NB+1;\n     DLARFX_C('B', len , *V(i), *TAU(i), A((i-1),J1   ), LDX);\n  }\n\n  for (i = ed; i >= st+1 ; i--){\n     len = min(ed,N)-i;\n     if(len>0)DLARFX_C('R', len, *V(i), *TAU(i), A((i+1),(i-1)), LDX);\n  }\n}\n#undef A\n#undef V\n#undef TAU\n///////////////////////////////////////////////////////////\n\n\n\n///////////////////////////////////////////////////////////\n//                  grouping sched wrapper call\n///////////////////////////////////////////////////////////\n#if 0\nint TRD_seqgralgtype(int N, int NB, parsec_complex64_t *A, int LDA, parsec_complex64_t *C, parsec_complex64_t *S, int i, int j, int m, int grsiz, int BAND) {\n  int    k,shift=3;\n  int    myid,colpt,stind,edind,blklastind,stepercol;\n  (void) BAND;\n\n\n\n  k   = shift/grsiz;\n  stepercol =  k*grsiz == shift ? k:k+1;\n\n\n   for (k = 1; k <=grsiz; k++){\n      myid = (i-j)*(stepercol*grsiz) +(m-1)*grsiz + k;\n      if(myid%2 ==0){\n           colpt      = (myid/2)*NB+1+j-1;\n           stind      = colpt-NB+1;\n           edind      = min(colpt,N);\n           blklastind = colpt;\n           if(stind>=edind){\n               printf(\"TRD_seqalg ERROR---------> st>=ed  %d  %d \\n\\n\",stind, edind);\n               return -10;\n           }\n      }else{\n           colpt      = ((myid+1)/2)*NB + 1 +j -1 ;\n           stind      = colpt-NB+1;\n           edind      = min(colpt,N);\n           if( (stind>=edind-1) && (edind==N) )\n               blklastind=N;\n           else\n               blklastind=0;\n           if(stind>=edind){\n               printf(\"TRD_seqalg ERROR---------> st>=ed  %d  %d \\n\\n\",stind, edind);\n               return -10;\n\n           }\n      }\n\n          if(myid == 1)\n              TRD_type1bHL(N, NB, A, LDA, C, S, stind, edind);\n          else if(myid%2 == 0)\n              TRD_type2bHL(N, NB, A, LDA, C, S, stind, edind);\n          else if(myid%2 == 1)\n              TRD_type3bHL(N, NB, A, LDA, C, S, stind, edind);\n          else{\n              printf(\"COUCOU ERROR myid/2 %d\\n\",myid);\n               return -10;\n          }\n\n      if(blklastind >= (N-1))  break;\n      //if(myid==2)return;\n  }   // END for k=1:grsiz\nreturn 0;\n}\n///////////////////////////////////////////////////////////\n#endif\n\n///////////////////////////////////////////////////////////////////////////////////////////////////////////////\n//                  REDUCTION BAND TO TRIDIAG\n///////////////////////////////////////////////////////////////////////////////////////////////////////////////\n#if 0\nstatic void band_to_trd_v8seq(int N, int NB, parsec_complex64_t *A, int LDA, int INgrsiz, int INthgrsiz) {\n  int myid, grsiz, shift, stt, st, ed, stind, edind, BAND;\n  int blklastind, colpt;\n  int stepercol,mylastid;\n  parsec_complex64_t *C, *S;\n  int i,j,m;\n  int thgrsiz, thgrnb, thgrid, thed;\n  int INFO;\n  INFO=-1;\n  BAND = 0;\n  C   = malloc(N*sizeof(parsec_complex64_t));\n  S   = malloc(N*sizeof(parsec_complex64_t));\n  memset(C,0,N*sizeof(parsec_complex64_t));\n  memset(S,0,N*sizeof(parsec_complex64_t));\n\n  grsiz   = INgrsiz;\n  thgrsiz = INthgrsiz;\n\n  shift   = 3;\n  if(grsiz==0)grsiz   = 6;\n  if(thgrsiz==0)thgrsiz = N;\n\n  if(LDA != (NB+1))\n  {\n      printf(\" ERROR LDA not equal NB+1 and this code is special for LDA=NB+1. LDA=%d NB+1=%d \\n\",LDA,NB+1);\n      return;\n  }\n  printf(\"  Version -8seq- grsiz %4d     thgrsiz %4d       N %5d      NB %5d    BAND %5d\\n\",grsiz,thgrsiz, N, NB, BAND);\n\n\n  i = shift/grsiz;\n  stepercol =  i*grsiz == shift ? i:i+1;\n\n  i       = (N-2)/thgrsiz;\n  thgrnb  = i*thgrsiz == (N-2) ? i:i+1;\n\n  for (thgrid = 1; thgrid<=thgrnb; thgrid++){\n     stt  = (thgrid-1)*thgrsiz+1;\n     thed = min( (stt + thgrsiz -1), (N-2));\n     for (i = stt; i <= N-2; i++){\n        ed=min(i,thed);\n        if(stt>ed)break;\n        for (m = 1; m <=stepercol; m++){\n            st=stt;\n            for (j = st; j <=ed; j++){\n                 myid     = (i-j)*(stepercol*grsiz) +(m-1)*grsiz + 1;\n                 mylastid = myid+grsiz-1;\n                 INFO = TRD_seqgralgtype(N, NB, A, LDA, C, S, i, j, m, grsiz, BAND);\n                 if(INFO!=0){\n                         printf(\"ERROR band_to_trd_v8seq INFO=%d\\n\",INFO);\n                         return;\n                 }\n                 if(mylastid%2 ==0){\n                     blklastind      = (mylastid/2)*NB+1+j-1;\n                 }else{\n                      colpt      = ((mylastid+1)/2)*NB + 1 +j -1 ;\n                      stind      = colpt-NB+1;\n                      edind      = min(colpt,N);\n                      if( (stind>=edind-1) && (edind==N) )\n                          blklastind=N;\n                      else\n                          blklastind=0;\n                 }\n                 if(blklastind >= (N-1))  stt=stt+1;\n           } // END for j=st:ed\n        } // END for m=1:stepercol\n     } // END for i=1:N-2\n  } // END for thgrid=1:thgrnb\n\n} // END FUNCTION\n///////////////////////////////////////////////////////////////////////////////////////////////////////////////\n#endif\n\n\n\n\n\n\n///////////////////////////////////////////////////////////////////////////////////////////////////////////////\nint blgchase_ztrdv1(int NT, int N, int NB, parsec_complex64_t *A, parsec_complex64_t *V, parsec_complex64_t *TAU, int sweep, int id, int blktile) {\n  int    /*edloc,*/ stloc, st, ed, KDM1, LDA;\n\n  (void)NT;\n  KDM1   = NB-1;\n  LDA    = NB+1;\n  /* generate the indiceslocal and global*/\n  stloc  = (sweep+1)%NB;\n  if(stloc==0) stloc=NB;\n  /*if(id==NT-1)\n     edloc = NB-1;\n  else\n     edloc = stloc + KDM1;\n  */\n\n  st = min(id*NB+stloc, N-1);\n  ed = min(st+KDM1, N-1);\n  /*\n   * i     = (N-1)%ed;\n   * edloc = i%NB+NB;\n   */\n\n  /* quick return in case of last tile */\n  if(st==ed)\n     return 0;\n\n  /* because the kernel have been writted for fortran, add 1 */\n   st = st +1;\n   ed = ed +1;\n  /* code for all tiles */\n  if(id==blktile){\n     TRD_type1bHL(N, NB, A, LDA, V, TAU, st, ed);\n     TRD_type2bHL(N, NB, A, LDA, V, TAU, st, ed);\n  }else{\n     TRD_type3bHL(N, NB, A, LDA, V, TAU, st, ed);\n     //if(id==6) return;\n     TRD_type2bHL(N, NB, A, LDA, V, TAU, st, ed);\n  }\n  return 0;\n}\n\n#if 0\n///////////////////////////////////////////////////////////////////////////////////////////////////////////////\n//\n///////////////////////////////////////////////////////////////////////////////////////////////////////////////\nstatic void band_to_trd_vmpi1(int N, int NB, parsec_complex64_t *A, int LDA) {\n  int NT;\n  parsec_complex64_t *V, *TAU;\n  int blktile, S, id, sweep;\n  V   = malloc(N*sizeof(parsec_complex64_t));\n  TAU = malloc(N*sizeof(parsec_complex64_t));\n  memset(V,0,N*sizeof(parsec_complex64_t));\n  memset(TAU,0,N*sizeof(parsec_complex64_t));\n\n\n  NT = N/NB;\n  if(NT*NB != N){\n      printf(\"ERROR NT*NB not equal N \\n\");\n      return;\n  }\n\n  //printf(\"voici NT, N NB %d %d %d\\n\",NT,N,NB);\n  for (blktile = 0; blktile<NT; blktile++){\n     for (S = 0; S<NB; S++){\n        sweep = blktile*NB + S ;\n        for (id = blktile; id<NT; id++){\n               blgchase_ztrdv1 (NT, N, NB, A, V, TAU, sweep , id, blktile);\n        }\n     }\n  }\n\n}\n///////////////////////////////////////////////////////////////////////////////////////////////////////////////\n#endif\n\n\n\n\n///////////////////////////////////////////////////////////////////////////////////////////////////////////////\nint blgchase_ztrdv2(int NT, int N, int NB, parsec_complex64_t *A1, parsec_complex64_t *A2, parsec_complex64_t *V1, parsec_complex64_t *TAU1, parsec_complex64_t *V2, parsec_complex64_t *TAU2, int sweep, int id, int blktile) {\n  int    edloc, stloc, st, ed, KDM1, LDA;\n\n  KDM1   = NB-1;\n  LDA    = NB+1;\n  /* generate the indiceslocal and global*/\n  stloc  = (sweep+1)%NB;\n  if(stloc==0) stloc=NB;\n  if(id==NT-1)\n     edloc = NB-1;\n  else\n     edloc = stloc + KDM1;\n\n  st = min(id*NB+stloc, N-1);\n  ed = min(st+KDM1, N-1);\n  /*\n   * i     = (N-1)%ed;\n   * edloc = i%NB+NB;\n   */\n\n  /* quick return in case of last tile */\n  if(st==ed)\n     return 0;\n\n\n  /* code for all tiles */\n  if(id==blktile){\n     CORE_zhbtelr(N, NB, A1, LDA, A2, LDA, V1, TAU1, stloc, edloc);\n     CORE_zhbtrce(N, NB, A1, LDA, A2, LDA, V1, TAU1, V2, TAU2, stloc, edloc, ed);\n  }else{\n     CORE_zhbtlrx(N, NB, A1, LDA, A2, LDA, V1, TAU1, stloc, edloc);\n     CORE_zhbtrce(N, NB, A1, LDA, A2, LDA, V1, TAU1, V2, TAU2, stloc, edloc, ed);\n  }\n  return 0;\n}\n\n#if 0\n///////////////////////////////////////////////////////////////////////////////////////////////////////////////\n//\n///////////////////////////////////////////////////////////////////////////////////////////////////////////////\nstatic void band_to_trd_vmpi2(int N, int NB, parsec_complex64_t *A, int LDA) {\n    int NT;\n    parsec_complex64_t *V, *TAU;\n    int blktile, S, id, sweep;\n    V   = malloc(N*sizeof(parsec_complex64_t));\n    TAU = malloc(N*sizeof(parsec_complex64_t));\n    memset(V,0,N*sizeof(parsec_complex64_t));\n    memset(TAU,0,N*sizeof(parsec_complex64_t));\n\n\n    NT = N/NB;\n    if(NT*NB != N){\n        printf(\"ERROR NT*NB not equal N \\n\");\n        return;\n    }\n\n    //printf(\"voici NT, N NB %d %d %d\\n\",NT,N,NB);\n    for (blktile = 0; blktile<NT; blktile++){\n        for (S = 0; S<NB; S++){\n            sweep = blktile*NB + S ;\n            for (id = blktile; id<NT; id++){\n                //printf(\"voici  blktile %d    S %d     id %d   sweep %d   \\n\",blktile, S, id, sweep);\n                blgchase_ztrdv2 (NT, N, NB,\n                                A+(id*NB*LDA), A+((id+1)*NB*LDA),\n                                V+(id*NB), TAU+(id*NB),\n                                V+((id+1)*NB), TAU+((id+1)*NB),\n                                sweep, id, blktile);\n            }\n            //if(sweep==0) return;\n        }\n    }\n\n}\n///////////////////////////////////////////////////////////////////////////////////////////////////////////////\n#endif\n", "meta": {"hexsha": "8d54f6307f2d8a35c90f00f37127aefb294040bc", "size": 34523, "ext": "c", "lang": "C", "max_stars_repo_path": "dplasma/cores/core_ztrdv.c", "max_stars_repo_name": "NLAFET/ABFT", "max_stars_repo_head_hexsha": "73af5b9ffe65cdb06b58c0cb34029ee6265d2bf8", "max_stars_repo_licenses": ["BSD-3-Clause-Open-MPI"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2019-08-13T10:13:00.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-13T10:13:00.000Z", "max_issues_repo_path": "dplasma/cores/core_ztrdv.c", "max_issues_repo_name": "NLAFET/ABFT", "max_issues_repo_head_hexsha": "73af5b9ffe65cdb06b58c0cb34029ee6265d2bf8", "max_issues_repo_licenses": ["BSD-3-Clause-Open-MPI"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "dplasma/cores/core_ztrdv.c", "max_forks_repo_name": "NLAFET/ABFT", "max_forks_repo_head_hexsha": "73af5b9ffe65cdb06b58c0cb34029ee6265d2bf8", "max_forks_repo_licenses": ["BSD-3-Clause-Open-MPI"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.5540679712, "max_line_length": 237, "alphanum_fraction": 0.4496422675, "num_tokens": 11798, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.46879062662624377, "lm_q2_score": 0.03732688600549891, "lm_q1q2_score": 0.017498494280524204}}
{"text": "/* -*- mode: C; c-basic-offset: 4 -*- */\n/* ex: set shiftwidth=4 tabstop=4 expandtab: */\n/*\n * Copyright (c) 2018-2019, Colorado School of Mines\n * All rights reserved.\n *\n * Author(s): Neil T. Dantam <ndantam@miens.edu>\n * Georgia Tech Humanoid Robotics Lab\n * Under Direction of Prof. Mike Stilman <mstilman@cc.gatech.edu>\n *\n *\n * This file is provided under the following \"BSD-style\" License:\n *\n *\n *   Redistribution and use in source and binary forms, with or\n *   without modification, are permitted provided that the following\n *   conditions are met:\n *\n *   * Redistributions of source code must retain the above copyright\n *     notice, this list of conditions and the following disclaimer.\n *\n *   * Redistributions in binary form must reproduce the above\n *     copyright notice, this list of conditions and the following\n *     disclaimer in the documentation and/or other materials provided\n *     with the distribution.\n *\n *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND\n *   CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES,\n *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\n *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR\n *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF\n *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED\n *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\n *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN\n *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n *   POSSIBILITY OF SUCH DAMAGE.\n *\n */\n\n#ifndef AMINO_MAT_H\n#define AMINO_MAT_H\n\n#include <cblas.h>\n\n/**\n * @file mat.h\n *\n * Block matrix descriptors and linear algebra operations.\n *\n */\n\ntypedef size_t aa_la_size;\n\n/**\n * Descriptor for a vector.\n */\nstruct aa_dvec {\n    aa_la_size len;   ///< Number of elements in vector\n    double *data; ///< Pointer to data\n    aa_la_size inc;   ///< Increment between successive vector elements\n};\n\n/**\n * Descriptor for a block matrix.\n */\nstruct aa_dmat {\n    aa_la_size rows;    ///< number of rows in matrix\n    aa_la_size cols;    ///< number of columns\n    double *data;   ///< Pointer to matrix data\n    aa_la_size ld;      ///< Leading dimension of matrix\n};\n\n\n#define AA_DVEC_REF(v,i) ((v)->data[(i) * (v)->inc])\n\n/**\n * Reference a matrix entry.\n *\n * @param M matrix\n * @param i row\n * @param j column\n */\n#define AA_DMAT_REF(M,i,j) (((M)->data)[(M)->ld*(j) + (i)])\n\n\n\ntypedef void\n(aa_la_err_fun)( const char *message );\n\nAA_API void\naa_la_err( const char *message );\n\nAA_API void\naa_la_set_err( aa_la_err_fun *fun );\n\n\n/**\n * BLAS arguments for a vector\n */\n#define AA_VEC_ARGS(X) (X->data), ((int)(X->inc))\n\n/**\n * BLAS arguments for a matrix\n */\n#define AA_MAT_ARGS(X) (X->data), ((int)(X->ld))\n\n/* Construction */\n\n/**\n * Fill in a vector descriptor.\n *\n * @param len  Number of elements in vector\n * @param data Pointer to vector data\n * @param inc  Increment between sucessive elements\n */\nstatic inline struct aa_dvec\nAA_DVEC_INIT( size_t len, double *data, size_t inc )\n{\n    struct aa_dvec vec;\n    vec.len = len;\n    vec.data = data;\n    vec.inc = inc;\n    return vec;\n}\n\n/**\n * Fill in a vector descriptor.\n *\n * @param vec  Pointer to descriptor\n * @param len  Number of elements in vector\n * @param data Pointer to vector data\n * @param inc  Increment between sucessive elements\n */\nAA_API void\naa_dvec_view( struct aa_dvec *vec, size_t len, double *data, size_t inc );\n\n/**\n * Fill in a matrix descriptor.\n *\n * @param mat   Pointer to descriptor\n * @param rows  Number of rows in matrix\n * @param cols  Number of colums in matrix\n * @param data  Pointer to vector data\n * @param ld    Leading dimension of matrix\n */\nAA_API void\naa_dmat_view( struct aa_dmat *mat, size_t rows, size_t cols, double *data, size_t ld );\n\n/**\n * View a block of a matrix.\n */\nAA_API void\naa_dmat_view_block( struct aa_dmat *dst,\n                    const struct aa_dmat *src,\n                    size_t row_start, size_t col_start,\n                    size_t rows, size_t cols );\n\n/**\n * View a slice of a vector.\n */\nAA_API void\naa_dvec_slice( const struct aa_dvec *src,\n               size_t start,\n               size_t stop,\n               size_t step,\n               struct aa_dvec *dst );\n\n\n/**\n * View a block of a matrix.\n */\nAA_API void\naa_dmat_block( const struct aa_dmat *src,\n               size_t row_start, size_t col_start,\n               size_t row_end, size_t col_end,\n               struct aa_dmat *dst );\n\n/**\n * View a row of a matrix as a vector.\n */\nAA_API void\naa_dmat_row_vec( const struct aa_dmat *src, size_t row, struct aa_dvec *dst );\n\n/**\n * View a column of a matrix as a vector.\n */\nAA_API void\naa_dmat_col_vec( const struct aa_dmat *src, size_t col, struct aa_dvec *dst );\n\n/**\n * View the diagonal of a matrix as a vector.\n */\nAA_API void\naa_dmat_diag_vec( const struct aa_dmat *src, struct aa_dvec *dst );\n\n\n/**\n * Fill in a matrix descriptor.\n *\n * @param rows  Number of rows in matrix\n * @param cols  Number of colums in matrix\n * @param data  Pointer to vector data\n * @param ld    Leading dimension of matrix\n */\nstatic inline struct aa_dmat\nAA_DMAT_INIT( size_t rows, size_t cols, double *data, size_t ld )\n{\n    struct aa_dmat mat;\n    mat.rows = rows;\n    mat.cols = cols;\n    mat.data = data;\n    mat.ld = ld;\n    return mat;\n}\n\n\n#define AA_MAT_DIAG(VEC,MAT)                                    \\\n    aa_dvec_view((VEC), (MAT)->cols, (MAT)->data, 1+(MAT)->ld);\n\n/**\n * Region-allocate a vector.\n *\n * When finished, pop the descriptor.\n */\nAA_API struct aa_dvec *\naa_dvec_alloc( struct aa_mem_region *reg, size_t len );\n\n\n/**\n * Duplicate vector out of region\n *\n * When finished, pop the descriptor.\n */\nAA_API struct aa_dvec *\naa_dvec_dup( struct aa_mem_region *reg, const struct aa_dvec *src);\n\n/**\n * Duplicate matrix out of region\n *\n * When finished, pop the descriptor.\n */\nAA_API struct aa_dmat *\naa_dmat_dup( struct aa_mem_region *reg, const struct aa_dmat *src);\n\n/**\n * Region-allocate a matrix.\n *\n * When finished, pop the descriptor.\n */\nAA_API struct aa_dmat *\naa_dmat_alloc( struct aa_mem_region *reg, size_t rows, size_t cols );\n\n/**\n * Heap-allocate a vector.\n *\n * The descriptor and data are contained in a single malloc()'ed block.\n * When finished, call free() on the descriptor.\n */\nAA_API struct aa_dvec *\naa_dvec_malloc( size_t len );\n\n/**\n * Heap-allocate a matrix.\n *\n * The descriptor and data are contained in a single malloc()'ed block.\n * When finished, call free() on the descriptor.\n */\nAA_API struct aa_dmat *\naa_dmat_malloc( size_t rows, size_t cols );\n\n/**\n * Zero a vector.\n */\nAA_API void\naa_dvec_zero( struct aa_dvec *vec );\n\n/**\n * Fill a vector.\n */\nAA_API void\naa_dvec_set( struct aa_dvec *vec, double alpha );\n\n/**\n * Fill a matrix diagonal and off-diagonal elements.\n *\n * @param[in] A        The matrix to fill\n * @param[in] alpha    off-diagonal entries of A\n * @param[in] beta     diagonal entries of A\n */\nAA_API void\naa_dmat_set( struct aa_dmat *A, double alpha, double beta );\n\n/**\n * Zero a matrix.\n */\nAA_API void\naa_dmat_zero( struct aa_dmat *mat );\n\n/* Level 1 BLAS */\n\n/**\n * Swap x and y\n *\n * \\f[ \\mathbf{x} \\leftrightarrow \\mathbf{y} \\f]\n */\nAA_API void\naa_dvec_swap( struct aa_dvec *x, struct aa_dvec *y );\n\n/**\n * Scale x by alpha.\n *\n * \\f[ \\mathbf{x} \\leftarrow \\alpha \\mathbf{x} \\f]\n */\nAA_API void\naa_dvec_scal( double alpha, struct aa_dvec *x );\n\n/**\n * Increment x by alpha.\n *\n * \\f[ \\mathbf{x} \\leftarrow \\alpha + \\mathbf{x} \\f]\n */\nAA_API void\naa_dvec_inc( double alpha, struct aa_dvec *x );\n\n/**\n * Copy x to y.\n *\n * \\f[ \\mathbf{y} \\leftarrow \\mathbf{x} \\f]\n */\nAA_API void\naa_dvec_copy( const struct aa_dvec *x, struct aa_dvec *y );\n\n\n/**\n * Alpha x plus y.\n *\n * \\f[ \\mathbf{y} \\leftarrow \\alpha \\mathbf{x} + \\mathbf{y} \\f]\n */\nAA_API void\naa_dvec_axpy( double a, const struct aa_dvec *x, struct aa_dvec *y );\n\n/**\n * Dot product\n *\n * \\f[ \\mathbf{x}^T \\mathbf{y} \\f]\n */\nAA_API double\naa_dvec_dot( const struct aa_dvec *x, struct aa_dvec *y );\n\n/**\n * Euclidean Norm\n *\n * \\f[ \\left\\Vert \\mathbf{x} \\right\\Vert_2  \\f]\n */\nAA_API double\naa_dvec_nrm2( const struct aa_dvec *x );\n\n/* Level 2 BLAS */\n\n/**\n * General Matrix-Vector multiply\n *\n * \\f[ \\mathbf{y} \\leftarrow \\alpha \\mathbf{A}^{\\rm op} \\mathbf{x} + \\beta \\mathbf{y}  \\f]\n */\nAA_API void\naa_dmat_gemv( CBLAS_TRANSPOSE trans,\n              double alpha, const struct aa_dmat *A,\n              const struct aa_dvec *x,\n              double beta, struct aa_dvec *y );\n\n\n\n/* Level 3 BLAS */\n\n/**\n * General Matrix-Matrix multiply\n *\n * \\f[ \\mathbf{y} \\leftarrow \\alpha \\mathbf{A}^{\\rm opA} \\mathbf{B}^\\rm{opB} + \\beta \\mathbf{C}  \\f]\n */\nAA_API void\naa_dmat_gemm( CBLAS_TRANSPOSE transA, CBLAS_TRANSPOSE transB,\n              double alpha, const struct aa_dmat *A,\n              const struct aa_dmat *B,\n              double beta, struct aa_dmat *C );\n\n\n\n\n/* LAPACK */\n\n/**\n * Copies all or part of a two-dimensional matrix A to another\n * matrix B.\n *\n *  @param[in] UPLO\n *          Specifies the part of the matrix A to be copied to B.\n *          - = 'U':      Upper triangular part\n *          - = 'L':      Lower triangular part\n *          - Otherwise:  All of the matrix A\n *\n *  @param[in] A\n *          dimension (LDA,N)\n *          The m by n matrix A.  If UPLO = 'U', only the upper triangle\n *          or trapezoid is accessed; if UPLO = 'L', only the lower\n *          triangle or trapezoid is accessed.\n *\n *  @param[out] B\n *          dimension (LDB,N)\n *          On exit, B = A in the locations specified by UPLO.\n *\n */\nAA_API void\naa_dmat_lacpy( const char uplo[1],\n               const struct aa_dmat *A,\n               struct aa_dmat *B );\n\n\n\n/* Matrix/Vector Functions */\n\n/**\n * sum-square-differences of two vectors\n */\nAA_API double\naa_dvec_ssd( const struct aa_dvec *x, const struct aa_dvec *y);\n\n\n/**\n * Y += alpha * X\n */\nAA_API void\naa_dmat_axpy( double alpha, const struct aa_dmat *X, struct aa_dmat *Y);\n\n/**\n * sum-square-differences of two matrices\n */\nAA_API double\naa_dmat_ssd( const struct aa_dmat *x, const struct aa_dmat *y);\n\n/**\n * Scale the matrix A by alpha\n */\nAA_API void\naa_dmat_scal( struct aa_dmat *A, double alpha );\n\n/**\n * Increment the matrix A by alpha\n */\nAA_API void\naa_dmat_inc( struct aa_dmat *A, double alpha );\n\n/**\n * Euclidean Norm\n */\nAA_API double\naa_dmat_nrm2( const struct aa_dmat *x );\n\n\n/**\n * Matrix transpose.\n */\nAA_API void\naa_dmat_trans( const struct aa_dmat *A, struct aa_dmat *At);\n\n\n/**\n * Matrix inverse, in-place.\n */\nAA_API int\naa_dmat_inv( struct aa_dmat *A);\n\n\n/**\n * Pseudo-inverse.\n *\n * Singular values less than tol are ignored.  If tol < 0, then a sane\n * default is used.\n */\nAA_API int\naa_dmat_pinv( const struct aa_dmat *A, double tol, struct aa_dmat *As);\n\n/**\n * Damped pseudo-inverse.\n */\nAA_API int\naa_dmat_dpinv( const struct aa_dmat *A, double k, struct aa_dmat *As);\n\n/**\n * Dead-zone damped pseudo-inverse.\n */\nAA_API int\naa_dmat_dzdpinv(  const struct aa_dmat *A, double s_min, struct aa_dmat *As);\n\n/**\n * Copy a matrix\n */\nAA_API void\naa_dmat_copy(  const struct aa_dmat *A, struct aa_dmat *B);\n\n\n#endif /* AMINO_MAT_H */\n", "meta": {"hexsha": "0008d427c393320d16ac649e2ffa32af8be611c7", "size": 11370, "ext": "h", "lang": "C", "max_stars_repo_path": "include/amino/mat.h", "max_stars_repo_name": "dyalab/amino", "max_stars_repo_head_hexsha": "e3063ceeeed7d1a3d55fc0d3071c9aacb4466b22", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 32.0, "max_stars_repo_stars_event_min_datetime": "2015-06-02T20:06:09.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-14T16:49:22.000Z", "max_issues_repo_path": "include/amino/mat.h", "max_issues_repo_name": "dyalab/amino", "max_issues_repo_head_hexsha": "e3063ceeeed7d1a3d55fc0d3071c9aacb4466b22", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 28.0, "max_issues_repo_issues_event_min_datetime": "2016-05-18T20:54:44.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-22T23:43:23.000Z", "max_forks_repo_path": "include/amino/mat.h", "max_forks_repo_name": "dyalab/amino", "max_forks_repo_head_hexsha": "e3063ceeeed7d1a3d55fc0d3071c9aacb4466b22", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 20.0, "max_forks_repo_forks_event_min_datetime": "2016-01-05T18:55:14.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-22T01:32:20.000Z", "avg_line_length": 22.5148514851, "max_line_length": 100, "alphanum_fraction": 0.6545294635, "num_tokens": 3161, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4493926344647596, "lm_q2_score": 0.037892429753269334, "lm_q1q2_score": 0.017028578833092545}}
{"text": "/**\n * This file is part of yasimSBML (http://www.labri.fr/perso/ghozlane/metaboflux/about/yasimSBML.php)\n * Copyright (C) 2010 Amine Ghozlane from LaBRI and University of Bordeaux 1\n *\n * yasimSBML is free software: you can redistribute it and/or modify\n * it under the terms of the Lesser GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * yasimSBML is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the Lesser GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\n/**\n * \\file simulation.c\n * \\brief Simulate a petri net\n * \\author {Amine Ghozlane}\n * \\version 1.0\n * \\date 27 octobre 2009\n */\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <assert.h>\n#include <time.h>\n#include <unistd.h>\n#include <gsl/gsl_rng.h>\n#include <sbml/SBMLTypes.h>\n#include \"especes.h\"\n#include \"simulation.h\"\n\n/*TODO Verification des BoundaryConditions,Local parameter values, Global parameter values, Reaction, des equations */\n\n/**\n * \\fn void SBML_initEspeceAmounts(Model_t *mod, pEspeces molecules, int nbEspeces)\n * \\author Amine Ghozlane\n * \\brief  Alloc memory and initialize the struct Especes\n * \\param  mod Model of the SBML file\n * \\param  molecules Struct Especes\n * \\param  nbEspeces Number of molecules\n */\nvoid SBML_initEspeceAmounts(Model_t *mod, pEspeces molecules, int nbEspeces) {\n  int i;\n  Species_t *esp;\n\n  /* Initialisation des quantites des especes*/\n  for (i = 0; i < nbEspeces; i++) {\n      esp = Model_getSpecies(mod, i);\n      /*printf(\"espece: %s, compartiment : %s\\n\",Species_getId(esp),Species_getCompartment(esp));*/\n      Especes_save(molecules, i, Species_getInitialAmount(esp),\n          Species_getId(esp), Species_getCompartment(esp));\n  }\n}\n\n/**\n * \\fn void SBML_setReactions(Model_t *mod, pEspeces molecules, pScore result, double *reactions_ratio, int nbReactions, int nbEspeces)\n * \\author Amine Ghozlane\n * \\brief  Alloc memory and initialize the struct Especes\n * \\param  mod Model of the SBML file\n * \\param  molecules Struct Especes\n * \\param  result Struct Score\n * \\param  reactions_ratio List of computed reaction ratio\n * \\param  nbReactions Number of reaction\n * \\param  nbEspeces Number of molecules\n */\nvoid SBML_setReactions(Model_t *mod, pEspeces molecules, int nbReactions, int nbEspeces) {\n  int ref = 0, i, j;\n  SpeciesReference_t *reactif;\n  Species_t *especeId;\n  Reaction_t *react;\n  const char *kf;\n  const ASTNode_t *km;\n  KineticLaw_t *kl;\n\n  /*fprintf(stdout, \"Debut reaction\\n\");*/\n  /* Recherche les reactions ou apparaissent chaque espece */\n  for (i = 0; i < nbReactions; i++) {\n      react = Model_getReaction(mod, i);\n      for (j = 0; j < (int)Reaction_getNumReactants(react); j++) {\n          reactif = Reaction_getReactant(react, j);\n          especeId = Model_getSpeciesById(mod, SpeciesReference_getSpecies(\n              reactif));\n          ref = Especes_find(molecules, Species_getId(especeId), nbEspeces);\n          /*printf(\"Reactif :Quantite de ref %d :%f \\n\", ref,Especes_getQuantite(molecules, ref));*/\n\n          kl = Reaction_getKineticLaw(react);\n\n          if (KineticLaw_isSetFormula(kl)) {\n              kf = KineticLaw_getFormula(kl);\n              /*printf(\"c du kf %s\\n\", kf);*/\n              Especes_allocReactions(molecules, ref, react,\n                  SBML_evalExpression(kf));\n          } else {\n              km = KineticLaw_getMath(kl);\n              printf(\"C du kM... cas encore ignore\\n\");\n              exit(1);\n          }\n      }\n  }\n  /*fprintf(stdout, \"Fin reaction\\n\");*/\n}\n\n/**\n * \\fn double SBML_evalExpression(const char *formule)\n * \\author Amine Ghozlane\n * \\brief  Get the reaction ratio define in the sbml\n * \\param  formule Formule SBML\n * \\return Return double value of the constraint\n */\ndouble SBML_evalExpression(const char *formule) {\n  return atof(formule);\n}\n\n/**\n * \\fn int SBML_checkQuantite(Model_t *mod, Reaction_t *react, int nbEspeces, pEspeces molecules)\n * \\author Amine Ghozlane\n * \\brief  Determine the number of reaction for one molecule\n * \\param  mod Model of the SBML file\n * \\param  react Reaction id\n * \\param  nbEspeces Number of molecules\n * \\param  molecules Struct Especes\n * \\return Number of reaction for one molecule\n */\nint SBML_checkQuantite(Model_t *mod, Reaction_t *react, int nbEspeces, pEspeces molecules)\n{\n  double quantite = 0.0, minStep = 0.0, temp = 0.0;\n  int ref = 0, i;\n  SpeciesReference_t *reactif;\n  Species_t *especeId;\n\n  reactif = Reaction_getReactant(react, 0);\n  especeId = Model_getSpeciesById(mod, SpeciesReference_getSpecies(reactif));\n  ref = Especes_find(molecules, Species_getId(especeId), nbEspeces);\n\n  if ((quantite = Especes_getQuantite(molecules, ref)) <= 0.0) {\n      /*printf(\"je fais le return\\n\");*/\n      return END;\n  }\n  /*printf(\"quantite : %d\\n\",quantite);*/\n  minStep = quantite / SpeciesReference_getStoichiometry(reactif);\n  /*printf(\"quantite : %d, minStep init : %d\\n\",quantite,minStep);*/\n  /* Cas ou le nombre de pas est egal a 0 */\n  if(minStep==0.0) return END;\n\n  for (i = 1; i < (int)Reaction_getNumReactants(react); i++) {\n      reactif = Reaction_getReactant(react, i);\n      especeId = Model_getSpeciesById(mod, SpeciesReference_getSpecies(reactif));\n      ref = Especes_find(molecules, Species_getId(especeId), nbEspeces);\n      quantite= Especes_getQuantite(molecules, ref);\n      /* La quantite est egale a 0 */\n      if(quantite<=0.0) return END;\n      temp = floor(Especes_getQuantite(molecules, ref)/SpeciesReference_getStoichiometry(reactif));\n      /* Cas ou le nombre de pas est egal a 0 */\n      if(temp==0.0) return END;\n      /* Si le nouveau nombre est inferieur au precedent, on change la valeur de minStep */\n      if (minStep > temp) minStep = temp;\n  }\n\n  return (int)minStep;\n}\n\n/**\n * \\fn Reaction_t * SBML_reactChoice(pEspeces molecules, const gsl_rng * r, int ref)\n * \\author Amine Ghozlane\n * \\brief  Determine randomly the reaction to achieve for several nodes reactions\n * \\param  molecules Struct Especes\n * \\param  r Random number generator\n * \\param  ref Number reference of one molecule\n * \\return Id of the selected reaction\n */\nReaction_t * SBML_reactChoice(pEspeces molecules, const gsl_rng * r, int ref) {\n\n  pReaction temp = NULL;\n  pReaction Q = molecules[ref].system;\n  double value = gsl_rng_uniform(r) * 100.0;\n  double choice = 0.0;\n\n  /*printf(\"Choix de la reaction :\\n\");\n\t printf(\"value : %f\\n\", value);*/\n\n  /* Choix de la reaction a realiser */\n  if (value < Q->ratio)\n    temp = Q;\n  else {\n      do {\n          /*printf(\"reaction %s : ratio %f\\n\", Reaction_getId(Q->link), Q->ratio);*/\n          choice += Q->ratio;\n          /*printf(\"choice : %f\\n\", choice);*/\n          Q = Q->suivant;\n          temp = Q;\n          /*printf(\"ratio suivant : %f\\n\",Q->ratio );*/\n      } while (Q->suivant != NULL && value <= (choice + Q->suivant->ratio)\n          && value > choice);\n  }\n  if (temp == NULL) {\n      fprintf(stderr, \"on a un probleme de ratio\\n\");\n      exit(EXIT_FAILURE);\n  }\n\n  /*printf(\"Resultat :\\n\");\n\t printf(\"value : %f, choice :%f\\n\", value, (choice + Q->ratio));\n\t printf(\"reaction %s : ratio %f\\n\", Reaction_getId(temp->link), temp->ratio);*/\n  /*if (Q->suivant == NULL)\n\t printf(\"choice :%f\", choice);*/\n  /*printf(\"c bon\\n\");*/\n\n  return (temp->link);\n\n}\n\n/**\n * \\fn void SBML_reaction(Model_t *mod, pEspeces molecules, Reaction_t *react, int nbEspeces)\n * \\author Amine Ghozlane\n * \\brief  Simulation of a discrete transision\n * \\param  mod Model of the SBML file\n * \\param  molecules Struct Especes\n * \\param  react Reaction id\n * \\param  nbEspeces Number of molecules\n */\nvoid SBML_reaction(Model_t *mod, pEspeces molecules, Reaction_t *react, int nbEspeces)\n{\n  SpeciesReference_t *reactif;\n  Species_t *especeId;\n  int i, ref = 0;\n\n  /*boucle pour retirer des reactifs*/\n  for (i = 0; i < (int)Reaction_getNumReactants(react); i++) {\n      reactif = Reaction_getReactant(react, i);\n      especeId = Model_getSpeciesById(mod, SpeciesReference_getSpecies(reactif));\n      ref = Especes_find(molecules, Species_getId(especeId), nbEspeces);\n\n      /*printf(\"Reactif : %s\",Species_getId(especeId) );\n\t\t printf(\"ref : %d\\n\",ref);\n\t\t printf(\"Reactif :Quantite de ref %d :%d \\n\",ref,Espece_getQuantite(molecules,ref));*/\n      Especes_setQuantite(molecules, ref,(Especes_getQuantite(molecules, ref)- SpeciesReference_getStoichiometry(reactif)));\n      /*printf(\"Apres Reactif: Quantite de ref %d :%d \\n\",ref,Espece_getQuantite(molecules,ref));*/\n  }\n\n  /*boucle pour ajouter des produits */\n  for (i = 0; i < (int)Reaction_getNumProducts(react); i++) {\n      reactif = Reaction_getProduct(react, i);\n      especeId = Model_getSpeciesById(mod, SpeciesReference_getSpecies(reactif));\n      /*printf(\"Produit : %s\",Species_getId(especeId) );*/\n      ref = Especes_find(molecules, Species_getId(especeId), /*Species_getCompartment(especeId),*/ nbEspeces);\n      /*printf(\"Produit : ref : %d\\n\",ref);\n\t\t printf(\"Produit : Quantite de ref %d :%d \\n\",ref,Espece_getQuantite(molecules,ref));*/\n\n      Especes_setQuantite(molecules, ref,(Especes_getQuantite(molecules, ref)+ SpeciesReference_getStoichiometry(reactif)));\n      /*printf(\"Apres Produit : Quantite de ref %d :%d \\n\",ref,Espece_getQuantite(molecules,ref));*/\n  }\n}\n\n/**\n * \\fn void SBML_allocTest(pTestReaction T, int nbReactions)\n * \\author Amine Ghozlane\n * \\brief  Alloc memory and initialize the struct pTestReaction\n * \\param  T Empty struct TestReaction\n * \\param  nbReactions Number of reactions\n */\nvoid SBML_allocTest(pTestReaction T, int nbReactions)\n{\n  int i;\n\n  /* Initialisation des tableaux des reactions */\n  T->tabReactions= (Reaction_t **) malloc(nbReactions * sizeof(Reaction_t *));\n  T->minStepTab = (int*) malloc(nbReactions * sizeof(int));\n\n  if (T->tabReactions == NULL)\n    exit(EXIT_FAILURE);\n  if (T->minStepTab == NULL)\n    exit(EXIT_FAILURE);\n\n  for (i = 0; i < nbReactions; i++) {\n      T->tabReactions[i] = NULL;\n      T->minStepTab[i] = 0;\n  }\n}\n\n/**\n * \\fn void SBML_freeTest(pTestReaction T)\n * \\author Amine Ghozlane\n * \\brief  Free memory of the struct TestReaction\n * \\param T Struct TestReaction gives data on reaction\n */\nvoid SBML_freeTest(pTestReaction T)\n{\n  if (T->tabReactions != NULL)\n    free(T->tabReactions);\n  if (T->minStepTab != NULL)\n    free(T->minStepTab);\n}\n\n/**\n * \\fn int SBML_EstimationReaction(Model_t *mod, pTestReaction T, pEspeces molecules, int ref, int nbEspeces)\n * \\author Amine Ghozlane\n * \\brief  Alloc memory and initialize the struct Especes\n * \\param  mod Model of the SBML file\n * \\param  T Struct TestReaction gives data on reaction\n * \\param  molecules Struct Especes\n * \\param  ref Number reference of one molecule\n * \\param  nbEspeces Number of molecules\n * \\return Estimated number of feasible step by reaction\n */\nint SBML_EstimationReaction(Model_t *mod, pTestReaction T, pEspeces molecules, int ref, int nbEspeces)\n{\n  pReaction Q = molecules[ref].system;\n  int i = 0, min = 0, curr = 0;\n\n  /* Compte le nombre de reactions rattachees a une espece */\n  while (Q != NULL) {\n      T->tabReactions[i] = Q->link;\n      T->minStepTab[i] = SBML_checkQuantite(mod, Q->link, nbEspeces,\n          molecules);\n      if (i == 0)\n        min = T->minStepTab[i];\n      curr = T->minStepTab[i];\n      if (T->minStepTab[i] <= 0)\n        return END;\n      else if (curr < min)\n        min = curr;\n      Q = Q->suivant;\n      i++;\n  }\n\n  return min;\n}\n\n/**\n * \\fn int SBML_simulate(Model_t *mod, pEspeces molecules, const gsl_rng * r, pTestReaction T, char **banned, int nbBanned, int nbEspeces, int ref)\n * \\author Amine Ghozlane\n * \\brief  Simulate one step of petri net\n * \\param  mod Model of the SBML file\n * \\param  molecules Struct Especes\n * \\param  r Random number generator\n * \\param  T Struct TestReaction gives data on reaction\n * \\param  banned List of banned compound\n * \\param  nbBanned Number of banned compound\n * \\param  nbEspeces Number of molecules\n * \\param  ref Number reference of one molecule\n * \\return Condition of stop/pursue\n */\nint SBML_simulate(Model_t *mod, pEspeces molecules, const gsl_rng * r, pTestReaction T, int nbEspeces, int ref)\n{\n  Reaction_t *react = NULL;\n  int minStep = 0, valid = 0/*, i=0*/;\n  /*int nbReactions = Especes_getNbreactions(molecules, ref);*/\n  int nbReactions = molecules[ref].nbReactions;\n\n  /*printf(\"nbreactions : %d, ref : %d\\n\", nbReactions, ref);\n\t printf(\"molecules : %s\\n\", molecules[ref].id);*/\n\n  /* Probleme ATP, ADP, NADH, NAD+ */\n  if (!strcmp(molecules[ref].id, \"ADP\") || !strcmp(molecules[ref].id, \"ATP\")\n      || !strcmp(molecules[ref].id, \"NADH\") || !strcmp(molecules[ref].id,\n          \"NADplus\") || !strcmp(molecules[ref].id, \"NADPH\") || !strcmp(\n              molecules[ref].id, \"NADPplus\")|| !strcmp(molecules[ref].id, \"NADplus_g\")||\n              !strcmp(molecules[ref].id, \"NADH_g\")|| !strcmp(molecules[ref].id, \"ADP_g\")||\n              !strcmp(molecules[ref].id, \"ATP_g\")|| !strcmp(molecules[ref].id, \"ADP_c\")|| !strcmp(molecules[ref].id, \"ATP_c\")) {\n      /*printf(\"END : molecules : %s\\n\", molecules[ref].id);*/\n      return END;\n  }\n\n  /* Elimine les calculs sur ADP... */\n  /*for(j=0;j<BANNI;j++){\n\t if(!strcmp(tab[i],molecules[ref].id)){\n\t printf(\"test : tab: %s molecules : %s\\n\",tab[i],molecules[ref].id );\n\t return END;\n\t }\n\t }*/\n\n  /* Variation selon le cas. */\n  switch (nbReactions) {\n  /* Cas ou aucune reaction n'est possible */\n  case 0:\n    /*printf(\"Cas N°1\\n\");*/\n    return END;\n    break;\n    /* Cas ou une seule reaction est possible */\n  case 1:\n    /*printf(\"Cas N°2\\n\");*/\n    react = molecules[ref].system->link;\n    if ((minStep = SBML_checkQuantite(mod, react, nbEspeces, molecules))<= END)\n      return END;\n    /*printf(\"minstep = %d\\n\", minStep);*/\n\n    while (minStep > 0) {\n        SBML_reaction(mod, molecules, react, nbEspeces);\n        minStep--;\n    }\n    break;\n    /* Cas ou  plusieurs reactions sont possibles*/\n  default:\n    /*printf(\"Cas N°3\\n\");*/\n    /* Allocation de la memoire au tableau des reactions */\n    SBML_allocTest(T, nbReactions);\n    valid = SBML_EstimationReaction(mod, T, molecules, ref, nbEspeces);\n    if (valid <= END) {\n        /*printf(\"on ne fait rien\\n\");*/\n        return END;\n    }\n    while (Especes_getQuantite(molecules, ref) > 0.0 && valid > END) {\n        react = SBML_reactChoice(molecules, r, ref);\n        /*printf(\"molecule : %s, reaction %s\\n\", molecules[ref].id, Reaction_getId(react));*/\n        /*printf(\"reaction : %s\\n\", Reaction_getId(react));*/\n        /*printf(\"valid : %d, i : %d\\n\", valid, i);*/\n        SBML_reaction(mod, molecules, react, nbEspeces);\n        /*if(i>=valid) valid=SBML_EstimationReaction(mod, T, molecules, ref, nbEspeces);*/\n        /*i++;*/\n        valid--;\n    }\n    /*printf(\"Fin de simulation\\n\");*/\n\n    /* Liberation de la memoire allouee au tableau des reactions */\n    SBML_freeTest(T);\n    break;\n  }\n  /*printf(\"On quitte la simulation\\n\");*/\n  return PURSUE;\n}\n\n/**\n * \\fn void SBML_compute_simulation(pScore result, Model_t *mod, double *reactions_ratio, gsl_rng * r, char **banned, int nbBanned)\n * \\author Amine Ghozlane\n * \\brief  Simulation of metabolic network\n * \\param  result Struct Score\n * \\param  mod Model of the SBML file\n * \\param  reactions_ratio List of computed reaction ratio\n * \\param  r Random number generator\n * \\param  banned List of banned compound\n * \\param  nbBanned Number of banned compound\n */\nvoid compute_simulation(Model_t *mod)\n{\n  int i, nbReactions = 0, nbEspeces = 0, temp = 1, tempo = 0;\n  pEspeces molecules;\n  const gsl_rng_type *T;\n  gsl_rng * r;\n  pTestReaction TR = NULL;\n\n  /* Verifications */\n  /*TODO numGlobalParameters=Model_getNumParameters(mod);\n\tcheckBoundaryConditions(mod);\n\tif(numGlobalParameters>0){\n\t    globalParVec=gsl_vector_alloc(numGlobalParameters);\n\t    setGlobalParVec();\n\t  }*/\n  /* Allocation memoire et initialisation des generateurs de nombre aleatoire */\n  gsl_rng_env_setup();\n  if (!getenv(\"GSL_RNG_SEED\"))\n    gsl_rng_default_seed = time(NULL);\n  T = gsl_rng_default;\n  r = gsl_rng_alloc(T);\n  gsl_rng_default_seed = gsl_rng_uniform(r);\n\n  /* Allocation memoire */\n  TR = (pTestReaction) malloc(1 * sizeof(TestReaction));\n  if (T == NULL)\n    exit(EXIT_FAILURE);\n\n  /* File information */\n  nbReactions = Model_getNumReactions(mod);\n  nbEspeces = Model_getNumSpecies(mod);\n  /*printf(\"Nom du model : %s\\n\",Model_getId(mod));*/\n  molecules = Especes_alloc(nbEspeces);\n  /* Initialisation de la quantite des especes */\n  SBML_initEspeceAmounts(mod, molecules, nbEspeces);\n  /* Initialisation des reactions et des ratios*/\n  SBML_setReactions(mod, molecules, nbReactions, nbEspeces);\n\n\n  /*TODO checkRatio(mod,molecules);*/\n\n  /* Test des donnees enregistrees */\n  printf(\"\\nEtat des especes :\\n\\n\");\n  Especes_print(molecules, nbEspeces);\n\n  printf(\"\\nDebut de simulation ...\\n\");\n  /* Simulation des reactions */\n  while (temp > END) {\n      temp = 0;\n      for (i = 0; i < nbEspeces; i++) {\n          tempo = SBML_simulate(mod, molecules, r, TR, nbEspeces, i);\n          /*if (tempo != END) {\n              Especes_print_2(molecules, nbEspeces);\n\t\t\t\t printf(\"\\n\");\n          }*/\n          temp += tempo;\n      }\n  }\n  printf(\"Fin de simulation...\\n\");\n  printf(\"\\nEtat des especes :\\n\");\n  Especes_print_2(molecules, nbEspeces);\n  /* Liberation de la memoire des generateurs aleatoire */\n  gsl_rng_free(r);\n\n  /* Liberation de la memoire de la structure Especes */\n  Especes_free(molecules, nbEspeces);\n  if (TR != NULL)\n    free(TR);\n}\n\n/**\n * \\fn void SBML_score_add(pScore result, pScore result_temp, FILE *debugFile)\n * \\author Amine Ghozlane\n * \\brief  Add scores\n * \\param  result Struct Score used for all the simulation\n * \\param  result_temp Struct Score used at each simulation step\n * \\param  debugFile File use for debug\n */\nvoid SBML_score_add(pScore result, pScore result_temp, int nbEspeces)\n{\n  /* Addition des scores */\n  int i;\n\n  /* Copie des resultats */\n  for(i=0;i<nbEspeces;i++){\n      if(result->name[i]==NULL){\n          result->name[i]=(char*)malloc(((int)strlen(result_temp->name[i])+1)*sizeof(char));\n          assert(result->name[i]!=NULL);\n          strcpy(result->name[i], result_temp->name[i]);\n      }\n      result->quantite[i]+=result_temp->quantite[i];\n  }\n}\n\n/**\n * \\fn void SBML_score_mean(pScore result, int n)\n * \\author Amine Ghozlane\n * \\brief  Mean quantities for score\n * \\param  result Struct Score\n * \\param  n Number of simulation step\n */\nvoid SBML_score_mean(pScore result, int nbEspeces, int n)\n{\n  /* Moyenne des resultats */\n  int i;\n  for(i=0;i<nbEspeces;i++){\n      result->quantite[i]/=n;\n  }\n}\n\n/**\n * \\fn pScore SBML_scoreAlloc(pListParameters a)\n * \\author Amine Ghozlane\n * \\brief  Allocation of the struct Score\n * \\param  a Global parameters : struct ListParameters\n * \\return Allocated struct Score\n */\npScore SBML_scoreAlloc(int nbEspeces)\n{\n  int i;\n  /* Allocation de la structure de score */\n  pScore result=NULL;\n  result=(pScore)malloc(1*sizeof(Score));\n  assert(result!=NULL);\n\n  result->name=NULL;\n  result->quantite=NULL;\n  result->name=(char**)malloc(nbEspeces*sizeof(char*));\n  assert(result->name!=NULL);\n  result->quantite=(double*)malloc(nbEspeces*sizeof(double));\n  assert(result->quantite!=NULL);\n  for(i=0;i<nbEspeces;i++){\n      result->name[i]=NULL;\n      result->quantite[i]=0.0;\n  }\n  return result;\n}\n\n/**\n * \\fn void SBML_scoreFree(pScore out)\n * \\author Amine Ghozlane\n * \\brief  Free the struct Score\n * \\param  out Struct score\n */\nvoid SBML_scoreFree(pScore out, int nbEspeces)\n{\n  int i;\n  /* Libere la memoire alloue a la structure de score */\n  for(i=0;i<nbEspeces;i++){\n      if(out->name[i]!=NULL) free(out->name[i]);\n  }\n  if(out->name!=NULL) free(out->name);\n  if(out->quantite!=NULL) free(out->quantite);\n  if(out!=NULL) free(out);\n}\n\n/* Affiche le score moyen */\n\n/**\n * \\fn void SBML_scoreFree(pScore out)\n * \\author Amine Ghozlane\n * \\brief  Free the struct Score\n * \\param  out Struct score\n * \\param  nbEspeces\n */\nvoid SBML_score_print(pScore result, int nbEspeces)\n{\n  int i;\n  /* Print head*/\n  /*for(i=0;i<nbEspeces;i++){\n      printf(\"%s;\",result->name[i]);\n  }\n  printf(\"\\n\");*/\n  /* Print Value */\n  for(i=0;i<nbEspeces;i++){\n      /*printf(\"Molecule: %s - Biomass: %.0f\\n\",result->name[i],result->quantite[i]);*/\n      printf(\"%.0f;\",result->quantite[i]);\n  }\n  printf(\"\\n\");\n}\n\n/**\n * \\fn void SBML_compute_simulation_mean(Model_t *mod, int nb_simulation)\n * \\author Amine Ghozlane\n * \\brief  X time simulation of metabolic network\n * \\param  mod Model of the SBML file\n * \\param  nb_simulation Number of simulation step\n */\nvoid SBML_compute_simulation_mean(Model_t *mod, int nb_simulation)\n{\n  /* Simulation du reseau metabolique  */\n  int i, j,nbReactions = 0, nbEspeces = 0, temp = 1, tempo=0, test=0;\n  pEspeces molecules=NULL;\n  pTestReaction TR=NULL;\n  const gsl_rng_type *T;\n  gsl_rng * r;\n  pScore result=NULL,result_temp=NULL;\n\n  /* Allocation memoire et initialisation des generateurs de nombre aleatoire */\n  gsl_rng_env_setup();\n  if (!getenv(\"GSL_RNG_SEED\"))\n    gsl_rng_default_seed = time(NULL)+(double)getpid();\n  T = gsl_rng_default;\n  r = gsl_rng_alloc(T);\n  /*gsl_rng_default_seed = time(NULL)+(double)getpid();*/\n\n  /* Allocation memoire */\n  TR=(pTestReaction)malloc(1*sizeof(TestReaction));\n  assert(TR!=NULL);\n\n  /* File information */\n  nbReactions = (int)Model_getNumReactions(mod);\n  nbEspeces = (int)Model_getNumSpecies(mod);\n  molecules = Especes_alloc(nbEspeces);\n\n  /* Initialisation de la structure de score temporaire */\n  result=SBML_scoreAlloc(nbEspeces);\n  result_temp=SBML_scoreAlloc(nbEspeces);\n\n  /* Initialisation de la quantite des especes */\n  SBML_initEspeceAmounts(mod, molecules, nbEspeces);\n  /* Initialisation des reactions et des ratios*/\n  SBML_setReactions(mod, molecules, nbReactions, nbEspeces);\n\n  /*printf(\"Start the simulation\\n\");*/\n  /* SIMULATION */\n  for(j=0;j<nb_simulation;j++){\n      /* Simulation des reactions */\n      while (temp > END) {\n          temp = 0;\n          for (i = 0; i < nbEspeces; i++) {\n              tempo = SBML_simulate(mod, molecules, r, TR, nbEspeces, i);\n              temp +=tempo;\n          }\n          test+=1;\n      }\n      temp=1;\n      tempo=0;\n      /*printf(\"Nombre de tour %d\\n\",test);*/\n      /*Score */\n      /* Enregistre le score des especes */\n      Especes_scoreSpecies(molecules, nbEspeces, result_temp->name, result_temp->quantite);\n      SBML_score_add(result,result_temp,nbEspeces);\n      SBML_initEspeceAmounts(mod, molecules, nbEspeces);\n  }\n  SBML_score_mean(result,nbEspeces,nb_simulation);\n\n  /*printf(\"End of the simulation...\\n\");\n  printf(\"Final state of the molecules :\\n\");*/\n  SBML_score_print(result, nbEspeces);\n\n  /* Liberation de la memoire des generateurs aleatoire */\n  gsl_rng_free(r);\n\n  /* Liberation de la memoire du score */\n  SBML_scoreFree(result, nbEspeces);\n  SBML_scoreFree(result_temp, nbEspeces);\n\n  /* Liberation de la memoire de la structure Especes */\n  Especes_free(molecules, nbEspeces);\n  if(TR!=NULL) free(TR);\n}\n", "meta": {"hexsha": "f36531ea27ecc2d93e36923141f6c1124b2e6149", "size": 23296, "ext": "c", "lang": "C", "max_stars_repo_path": "src/simulation.c", "max_stars_repo_name": "aghozlane/yasimSBML", "max_stars_repo_head_hexsha": "bd2067127afaaeccf3292b288797ce90ec9cddc0", "max_stars_repo_licenses": ["DOC"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/simulation.c", "max_issues_repo_name": "aghozlane/yasimSBML", "max_issues_repo_head_hexsha": "bd2067127afaaeccf3292b288797ce90ec9cddc0", "max_issues_repo_licenses": ["DOC"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/simulation.c", "max_forks_repo_name": "aghozlane/yasimSBML", "max_forks_repo_head_hexsha": "bd2067127afaaeccf3292b288797ce90ec9cddc0", "max_forks_repo_licenses": ["DOC"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.3276108727, "max_line_length": 147, "alphanum_fraction": 0.6659512363, "num_tokens": 6829, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.341582499438317, "lm_q2_score": 0.04958902631991414, "lm_q1q2_score": 0.016938743555068757}}
{"text": "/**\n * @file   libhades.c\n * @author Michael Hartmann <michael.hartmann@physik.uni-augsburg.de>\n * @date   February, 2016\n * @brief  library to access low-level LAPACK functions\n */\n\n#include <cblas.h>\n#include <errno.h>\n#include <math.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <stdint.h>\n#include <string.h>\n#include <strings.h>\n\n#include <libhades.h>\n#include <libhades/parse_npy_dict.h>\n\n\n/** \\defgroup misc miscellaneous functions\n *  @{\n */\n\n/** @brief malloc wrapper\n *\n * This function uses malloc to allocate size bytes of memory and returns a\n * pointer to the memory. If an error occures, an error message is printed to\n * stderr and the program is aborted.\n *\n * @param [in] size amount of memory to allocate\n * @retval ptr pointer to the allocated memory\n */\nvoid *libhades_malloc(size_t size)\n{\n    void *ptr = malloc(size);\n    if(ptr == NULL)\n    {   \n        const int err = errno;\n        fprintf(stderr, \"malloc can't allocate %zu bytes of memory: %s (%d)\\n\", size, strerror(err), err);\n        abort();\n    }   \n    return ptr;\n}\n\n/** @brief free wrapper\n *\n * This function frees the memory allocated by \\ref libhades_malloc or \\ref\n * libhades_realloc (or malloc and realloc). If the pointer given is NULL, an error is\n * printed to stderr and the program is aborted.\n *\n * @param [in] ptr pointer to the memory that should be freed\n */\nvoid libhades_free(void *ptr)\n{\n    if(ptr == NULL)\n    {\n        fprintf(stderr, \"Trying to free NULL pointer\\n\");\n        abort();\n    }\n\n    free(ptr);\n}\n\n/** @brief realloc wrapper\n *\n * This function changes the size of the memory block pointed to by ptr to size\n * bytes. If ptr is NULL, this function behaves like \\ref libhades_malloc. If\n * an error occures, an error is printed to stderr and the program is aboprted.\n *\n * @param [in] ptr pointer to the memory block\n * @param [in] size size of the memory block\n * @retval ptr_new pointer to the new memory block\n */\nvoid *libhades_realloc(void *ptr, size_t size)\n{\n    void *ptr_new = realloc(ptr, size);\n\n    if(ptr_new == NULL)\n    {\n        int err = errno;\n        fprintf(stderr, \"realloc can't allocate %zu bytes of memory: %s (%d)\\n\", size, strerror(err), err);\n        abort();\n    }\n\n    return ptr_new;\n}\n\nstatic void *(*malloc_cb)(size_t)          = &libhades_malloc;\nstatic void *(*realloc_cb)(void *, size_t) = &libhades_realloc;\nstatic void  (*free_cb)(void *)            = &libhades_free;\n\n\n/** macro to create functions argmin, argmax, argabsmin, argabsmax */\n#define ARGXXX(FUNCTION_NAME, FUNCTION, RELATION) \\\nsize_t FUNCTION_NAME(double list[], size_t size) \\\n{ \\\n    size_t index = 0; \\\n    for(size_t i = 0; i < size; i++) \\\n        if(FUNCTION(list[i]) RELATION FUNCTION(list[index])) \\\n            index = i; \\\n    return index; \\\n}\n\n/** @brief Return index of smallest element in list\n *\n * @param [in] list\n * @param [in] size elements in list\n *\n * @retval index\n */\nARGXXX(argmin, +, <)\n\n/** @brief Return index of largest element in list\n *\n * @param [in] list\n * @param [in] size elements in list\n *\n * @retval index\n */\nARGXXX(argmax, +, >)\n\n/** @brief Return index of element with smallest absolute value in list\n *\n * @param [in] list\n * @param [in] size elements in list\n *\n * @retval index\n */\nARGXXX(argabsmin, fabs, <)\n/** @brief Return index of element with largest absolute value in list\n *\n * @param [in] list\n * @param [in] size elements in list\n *\n * @retval index\n */\nARGXXX(argabsmax, fabs, >)\n\n/** @}*/\n\n\n\n/** \\defgroup create Creating, printing and freeing matrices\n *  @{\n */\n\nstatic inline void _swap_int(int *a, int *b);\nstatic inline void _swap_size_t(size_t *a, size_t *b);\n\nstatic inline void _swap_int(int *a, int *b)\n{\n    int c = *a;\n    *a = *b;\n    *b = c;\n}\n\nstatic inline void _swap_size_t(size_t *a, size_t *b)\n{\n    size_t c = *a;\n    *a = *b;\n    *b = c;\n}\n\n#define MATRIX_SWAP(FUNCTION_NAME, MATRIX_TYPE, TYPE) \\\nvoid FUNCTION_NAME(MATRIX_TYPE *A, MATRIX_TYPE *B) \\\n{ \\\n    /* swap pointers */ \\\n    TYPE *ptr = A->M; \\\n    A->M = B->M; \\\n    B->M = ptr; \\\n\\\n    /* swap rows */ \\\n    _swap_int(&A->rows, &B->rows); \\\n\\\n    /* swap columns */ \\\n    _swap_int(&A->columns, &B->columns); \\\n\\\n    /* swap min */ \\\n    _swap_int(&A->min, &B->min); \\\n\\\n    /* swap size */ \\\n    _swap_size_t(&A->size, &B->size); \\\n\\\n    /* swap type */ \\\n    _swap_int(&A->type, &B->type); \\\n\\\n    /* swap min */ \\\n    _swap_int(&A->min, &B->min); \\\n}\n\n/** @brief Swap matrices A and B\n *\n * This function swaps the matrices A and B. The former content of A will be\n * the content of B and vice versa. No data is copied or moved, but the\n * pointers are swapped.\n *\n * @param [in,out] A matrix A\n * @param [in,out] B matrix B\n */\nMATRIX_SWAP(matrix_swap, matrix_t, double);\n\n/** @brief Swap matrices A and B\n *\n * See \\ref matrix_swap.\n *\n * @param [in,out] A matrix A\n * @param [in,out] B matrix B\n */\nMATRIX_SWAP(matrix_complex_swap, matrix_complex_t, complex_t);\n\n/** macro to create a diagnal matrix out of a vector */\n#define MATRIX_DIAG(FUNCTION_NAME, MATRIX_TYPE, ZEROS) \\\nMATRIX_TYPE *FUNCTION_NAME(MATRIX_TYPE *v) \\\n{ \\\n    int dim = v->size; \\\n    MATRIX_TYPE *A = ZEROS(dim, dim, NULL); \\\n    if(A == NULL) \\\n        return NULL; \\\n\\\n    for(int i = 0; i < dim; i++) \\\n        matrix_set(A, i,i, v->M[i]); \\\n\\\n    return A; \\\n}\n\n/** @brief Construct a real diagonal matrix from a row or columns vector\n *\n * @param [in] v row or column vector\n *\n * @retval A A = diag(v) if successfull, NULL otherwise\n */\nMATRIX_DIAG(matrix_diag, matrix_t, matrix_zeros)\n\n/** @brief Construct a complex diagonal matrix from a row or columns vector\n *\n * @param [in] v row or column vector\n *\n * @retval A A = diag(v) if successfull, NULL otherwise\n */\nMATRIX_DIAG(matrix_complex_diag, matrix_complex_t, matrix_complex_zeros)\n\n\n/** @brief Set functions to allocate and free memory\n *\n * By default wrappers to malloc and free from <stdlib.h> are used to allocate\n * and free memory. If allocation of memory fails or a NULL pointer is freed,\n * the program will terminate.\n *\n * @param [in] _malloc_cb callback to a malloc-alike function\n * @param [in] _free_cb callback to a free-alike function\n */\nvoid matrix_set_alloc(void *(*_malloc_cb)(size_t), void  (*_free_cb)(void *))\n{\n    malloc_cb = _malloc_cb;\n    free_cb   = _free_cb;\n}\n\n\n/** macro for copying matrices. */\n#define MATRIX_COPY(FUNCTION_NAME, MTYPE, TYPE, ALLOC) \\\nMTYPE *FUNCTION_NAME(MTYPE *A, MTYPE *C) \\\n{ \\\n    if(C == NULL) { \\\n        C = ALLOC(A->rows, A->columns); \\\n        if(C == NULL) \\\n            return NULL; \\\n    } \\\n\\\n    C->rows    = A->rows; \\\n    C->columns = A->columns; \\\n    C->min     = A->min; \\\n    C->size    = A->size; \\\n    C->type    = A->type; \\\n    C->view    = 0; \\\n    memcpy(C->M, A->M, C->size*sizeof(TYPE)); \\\n    return C; \\\n}\n\n\n\n/** @brief Copy real matrix A\n *\n * Copy matrix A into C. If C is NULL, space for the matrix C will be\n * allocated.\n *\n * @param [in]     A real matrix\n * @param [in,out] C real matrix\n *\n * @retval C copy of A\n */\nMATRIX_COPY(matrix_copy, matrix_t, double, matrix_alloc)\n\n\n/** @brief Copy complex matrix A\n *\n * Copy matrix A into C. If C is NULL, space for the matrix C will be\n * allocated.\n *\n * @param [in]     A complex matrix\n * @param [in,out] C complex matrix\n *\n * @retval C copy of A\n */\nMATRIX_COPY(matrix_complex_copy, matrix_complex_t, complex_t, matrix_complex_alloc)\n\n\n/** @brief Copy a real matrix A to a complex matrix C\n *\n * Copy the matrix A to a complex matrix C. The matrix elements of A and C will\n * be identical. If C is NULL, memory for the matrix will be allocated.\n *\n * @param [in] A real matrix\n *\n * @retval C copy of A if successfull, NULL otherwise\n */\nmatrix_complex_t *matrix_tocomplex(matrix_t *A, matrix_complex_t *C)\n{\n    if(C == NULL)\n    {\n        C = matrix_complex_alloc(A->rows, A->columns);\n        if(C == NULL)\n            return NULL;\n    }\n\n    for(size_t i = 0; i < C->size; i++)\n        C->M[i] = A->M[i];\n\n    return C;\n}\n\n/** @brief Print real matrix M to stream\n *\n * Print the matrix A to the stream given by stream, e.g. stdout or stderr.\n * The format is given by the format string format, the separator of two\n * columns is sep, the separator between lines is given by sep_line. Both sep\n * and sep_line may be NULL.\n *\n * @param [in] stream output stream\n * @param [in] A real matrix\n * @param [in] format output format, e.g. \"%lf\" or \"%g\"\n * @param [in] sep separator between columns, e.g. \"\\t\"\n * @param [in] sep_line separator between lines, e.g. \"\\n\"\n */\nvoid matrix_fprintf(FILE *stream, matrix_t *A, const char *format, const char *sep, const char *sep_line)\n{\n    const int rows = A->rows, columns = A->columns;\n\n    for(int i = 0; i < rows; i++)\n    {\n        for(int j = 0; j < columns; j++)\n        {\n            fprintf(stream, format, matrix_get(A, i,j));\n            if(sep != NULL)\n                fputs(sep, stream);\n        }\n        if(sep_line != NULL)\n            fputs(sep_line, stream);\n    }\n}\n\n/** @brief Print complex matrix A to stream\n *\n * See matrix_fprintf.\n *\n * @param [in] stream output stream\n * @param [in] A complex matrix\n * @param [in] format output format, e.g. \"%+lf%+lfi\"\n * @param [in] sep separator between columns, e.g. \"\\t\"\n * @param [in] sep_line separator between lines, e.g. \"\\n\"\n */\nvoid matrix_complex_fprintf(FILE *stream, matrix_complex_t *A, const char *format, const char *sep, const char *sep_line)\n{\n    const int rows = A->rows, columns = A->columns;\n\n    for(int i = 0; i < rows; i++)\n    {\n        for(int j = 0; j < columns; j++)\n        {\n            const complex_t c = matrix_get(A, i,j);\n            fprintf(stream, format, CREAL(c), CIMAG(c));\n            if(sep != NULL)\n                fputs(sep, stream);\n        }\n        if(sep_line != NULL)\n            fputs(sep_line, stream);\n    }\n}\n\n/** macro for matrix allocations. */\n#define MATRIX_ALLOC(FUNCTION_NAME, MTYPE, TYPE) \\\nMTYPE *FUNCTION_NAME(int rows, int columns) \\\n{ \\\n    if(rows <= 0 || columns <= 0) \\\n        return NULL; \\\n\\\n    MTYPE *A = malloc_cb(sizeof(MTYPE)); \\\n    if(A == NULL) \\\n        return NULL; \\\n\\\n    const size_t size = (size_t)rows*(size_t)columns; \\\n\\\n    A->rows    = rows; \\\n    A->columns = columns; \\\n    A->min     = MIN(rows, columns); \\\n    A->size    = size; \\\n    A->type    = 0; \\\n    A->view    = 0; \\\n    A->M       = malloc_cb(size*sizeof(TYPE)); \\\n    if(A->M == NULL) \\\n    { \\\n        free_cb(A); \\\n        return NULL; \\\n    } \\\n\\\n    return A; \\\n}\n\n/** @brief Allocate memory for real matrix of m rows and n columns\n *\n * This function will allocate and return a matrix of m lines and n columns.\n * The function given by matrix_set_alloc will be used to allocate memory; by\n * default this is malloc from <stdlib.h>.\n *\n * The matrix elements will be undefined. To allocate a matrix initialized with\n * zeros, see matrix_zeros. To create a unity matrix, see matrix_eye.\n *\n * @param [in] rows rows of matrix M (rows > 0)\n * @param [in] columns columns of matrix M (columns > 0)\n *\n * @retval A real matrix if successful, NULL otherwise\n */\nMATRIX_ALLOC(matrix_alloc, matrix_t, double)\n\n/** @brief Allocate memory for complex matrix of m rows and n columns\n *\n * See matrix_alloc.\n *\n * @param [in] rows rows of matrix M (rows > 0)\n * @param [in] columns columns of matrix M (columns > 0)\n *\n * @retval A complex matrix if successful, otherwise NULL\n */\nMATRIX_ALLOC(matrix_complex_alloc, matrix_complex_t, complex_t)\n\n/** macro to create zero matrix */\n#define MATRIX_ZEROS(FUNCTION_NAME, MTYPE, TYPE, ALLOC, SETALL) \\\nMTYPE *FUNCTION_NAME(int rows, int columns, MTYPE *A) \\\n{ \\\n    if(A == NULL) \\\n    { \\\n        A = ALLOC(rows,columns); \\\n        if(A == NULL) \\\n            return NULL; \\\n    } \\\n\\\n    SETALL(A, 0); \\\n\\\n    return A; \\\n}\n\n/** @brief Generate a real zero matrix of m lines and n columns\n *\n * Set every element of matrix A to 0. If A is NULL, the matrix will be\n * created. In this case, you have to free the matrix yourself.\n *\n * @param [in] rows rows of matrix M\n * @param [in] columns columns of matrix M\n * @param [in,out] A: matrix\n *\n * @retval A real matrix 0 if successful, otherwise NULL\n */\nMATRIX_ZEROS(matrix_zeros, matrix_t, double, matrix_alloc, matrix_setall)\n\n/** @brief Generate a complex zero matrix of m lines and n columns\n *\n * See matrix_zeros.\n *\n * @param [in] rows rows of matrix M\n * @param [in] columns columns of matrix M\n * @param [in,out] A: matrix\n *\n * @retval A complex matrix 0 if successful, otherwise NULL\n */\nMATRIX_ZEROS(matrix_complex_zeros, matrix_complex_t, complex_t, matrix_complex_alloc, matrix_complex_setall)\n\n\n/** macro to create matrix x*Id */\n#define MATRIX_SETALL(FUNCTION_NAME, MATRIX_TYPE, TYPE) \\\nvoid FUNCTION_NAME(MATRIX_TYPE *A, TYPE x) \\\n{ \\\n    const size_t size = A->size; \\\n    TYPE *M = A->M; \\\n    for(size_t i = 0; i < size; i++) \\\n        *M++ = x; \\\n}\n\n/** @brief Set matrix elements of A to x\n *\n * @param [in,out] A real matrix\n * @param [in] x real number\n */\nMATRIX_SETALL(matrix_setall, matrix_t, double)\n\n/** @brief Set matrix elements of A to x\n *\n * @param [in,out] A complex matrix\n * @param [in] x complex number\n */\nMATRIX_SETALL(matrix_complex_setall, matrix_complex_t, complex_t)\n\n/** macro to create unity matrix */\n#define MATRIX_EYE(FUNCTION_NAME, MTYPE, TYPE, ALLOC, SETALL) \\\nMTYPE *FUNCTION_NAME(int dim, MTYPE *A) \\\n{ \\\n    if(A == NULL) \\\n    { \\\n        A = ALLOC(dim,dim); \\\n        if(A == NULL) \\\n            return NULL; \\\n    } \\\n \\\n    const int min = A->min; \\\n    TYPE *M = A->M; \\\n    SETALL(A,0); \\\n    for(int i = 0; i < min; i++) \\\n        *(M+i*(min+1)) = 1; \\\n \\\n    return A; \\\n}\n\n\n/** @brief Create real identity matrix\n *\n * If A == NULL, a identity matrix of dimension dim times dim is created and\n * returned.\n * If A != NULL, the matrix A is set to the identity matrix and the parameter\n * dim is ignored. More specific, for a general (e.g. not square) matrix A, the\n * matrix elements are set to A_ij = Delta_ij.\n *\n * @param [in]     dim dimension of identity matrix (ignored for A == NULL)\n * @param [in,out] A real matrix\n *\n * @retval A identity matrix if successful, NULL otherwise\n */\nMATRIX_EYE(matrix_eye, matrix_t, double, matrix_alloc, matrix_setall)\n\n/** @brief Create complex identity matrix\n *\n * See matrix_eye.\n *\n * @param [in]     dim dimension of identity matrix (ignored for A == NULL)\n * @param [in,out] A complex matrix\n *\n * @retval A identity matrix if successful, NULL otherwise\n */\nMATRIX_EYE(matrix_complex_eye, matrix_complex_t, complex_t, matrix_complex_alloc, matrix_complex_setall)\n\n\n/** macro to free matrices */\n#define MATRIX_FREE(FUNCTION_NAME, MTYPE) \\\nvoid FUNCTION_NAME(MTYPE *A) \\\n{ \\\n    if(A != NULL) \\\n    { \\\n        if(!A->view && A->M != NULL) \\\n        { \\\n            free_cb(A->M); \\\n            A->M = NULL; \\\n        } \\\n        free_cb(A); \\\n    } \\\n}\n\n/** @brief Free real matrix\n *\n * This function will free the memory allocated for matrix M. If M is NULL this\n * function will do nothing.\n *\n * @param [in,out] A matrix to free\n */\nMATRIX_FREE(matrix_free, matrix_t)\n\n/** @brief Free complex matrix\n *\n * See matrix_free.\n *\n * @param [in,out] A matrix to free\n */\nMATRIX_FREE(matrix_complex_free, matrix_complex_t)\n\n/** @}*/\n\n\n/** \\defgroup trdet trace and determinant\n *  @{\n */\n\n/** macro to calculate trace of matrix */\n#define MATRIX_TRACE(FUNCTION_NAME, MATRIX_TYPE, TYPE) \\\nTYPE FUNCTION_NAME(MATRIX_TYPE *A) \\\n{ \\\n    const int min = A->min; \\\n    const TYPE *M = A->M; \\\n    TYPE trace = 0; \\\n    for(int i = 0; i < min; i++) \\\n        trace += *(M+i*(1+min)); \\\n\\\n    return trace; \\\n}\n\n/** @brief Calculate Tr(A) of real matrix A\n *\n * @param [in] A complex matrix\n *\n * @retval x with x=Tr(A)\n */\nMATRIX_TRACE(matrix_trace, matrix_t, double)\n\n/** @brief Calculate Tr(A) of complex matrix A\n *\n * @param [in] A complex matrix\n *\n * @retval z with z=Tr(A)\n */\nMATRIX_TRACE(matrix_complex_trace, matrix_complex_t, complex_t)\n\n/** @brief Calculate Tr(A*B)\n *\n * This will calculate the trace of A*B: Tr(A*B). Matrix A and B must be square\n * matrices of dimension dim, dim.\n *\n * A and B must not point to the same matrix or the behaviour will be\n * undefined!\n *\n * @param [in] A real matrix\n * @param [in] B real matrix\n *\n * @retval x with x=Tr(A*B)\n */\ndouble matrix_trace_AB(matrix_t *A, matrix_t *B)\n{\n    const int dim = A->min;\n    double sum = 0;\n    double *M1 = A->M;\n    double *M2 = B->M;\n\n    for(int i = 0; i < dim; i++)\n        sum += cblas_ddot(dim, M1+i, dim, M2+i*dim, 1);\n\n    return sum;\n}\n\n/** @brief Calculate Tr(A*B) for A,B complex\n *\n * See matrix_trace_AB.\n *\n * @param [in] A complex matrix\n * @param [in] B complex matrix\n *\n * @retval z with z=Tr(A*B)\n */\ncomplex_t matrix_trace_complex_AB(matrix_complex_t *A, matrix_complex_t *B)\n{\n    const int dim = A->min;\n    complex_t sum = 0;\n\n    for(int i = 0; i < dim; i++)\n        for(int k = 0; k < dim; k++)\n            sum += matrix_get(A, i,k)*matrix_get(B, k,i);\n\n    return sum;\n}\n\n/** @brief Calculate Re(Tr(A*B)) for A,B complex\n *\n * See matrix_trace_AB.\n *\n * @param [in] A complex matrix\n * @param [in] B complex matrix\n *\n * @retval x with x=Re(Tr(A*B))\n */\ndouble matrix_trace_complex_AB_real(matrix_complex_t *A, matrix_complex_t *B)\n{\n    const int dim = A->rows;\n    double sum = 0;\n    const complex_t *M1 = A->M;\n    const complex_t *M2 = B->M;\n\n    for(int i = 0; i < dim; i++)\n        for(int k = 0; k < dim; k++)\n            sum += CREAL(M1[i*dim+k]*M2[k*dim+i]);\n\n    return sum;\n}\n\n/** @}*/\n\n\n/** \\defgroup kron Kronecker product\n *  @{\n */\n\n/** macro to create Kronecker product */\n#define MATRIX_KRON(FUNCTION_NAME, MTYPE, TYPE, ALLOC, SETALL) \\\nMTYPE *FUNCTION_NAME(MTYPE *A, MTYPE *B, MTYPE *C) \\\n{ \\\n    const int Am = A->rows, An = A->columns; \\\n    const int Bm = B->rows, Bn = B->columns; \\\n    if(C == NULL) \\\n    { \\\n        C = ALLOC(Am*Bm, An*Bn); \\\n        if(C == NULL) \\\n            return NULL; \\\n    } \\\n    SETALL(C, 0); \\\n\\\n    for(int m = 0; m < Am; m++) \\\n        for(int n = 0; n < An; n++) \\\n        { \\\n            const TYPE c = matrix_get(A,m,n); \\\n            if(c != 0) \\\n            { \\\n                for(int im = 0; im < Bm; im++) \\\n                    for(int in = 0; in < Bn; in++) \\\n                        matrix_set(C, m*Bm+im, n*Bn+in, c*matrix_get(B,im,in)); \\\n            } \\\n        } \\\n\\\n    return C; \\\n}\n\n\n/** @brief Calculate Kronecker product of real matrices A and B\n *\n * Matrix A has dimension Am,An, matrix B has dimension Bm,Bn.\n *\n * If C is not NULL, the Kronecker product will be stored in C. C must have\n * dimension Am+Bm,An+Bn. If C is NULL, memory for the matrix will be allocated\n * and the matrix will be returned. You have to free the memory for the\n * returned matrix yourself.\n *\n * @param [in] A real matrix\n * @param [in] B real matrix\n * @param [in,out] C Kronecker product\n *\n * @retval C Kronecker product of A and B, NULL if no memory could be allocated\n */\nMATRIX_KRON(matrix_kron, matrix_t, double, matrix_alloc, matrix_setall)\n\n\n/** @brief Calculate Kronecker product of complex matrices A and B\n *\n * See matrix_kron.\n *\n * @param [in] A complex matrix\n * @param [in] B complex matrix\n * @param [in,out] C Kronecker product\n *\n * @retval C Kronecker product of A and B\n */\nMATRIX_KRON(matrix_complex_kron, matrix_complex_t, complex_t, matrix_complex_alloc, matrix_complex_setall)\n\n/** @}*/\n\n\n/** \\defgroup addsubmult Add, subtract and multiply matrices\n *  @{\n */\n\n\n/** macro to multiply matrix with scalar factor */\n#define MATRIX_MULT_SCALAR(FUNCTION_NAME, MTYPE, TYPE) \\\nvoid FUNCTION_NAME(MTYPE *A, TYPE alpha) \\\n{ \\\n    const size_t size = A->size; \\\n    TYPE *M = A->M; \\\n    for(size_t i = 0; i < size; i++) \\\n        M[i] *= alpha; \\\n}\n\n/** @brief Multiply real matrix with a real scalar\n *\n * alpha*A -> A\n *\n * @param [in,out] A real matrix\n * @param [in] alpha real scalar\n * @retval A, A=alpha*A\n */\nMATRIX_MULT_SCALAR(matrix_mult_scalar, matrix_t, double)\n\n/** @brief Multiply complex matrix with a complex scalar\n *\n * alpha*A -> A\n *\n * @param [in,out] A complex matrix\n * @param [in] alpha complex scalar\n * @retval A, A=alpha*A\n */\nMATRIX_MULT_SCALAR(matrix_complex_mult_scalar, matrix_complex_t, complex_t)\n\n/** @brief Multiply real matrix with a complex scalar\n *\n * alpha*A -> C\n *\n * If C is NULL, memory for the matrix C will be allocated. If C is not NULL, C\n * must have the correct dimension.\n *\n * @param [in] A real matrix\n * @param [in] alpha complex scalar\n * @param [in,out] C complex matrix\n *\n * @retval C, C = alpha*A\n */\nmatrix_complex_t *matrix_mult_complex_scalar(matrix_t *A, complex_t alpha, matrix_complex_t *C)\n{\n    const int rows    = A->rows;\n    const int columns = A->columns;\n    const double *AM  = A->M;\n    complex_t *CM;\n    if(C == NULL)\n    {\n        C = matrix_complex_alloc(rows, columns);\n        if(C == NULL)\n            return NULL;\n    }\n    CM = C->M;\n\n    for(size_t i = 0; i < C->size; i++)\n        CM[i] = alpha*AM[i];\n\n    return C;\n}\n\n\n/* compute alpha*A*B */\n#define MATRIX_MULT(FUNCTION_NAME, MATRIX_TYPE, TYPE, ALLOC, BLAS_xGEMM, PTR) \\\nMATRIX_TYPE *FUNCTION_NAME(MATRIX_TYPE *A, MATRIX_TYPE *B, TYPE alpha, MATRIX_TYPE *C) \\\n{ \\\n    TYPE beta = 0; \\\n\\\n    if(A->columns != B->rows) \\\n        return NULL; \\\n\\\n    if(C == NULL) \\\n    { \\\n        C = ALLOC(A->rows, B->columns); \\\n        if(C == NULL) \\\n            return NULL; \\\n    } \\\n\\\n    /* xGEMM ( TRANSA, TRANSB, M, N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC) */ \\\n    BLAS_xGEMM(CblasColMajor, /* column order */ \\\n               CblasNoTrans,  /* don't transpose/conjugate A */ \\\n               CblasNoTrans,  /* don't transpose/conjugate B */ \\\n               A->rows,       /* M: rows of A and C */ \\\n               B->columns,    /* N: columns of B and C */ \\\n               A->columns,    /* K: columns of A and rows of B */ \\\n               PTR alpha,     /* alpha: scalar */ \\\n               A->M,          /* A: matrix A */ \\\n               A->rows,       /* LDA: leading dimension of A (columns) */ \\\n               B->M,          /* B: matrix B */ \\\n               A->columns,    /* LDB: leading dimension of B (columns) */ \\\n               PTR beta,      /* beta: scalar */ \\\n               C->M,          /* C: matrix C */ \\\n               C->rows        /* LDC: leading dimension of C (columns) */ \\\n    ); \\\n\\\n    return C; \\\n}\n\n/** @brief Multiply real matrices\n *\n * alpha*A*B -> C\n *\n * If C is NULL, memory for the matrix C will be allocated.\n *\n * @param [in] A real matrix\n * @param [in] B real matrix\n * @param [in] alpha real scalar\n * @param [in,out] C real matrix\n *\n * @retval C, C = alpha*A*B\n */\nMATRIX_MULT(matrix_mult, matrix_t, double, matrix_alloc, cblas_dgemm, +)\n\n/** @brief Multiply complex matrices\n *\n * alpha*A*B -> C\n *\n * If C is NULL, memory for the matrix C will be allocated.\n *\n * @param [in] A complex matrix\n * @param [in] B complex matrix\n * @param [in] alpha complex scalar\n * @param [in,out] C complex matrix\n *\n * @retval C, C = alpha*A*B\n */\nMATRIX_MULT(matrix_complex_mult, matrix_complex_t, complex_t, matrix_complex_alloc, cblas_zgemm, &)\n\n/** macro to add two matrices */\n#define MATRIX_ADD(FUNCTION_NAME, TYPE1, MTYPE1, TYPE2, MTYPE2) \\\nint FUNCTION_NAME(MTYPE1 *A, MTYPE2 *B, TYPE1 alpha, MTYPE1 *C) \\\n{ \\\n    const size_t size = A->size; \\\n    TYPE1 *M3; \\\n    TYPE1 *M1 = A->M; \\\n    TYPE2 *M2 = B->M; \\\n\\\n    if(C == NULL) \\\n        M3 = A->M; \\\n    else \\\n        M3 = C->M; \\\n\\\n    if(A->rows != B->rows || A->columns != B->columns) \\\n        return LIBHADES_ERROR_SHAPE; \\\n\\\n    for(size_t i = 0; i < size; i++) \\\n        M3[i] = M1[i] + (alpha*M2[i]); \\\n\\\n    return 0; \\\n}\n\n/** @brief Add real matrices A and B\n *\n * Calculate A+alpha*B -> C.\n *\n * The result will be stored in C. If C is NULL, the result is stored in A.\n *\n * @param [in,out] A real matrix\n * @param [in] B real matrix\n * @param [in] alpha real scalar\n * @param [in,out] C real matrix or NULL\n *\n * @retval 0 if successfull\n * @retval LIBHADES_ERROR_SHAPE if matrices have wrong shape\n */\nMATRIX_ADD(matrix_add, double, matrix_t, double, matrix_t)\n\n/** @brief Add complex matrices A and B\n *\n * Calculate A+alpha*B -> C.\n *\n * The result will be stored in C. If C is NULL, the result is stored in A.\n *\n * @param [in,out] A complex matrix\n * @param [in] B complex matrix\n * @param [in] alpha complex number\n * @param [in,out] C complex matrix or NULL\n *\n * @retval 0 if successfull\n * @retval LIBHADES_ERROR_SHAPE if matrices have wrong shape\n */\nMATRIX_ADD(matrix_complex_add, complex_t, matrix_complex_t, complex_t, matrix_complex_t)\n\n/** @brief Add complex matrix A and real matrix B\n *\n * Calculate A+alpha*B -> C.\n *\n * The result will be stored in C. If C is NULL, the result is stored in A.\n *\n * @param [in,out] A complex matrix\n * @param [in] B real matrix\n * @param [in] alpha complex scalar\n * @param [in,out] C complex matrix or NULL\n *\n * @retval 0 if successfull\n * @retval LIBHADES_ERROR_SHAPE if matrices have wrong shape\n */\nMATRIX_ADD(matrix_complex_add_real, complex_t, matrix_complex_t, double, matrix_t)\n\n/** @}*/\n\n\n/** \\defgroup transconj Transpose, conjugate\n *  @{\n */\n\n\n#define MATRIX_TRANSPOSE(FUNCTION_NAME, MTYPE, TYPE) \\\nvoid FUNCTION_NAME(MTYPE *A) \\\n{ \\\n    const int rows    = A->rows; \\\n    const int columns = A->columns; \\\n    for(int im = 0; im < rows; im++) \\\n        for(int in = im+1; in < columns; in++) \\\n        { \\\n            TYPE temp = matrix_get(A, im, in); \\\n            matrix_set(A, im, in, matrix_get(A, in, im)); \\\n            matrix_set(A, in, im, temp); \\\n        } \\\n\\\n    A->rows    = columns; \\\n    A->columns = rows; \\\n}\n\n/** @brief Transpose real matrix A\n *\n * The matrix will be transposed.\n *\n * @param [in,out] A real matrix\n *\n * @retval C with C=A^T\n */\nMATRIX_TRANSPOSE(matrix_transpose, matrix_t, double)\n\n/** @brief Transpose complex matrix A\n *\n * The matrix will be transposed.\n *\n * @param [in,out] A complex matrix\n *\n * @retval C with C=A^T\n */\nMATRIX_TRANSPOSE(matrix_complex_transpose, matrix_complex_t, complex_t)\n\n/** @}*/\n\n\n/** \\defgroup ev Eigenvalue problems\n *  @{\n */\n\n\n/** @brief Compute eigenvalues and optionally eigenvectors of symmetric matrix A\n *\n * This function computes all eigenvalues and, optionally, eigenvectors of a\n * real symmetric matrix A.\n *\n * See dsyev.\n *\n * @param [in] A real matrix\n * @param [in] JOBZ 'N': only eigenvalues, 'V' eigenvalues and eigenvectors\n * @param [in] UPLO 'U': upper triangle part of A is stored; 'L': lower triangle part of A is stored\n * @param [in] w real matrix of dimension (dim,1) (i.e. a vector); the eigenvalues will be stored in w\n *\n * @retval 0 on success\n */\nint eig_sym(matrix_t *A, char *JOBZ, char *UPLO, matrix_t *w)\n{\n    int info, lwork = -1, N = A->min;\n    double workopt;\n    double *work;\n\n    dsyev_(JOBZ, UPLO, &N, A->M, &N, w->M, &workopt, &lwork, &info);\n    if(info != 0)\n        return info;\n\n    lwork = workopt;\n    work = malloc_cb(lwork*sizeof(double));\n    if(work == NULL)\n        return LIBHADES_ERROR_OOM;\n\n    dsyev_(JOBZ, UPLO, &N, A->M, &N, w->M, work, &lwork, &info);\n\n    free_cb(work);\n\n    return info;\n}\n\n/** @brief Compute eigenvalues and optionally eigenvectors of Hermitian matrix A\n *\n * This function computes all eigenvalues and, optionally, eigenvectors of a\n * Hermitian symmetric matrix A.\n *\n * See zheev.\n *\n * @param [in] A complex matrix\n * @param [in] JOBZ 'N': only eigenvalues, 'V' eigenvalues and eigenvectors\n * @param [in] UPLO 'U': upper triangle part of A is stored; 'L': lower triangle part of A is stored\n * @param [in] w real matrix of dimension (dim,1) (i.e. a vector); the eigenvalues will be stored in w\n *\n * @retval 0 on success\n */\nint eig_herm(matrix_complex_t *A, char *JOBZ, char *UPLO, matrix_t *w)\n{\n    int info, lwork = -1, N = A->min;\n    complex_t workopt;\n    complex_t *work = NULL;\n    double *rwork;\n    \n    rwork = malloc_cb(MAX(1, 3*N-2)*sizeof(double));\n    if(rwork == NULL)\n        return LIBHADES_ERROR_OOM;\n\n    zheev_(JOBZ, UPLO, &N, A->M, &N, w->M, &workopt, &lwork, rwork, &info);\n    if(info != 0)\n    {\n        free_cb(rwork);\n        return info;\n    }\n\n    lwork = CREAL(workopt);\n    work = malloc_cb(lwork*sizeof(complex_t));\n    if(work == NULL)\n    {\n        free_cb(rwork);\n        return LIBHADES_ERROR_OOM;\n    }\n\n    zheev_(JOBZ, UPLO, &N, A->M, &N, w->M, work, &lwork, rwork, &info);\n\n    free_cb(rwork);\n    free_cb(work);\n\n    return info;\n}\n\n/** @brief Compute eigenvalues and optionally eigenvectors of matrix A\n *\n * Compute for an N-by-N complex nonsymmetric matrix A, the eigen- values and,\n * optionally, right eigenvectors\n *\n * See zgeev.\n *\n * @param [in] A real matrix\n * @param [in] w list containing the eigenvalues of A\n * @param [in] vr if vr != NULL, right eigenvectors are computed and will be stored in vr; vr must be a complex matrix of dimension (dim,dim)\n * @param [in] vl if vl != NULL, lefft eigenvectors are computed and will be stored in vl; vl must be a complex matrix of dimension (dim,dim)\n *\n * @retval 0 on success\n */\n\n/* Parameters */\nint eig_complex_generic(matrix_complex_t *A, matrix_complex_t *w, matrix_complex_t *vl, matrix_complex_t *vr)\n{\n    int N = A->min;\n    int lwork = -1;\n    char jobvr = 'N';\n    char jobvl = 'N';\n    int info;\n    complex_t *evr  = NULL;\n    complex_t *evl  = NULL;\n    complex_t *work = NULL;\n    double *rwork   = NULL;\n    complex_t wopt;\n\n    /* if vr is not NULL, calculate right eigenvectors */\n    if(vr != NULL)\n    {\n        jobvr = 'V';\n        evr   = vr->M;\n    }\n    /* if vl is not NULL, calculate left eigenvectors */\n    if(vl != NULL)\n    {\n        jobvl = 'V';\n        evl   = vl->M;\n    }\n\n    /* get the optimal size for workspace work */\n    zgeev_(&jobvl, &jobvr, &N, A->M, &N, w->M, evl, &N, evr, &N, &wopt, &lwork, rwork, &info);\n\n    if(info != 0)\n        return info;\n\n    lwork = CREAL(wopt);\n\n    rwork = malloc_cb(2*N*sizeof(double));\n    work  = malloc_cb(lwork*sizeof(complex_t));\n\n    if(rwork == NULL || work == NULL)\n    {\n        if(rwork != NULL)\n            free(rwork);\n        if(work != NULL)\n            free(work);\n\n        return LIBHADES_ERROR_OOM;\n    }\n\n    /* SUBROUTINE ZGEEV( JOBVL, JOBVR, N, A, LDA, W, VL, LDVL, VR, LDVR, WORK, LWORK, RWORK, INFO ) */\n    zgeev_(\n        &jobvl,     /* left eigenvectors of A are not computed */\n        &jobvr,     /* calculate/don't calculate right eigenvectors */\n        &N,         /* order of matrix A */\n        A->M,       /* matrix A */\n        &N,         /* LDA - leading dimension of A */\n        w->M,       /* eigenvalues */\n        evl,        /* left eigenvectors */\n        &N,         /* leading dimension of array vl */\n        evr,        /* eigenvectors */\n        &N,         /* leading dimension of the array VR */\n        work,       /* COMPLEX*16 array, dimension (LWORK) */\n        &lwork,     /* dimension of the array WORK; LWORK >= max(1,2*N) */\n        rwork,      /* (workspace) DOUBLE PRECISION array, dimension (2*N) */\n        &info       /* 0 == success */\n    );\n\n    free_cb(work);\n    free_cb(rwork);\n\n    return info;\n}\n\nint eig_complex_vr(matrix_complex_t *M, complex_t lambda, matrix_complex_t *vr)\n{\n    matrix_complex_t *A = NULL, *b = NULL;\n    const int rows    = M->rows;\n    const int columns = M->columns;\n\n    /* lapack */\n    char trans = 'N';\n    int info, lwork;\n    complex_t work_size, *work = NULL;\n    int m = rows+1, n = columns, nrhs = 1;\n    int lda = m, ldb = MAX(m,n);\n\n    if((A = matrix_complex_alloc(rows+1, columns)) == NULL)\n        return LIBHADES_ERROR_OOM;\n\n    if((b = matrix_complex_zeros(rows+1,1,NULL)) == NULL)\n    {\n        matrix_complex_free(A);\n        return LIBHADES_ERROR_OOM;\n    }\n    matrix_set(b, rows,0, 1);\n\n    for(int j = 0; j < columns; j++)\n    {\n        for(int i = 0; i < rows; i++)\n            matrix_set(A, i, j, matrix_get(M, i,j));\n\n        /* - lambda Id */\n        matrix_set(A, j,j, matrix_get(A,j,j)-lambda);\n\n        /* set nomalization condition */\n        matrix_set(A, rows,j, 1);\n    }\n\n    /* determine work size */\n    lwork = -1;\n    zgels_(&trans, &m, &n, &nrhs, A->M, &lda, b->M, &ldb, &work_size, &lwork, &info);\n    lwork = (int)CREAL(work_size);\n    if((work = malloc_cb(lwork*sizeof(complex_t))) == NULL)\n    {\n        matrix_complex_free(A);\n        matrix_complex_free(vr);\n        return LIBHADES_ERROR_OOM;\n    }\n\n    /* calculate eigenvector */\n    zgels_(\n        &trans, /* find least squares solution of overdetermined system */\n        &m,     /* number of rows of matrix A */\n        &n,     /* number of columns of matrix A */\n        &nrhs,  /* number of columns of matrix B */\n        A->M,   /* matrix A (will be overwritten) */\n        &lda,   /* leading dimension of A, LDA >= max(1,M) */\n        b->M,   /* on entry: right hand side vectors, on exit: solution */\n        &ldb,   /* leading dimension of B, LDB >= MAX(1,M,N) */\n        work,   /* workspace */\n        &lwork, /* dimension of work */\n        &info   /* status */\n    );\n\n    free_cb(work);\n    matrix_complex_free(A);\n\n    for(int i = 0; i < rows; i++)\n        matrix_set(vr, i,0, matrix_get(b, i,0));\n\n    matrix_complex_free(b);\n\n    return info;\n}\n\n/** @}*/\n\n\n\n\n/** \\defgroup exp Calculate matrix exponential\n *  @{\n */\n\n/** macro to calculate matrix norm */\n#define MATRIX_NORM(FUNCTION_NAME, MTYPE, LAPACK_FUNC) \\\nint FUNCTION_NAME(MTYPE *A, char norm_type, double *norm) \\\n{ \\\n    double *work = NULL; \\\n\\\n    if(norm_type == 'I') \\\n    { \\\n        work = malloc_cb(A->rows*sizeof(double)); \\\n        if(work == NULL) \\\n            return LIBHADES_ERROR_OOM; \\\n    } \\\n\\\n    *norm = LAPACK_FUNC(&norm_type, &A->rows, &A->columns, A->M, &A->rows, work); \\\n\\\n    if(work != NULL) \\\n        free_cb(work); \\\n\\\n    return 0; \\\n}\n\n/** @brief Compute matrix norm for real matrix\n *\n * See dlange.\n *\n * Returns\n *      max(abs(A(i,j))), norm_type = 'M' or 'm'\n *      norm1(A),         norm_type = '1', 'O' or 'o'\n *      normI(A),         norm_type = 'I' or 'i'\n *      normF(A),         norm_type = 'F', 'f', 'E' or 'e'\n *\n * @param [in]  A real matrix\n * @param [in]  norm_type type of norm, e.g. 'F' for Frobenius norm\n * @param [out] norm value of norm\n *\n * @retval ret 0 if successfull, <0 otherwise\n */\nMATRIX_NORM(matrix_norm, matrix_t, dlange_);\n\n/** @brief Compute matrix norm for complex matrix\n *\n * See matrix_norm.\n *\n * @param [in]  A complex matrix\n * @param [in]  norm_type type of norm, e.g. 'F' for Frobenius norm\n * @param [out] norm value of norm\n *\n * @retval ret 0 if successfull, <0 otherwise\n */\nMATRIX_NORM(matrix_complex_norm, matrix_complex_t, zlange_);\n\nmatrix_complex_t *matrix_complex_exp_taylor(matrix_complex_t *A, int order)\n{\n    const int rows = A->min;\n    matrix_complex_t *C = matrix_complex_alloc(rows,rows);\n\n    /* B = E+A/order */\n    matrix_complex_t *B = matrix_complex_copy(A,NULL);\n    matrix_complex_mult_scalar(B, 1./order);\n\n    for(int i = 0; i < rows; i++)\n        matrix_set(B, i,i, 1+matrix_get(B,i,i));\n\n    for(int k = order-1; k > 0; k--)\n    {\n        matrix_complex_mult(A, B, 1./order, C);\n\n        /* swap */\n        {\n            matrix_complex_t *temp;\n            temp = C;\n            C = B;\n            B = temp;\n        }\n\n        for(int i = 0; i < rows; i++)\n            matrix_set(B, i,i, 1+matrix_get(B,i,i));\n    }\n\n    matrix_complex_free(C);\n\n    return B;\n}\n\n/** @}*/\n\n\n\n/** \\defgroup LA LU decomposition, inverting\n *  @{\n */\n\n#define LU_DECOMPOSITION(FUNCTION_NAME, MATRIX_TYPE, XGETRF) \\\nint FUNCTION_NAME(MATRIX_TYPE *A, int ipiv[]) \\\n{ \\\n    int info; \\\n\\\n    XGETRF( \\\n        &A->rows,    /* M number of rows of A */ \\\n        &A->columns, /* N number of columns of A */ \\\n        A->M,        /* matrix A to be factored */ \\\n        &A->columns, /* LDA: leading dimension of A */ \\\n        ipiv,        /* pivot indices of dimension (min(M,N)) */ \\\n        &info \\\n    ); \\\n\\\n    return info; \\\n}\n\n/** @brief Compute LU decomposition of real matrix A\n *\n * See dgetrf.\n *\n * The factorization has the form\n *    A = P * L * U\n * where P is a permutation matrix, L is lower triangular with unit\n * diagonal elements (lower trapezoidal if rows > columns), and U is upper\n * triangular (upper trapezoidal if m < n).\n *\n * @param [in,out] A real matrix\n * @param [out] ipiv pivot indices; array of dimension MIN(rows,columns)\n *\n * @retval INFO\n */\nLU_DECOMPOSITION(matrix_lu_decomposition, matrix_t, dgetrf_)\n\n/** @brief Compute LU decomposition of complex matrix A\n *\n * See matrix_lu_decomposition.\n *\n * @param [in,out] A complex matrix\n * @param [out] ipiv pivot indices; array of dimension MIN(rows,columns)\n *\n * @retval INFO\n */\nLU_DECOMPOSITION(matrix_complex_lu_decomposition, matrix_complex_t, zgetrf_)\n\n#define MATRIX_INVERT(FUNCTION_NAME, TYPE, MATRIX_TYPE, LU_DECOMPOSITION, XGETRI) \\\nint FUNCTION_NAME(MATRIX_TYPE *A) \\\n{ \\\n    int info, lwork, dim = A->min; \\\n    int *ipiv = NULL; \\\n    TYPE *work = NULL; \\\n    TYPE workopt; \\\n\\\n    ipiv = malloc_cb(dim*sizeof(int)); \\\n    if(ipiv == NULL) \\\n        return LIBHADES_ERROR_OOM; \\\n\\\n    info = LU_DECOMPOSITION(A, ipiv); \\\n    if(info != 0) \\\n        goto out; \\\n\\\n    lwork = -1; \\\n    XGETRI(&dim, A->M, &dim, ipiv, &workopt, &lwork, &info); \\\n    if(info != 0) \\\n        goto out; \\\n\\\n    lwork = (int)workopt; \\\n    work = malloc_cb(lwork*sizeof(TYPE)); \\\n    if(work == NULL) \\\n    { \\\n        info = LIBHADES_ERROR_OOM; \\\n        goto out; \\\n    } \\\n\\\n    XGETRI( \\\n        &dim,   /* order of matrix A */ \\\n        A->M,   /* factors L and U from LU decomposition */ \\\n        &dim,   /* LDA: leading dimension of A */ \\\n        ipiv,   /* pivot indices */ \\\n        work,   /* workspace of dimension LWORK */ \\\n        &lwork, /* length of work */ \\\n        &info \\\n    ); \\\n\\\nout: \\\n    free_cb(ipiv); \\\n    if(work != NULL) \\\n        free_cb(work); \\\n\\\n    return info; \\\n}\n\n/** @brief Invert real matrix A\n *\n * The inverse of A is computed using the LU factorzation of A\n *\n * @param [in] A real matrix\n *\n * @retval INFO\n */\nMATRIX_INVERT(matrix_invert, double, matrix_t, matrix_lu_decomposition, dgetri_)\n\n/** @brief Invert complex matrix A\n *\n * See matrix_invert.\n *\n * @param [in] A complex matrix\n *\n * @retval INFO\n */\nMATRIX_INVERT(matrix_complex_invert, complex_t, matrix_complex_t, matrix_complex_lu_decomposition, zgetri_)\n\n#define MATRIX_SOLVE(FUNCTION_NAME, MATRIX_TYPE, LU_DECOMPOSITION, XGETRS) \\\nint FUNCTION_NAME(MATRIX_TYPE *A, MATRIX_TYPE *b) \\\n{ \\\n    int N = A->min; \\\n    char trans = 'N'; \\\n    int nrhs = b->columns; \\\n    int info = -1; \\\n    int *ipiv = malloc_cb(N*sizeof(int)); \\\n\\\n    if(ipiv == NULL) \\\n        return LIBHADES_ERROR_OOM; \\\n\\\n    LU_DECOMPOSITION(A, ipiv); \\\n    XGETRS(&trans, &N, &nrhs, A->M, &N, ipiv, b->M, &N, &info); \\\n\\\n    free_cb(ipiv); \\\n\\\n    return info; \\\n}\n\n/** @brief Solve system of linear equations\n *\n * Solve the system of linear equations:\n *      A*x = b\n *\n * @param [in,out] A matrix\n * @param [in,out] b vector/matrix\n *\n * @retval INFO\n */\n\n/** @}*/\nMATRIX_SOLVE(matrix_solve, matrix_t, matrix_lu_decomposition, dgetrs_);\n\n/** @brief Solve system of linear equations\n *\n * Solve the system of complex linear equations:\n *      A*x = b\n *\n * @param [in,out] A complex matrix\n * @param [in,out] b complex vector/matrix\n *\n * @retval INFO\n */\n\n/** @}*/\nMATRIX_SOLVE(matrix_complex_solve, matrix_complex_t, matrix_complex_lu_decomposition, zgetrs_);\n\n/*\nstatic void _cblas_zaxpy(const int N, const double alpha, const void *X, const int incX, void *Y, const int incY)\n{\n    complex_t beta = alpha;\n    cblas_zaxpy(N, &beta, X, incX, Y, incY);\n}\n*/\n\n/** @brief Calculate dot product of vectors x and y\n *\n * Calculate dot product of first column of x,y. If x and y have different\n * rows, the minimum is used.\n *\n * @param [in] x vector\n * @param [in] y vector\n * @retval x*y\n */\ndouble vector_dot(matrix_t *x, matrix_t *y)\n{\n    int incx = 1;\n    int incy = 1;\n    int N = MIN(x->rows, y->rows);\n    \n    return ddot_(&N, x->M, &incx, y->M, &incy);\n}\n\n/** @brief Calculate dot product of vectors x and y\n *\n * Calculate dot product of first column of x,y. If x and y have different\n * rows, the minimum is used.\n *\n * @param [in] x vector\n * @param [in] y vector\n * @retval x*y\n */\ncomplex_t vector_complex_dot(matrix_complex_t *x, matrix_complex_t *y)\n{\n    /*\n    int incx = 1;\n    int incy = 1;\n    int N = MIN(x->rows, y->rows);\n    complex_t z = 0;\n    \n    zdotc_(&z, &N, x->M, &incx, y->M, &incy);\n    return z;\n    */\n\n    int N = MIN(x->rows, y->rows);\n    complex_t z = 0;\n    for(int i = 0; i < N; i++)\n        z += matrix_get(x,i,0)*matrix_get(y,i,0);\n    return z;\n}\n\n#define MATRIX_GET_COLUMN(FUNCTION_NAME, TYPE, MATRIX_TYPE) \\\nMATRIX_TYPE *FUNCTION_NAME(MATRIX_TYPE *A, int i) \\\n{ \\\n    const int rows = A->rows; \\\n    MATRIX_TYPE *v = malloc_cb(sizeof(MATRIX_TYPE)); \\\n    if(v == NULL) \\\n        return NULL; \\\n\\\n    v->rows    = rows; \\\n    v->columns = 1; \\\n    v->min     = 1; \\\n    v->size    = rows; \\\n    v->type    = 0; \\\n    v->view    = 1; \\\n    v->M       = &A->M[i*rows]; \\\n\\\n    return v; \\\n}\n\n/** @brief Get i-th column of matrix A\n *\n * @param [in] A matrix\n * @param [in] i column number\n * @retval x*y\n */\nMATRIX_GET_COLUMN(matrix_get_column,         double,    matrix_t);\n\n/** @brief Get i-th column of matrix A\n *\n * @param [in] A matrix\n * @param [in] i column number\n * @retval x*y\n */\nMATRIX_GET_COLUMN(matrix_complex_get_column, complex_t, matrix_complex_t);\n\n\n/** \\defgroup sparse Functions for sparse matrices\n *  @{\n */\n\n#ifdef SUPPORT_SPARSE\n\n/** @brief Calculate eigenvalues of a sparse complex matrix\n *\n * @param [in] N     number of columns/rows of matrix\n * @param [in] nev   number of eigenvalues to compute\n * @param [in] which LM (largest magnitude), SM (smallest magnitude), LR (largest real part), SR (smallest real part), LI (largest imaginary part), SI (smallest imaginary part)\n * @param [in] Av callback function that implements the matrix-vector operation Av; the input vector is given as in, the vector Av must be written in out\n * @param [in,out] d on exit d contains the Rith approximations (must be of length nev+1)\n * @param [in] mxiter maximum number of Arnoldi update iterations allowed\n * @param [in] tol relative accuracy of the Ritz value\n * @param [in] data pointer that is given to callback function Av\n *\n * @retval 0 if successful\n */\nint sparse_complex_eig(int N, int nev, char *which, void (*Av)(int N, complex_t *in, complex_t *out, void *data), complex_t *d, int mxiter, double tol, void *data)\n{\n    int ret = LIBHADES_ERROR_OOM;\n    int info = 0;\n    int ido = 0;\n    char *bmat = \"I\";          /* standard eigenproblem */\n    int ncv = MIN(2*nev+2, N);\n\n    int ishift = 1;\n    int mode = 1;\n    int iparam[11] = { ishift, 0, mxiter, 1, 0, 0, mode, 0, 0, 0, 0 };\n\n    int ipntr[14];\n    int lworkl = ncv*(3*ncv + 5);\n    int rvec = 0;\n    char *howmny = \"P\";\n\n    complex_t *workd = NULL, *workl = NULL, *resid = NULL, *v = NULL, *workev = NULL;\n    int *select = NULL;\n    double *rwork = NULL;\n\n    /* allocate memory */\n    ret = LIBHADES_ERROR_OOM;\n\n    workd = malloc_cb(3*N*sizeof(complex_t));\n    if(workd == NULL)\n        goto out;\n    workl = malloc_cb(lworkl*sizeof(complex_t));\n    if(workl == NULL)\n        goto out;\n    rwork = malloc_cb(ncv*sizeof(double));\n    if(rwork == NULL)\n        goto out;\n    resid  = malloc_cb(N*sizeof(complex_t));\n    if(resid == NULL)\n        goto out;\n    v = malloc_cb(N*ncv*sizeof(complex_t));\n    if(v == NULL)\n        goto out;\n    select = malloc_cb(ncv*sizeof(int));\n    if(select == NULL)\n        goto out;\n    workev = malloc_cb((2*ncv)*sizeof(complex_t));\n    if(workev == NULL)\n        goto out;\n\n    /* loop */\n    while(1)\n    {\n        /* http://www.caam.rice.edu/software/ARPACK/UG/node138.html */\n        znaupd_(\n            &ido, bmat, &N, which, &nev, &tol, resid, &ncv, v, &N, iparam,\n            ipntr, workd, workl, &lworkl, rwork, &info, strlen(bmat),\n            strlen(which)\n        );\n\n        if(ido == 1 || ido == -1)\n            Av(N, &workd[ipntr[0]-1], &workd[ipntr[1]-1], data);\n        else if(ido == 99)\n            break;\n        else\n        {\n            ret = ido;\n            goto out;\n        }\n    }\n\n    if(info != 0)\n    {\n        ret = info;\n        goto out;\n    }\n\n    /* http://www.mathkeisan.com/usersguide/man/zneupd.html */\n    zneupd_(\n        &rvec, howmny, select, d, NULL, &N, NULL, workev, bmat, &N, which,\n        &nev, &tol, resid, &ncv, v, &N, iparam, ipntr, workd, workl, &lworkl,\n        rwork, &info, strlen(howmny), strlen(bmat), strlen(which)\n    );\n\n    ret = info;\n\nout:\n    if(resid != NULL)\n        free_cb(resid);\n    if(v != NULL)\n        free_cb(v);\n    if(workd != NULL)\n        free_cb(workd);\n    if(workl != NULL)\n        free_cb(workl);\n    if(rwork != NULL)\n        free_cb(rwork);\n    if(select != NULL)\n        free_cb(select);\n    if(workev != NULL)\n        free_cb(workev);\n\n    return ret;\n}\n\n#endif\n/** @}*/\n\n/** \\defgroup io Save/load matrices\n *  @{\n */\n\n#define MATRIX_LOAD_FROM_STREAM(FUNCTION_NAME, MATRIX_TYPE, TYPE, ALLOC, TRANSPOSE, IS_COMPLEX) \\\nMATRIX_TYPE *FUNCTION_NAME(FILE *stream, int *ret) \\\n{ \\\n    MATRIX_TYPE *M; \\\n    uint16_t len; \\\n    int rows, columns, fortran_order, is_complex; \\\n    char header[10] = { 0 }; \\\n    char dict[2048] = { 0 }; \\\n\\\n    if(ret != NULL) \\\n        *ret = 0; \\\n\\\n    /* read magic string, major and minor number */ \\\n    fread(header, 8, 1, stream); \\\n    if(memcmp(header, \"\\x93NUMPY\\x01\\x00\", 8) != 0) \\\n    { \\\n        if(ret != NULL) \\\n            *ret = LIBHADES_ERROR_HEADER; \\\n        return NULL; \\\n    } \\\n\\\n    /* read length of dict */ \\\n    fread(&len, sizeof(uint16_t), 1, stream); \\\n\\\n    if(len >= sizeof(dict)/sizeof(dict[0])) \\\n    { \\\n        if(ret != NULL) \\\n            *ret = LIBHADES_ERROR_INV_LENGTH; \\\n        return NULL; \\\n    } \\\n\\\n    fread(dict, sizeof(char), len, stream); \\\n\\\n    if(npy_dict_get_fortran_order(dict, &fortran_order) != 0) \\\n    { \\\n        if(ret != NULL) \\\n            *ret = LIBHADES_ERROR_ORDER; \\\n        return NULL; \\\n    } \\\n\\\n    if(npy_dict_get_shape(dict, &rows, &columns) != 0) \\\n    { \\\n        if(ret != NULL) \\\n            *ret = LIBHADES_ERROR_SHAPE; \\\n        return NULL; \\\n    } \\\n\\\n    if(npy_dict_get_descr(dict, &is_complex) != 0) \\\n    { \\\n        if(ret != NULL) \\\n            *ret = LIBHADES_ERROR_DESCR; \\\n        return NULL; \\\n    } \\\n\\\n    if(is_complex != IS_COMPLEX) \\\n    { \\\n        if(ret != NULL) \\\n            *ret = LIBHADES_ERROR_FORMAT; \\\n        return NULL; \\\n    } \\\n\\\n    M = ALLOC(rows,columns); \\\n    fread(M->M, sizeof(TYPE), rows*columns, stream); \\\n\\\n    if(!fortran_order) \\\n        TRANSPOSE(M); \\\n\\\n    M->min  = MIN(rows,columns); \\\n    M->size = (size_t)rows*(size_t)columns; \\\n    M->view = 0; \\\n    M->type = 0; \\\n\\\n    return M; \\\n}\n\n/** @brief Load real matrix from stream\n *\n * Load real matrix A from a stream. This function will also allocate memory\n * for the matrix.\n *\n * If error != NULL, error will be set to:\n *  0                         if successful\n *  LIBHADES_ERROR_HEADER     if magic or major/minor number is invalid\n *  LIBHADES_ERROR_INV_LENGTH if length of dictionary is invalid (too long)\n *  LIBHADES_ERROR_ORDER      if order is invalid (Fortran/C order)\n *  LIBHADES_ERROR_SHAPE      if shape is invalid (rows/columns)\n *  LIBHADES_ERROR_DESCR      if dtype is wrong/not supported\n *  LIBHADES_ERROR_FORMAT     if wrong format (real instead of complex)\n *  0 rows/columns wrong\n *\n * @param [in] stream file handle of a opened file\n * @param [out] error error code\n * @retval A matrix\n * @retval NULL if an error occured\n */\nMATRIX_LOAD_FROM_STREAM(matrix_load_from_stream, matrix_t, double, matrix_alloc, matrix_transpose, 0);\n\n/** @brief Load complex matrix from stream\n *\n * Load complex matrix A from a stream. This function will also allocate memory\n * for the matrix.\n *\n * If error != NULL, error will be set to:\n *  0                         if successful\n *  LIBHADES_ERROR_HEADER     if magic or major/minor number is invalid\n *  LIBHADES_ERROR_INV_LENGTH if length of dictionary is invalid (too long)\n *  LIBHADES_ERROR_ORDER      if order is invalid (Fortran/C order)\n *  LIBHADES_ERROR_SHAPE      if shape is invalid (rows/columns)\n *  LIBHADES_ERROR_DESCR      if dtype is wrong/not supported\n *  LIBHADES_ERROR_FORMAT     if wrong format (complex instead of real)\n *  0 rows/columns wrong\n *\n * @param [in] stream file handle of a opened file\n * @param [out] error error code\n * @retval A matrix\n * @retval NULL if an error occured\n */\nMATRIX_LOAD_FROM_STREAM(matrix_complex_load_from_stream, matrix_complex_t, complex_t, matrix_complex_alloc, matrix_complex_transpose, 1);\n\n\n#define MATRIX_LOAD(FUNCTION_NAME, MATRIX_TYPE, LOAD_FUNCTION) \\\nMATRIX_TYPE *FUNCTION_NAME(const char *filename, int *ret) \\\n{ \\\n    FILE *stream; \\\n    MATRIX_TYPE *M; \\\n\\\n    if((stream = fopen(filename, \"r\")) == NULL) \\\n    { \\\n        if(ret != NULL) \\\n            *ret = LIBHADES_ERROR_IO; \\\n        return NULL; \\\n    } \\\n\\\n    M = LOAD_FUNCTION(stream, ret); \\\n\\\n    fclose(stream); \\\n\\\n    return M; \\\n}\n\n/** @brief Load real matrix from file\n *\n * Load real matrix A from file given by filename. This function will also\n * allocate memory for the matrix. See \\ref matrix_load_from_stream for errors.\n *\n * @param [in] filename path to the file\n * @param [out] error error code\n * @retval A matrix\n * @retval NULL if an error occured\n */\nMATRIX_LOAD(matrix_load, matrix_t, matrix_load_from_stream);\n\n/** @brief Load complex matrix from file\n *\n * Load complex matrix A from file given by filename. This function will also\n * allocate memory for the matrix. See \\ref matrix_complex_load_from_stream for\n * errors.\n *\n * @param [in] filename path to the file\n * @param [out] error error code\n * @retval A matrix\n * @retval NULL if an error occured\n */\nMATRIX_LOAD(matrix_complex_load, matrix_complex_t, matrix_complex_load_from_stream);\n\n#define MATRIX_SAVE_TO_STREAM(FUNCTION_NAME, TYPE, MATRIX_TYPE, DTYPE) \\\nvoid FUNCTION_NAME(MATRIX_TYPE *M, FILE *stream) \\\n{ \\\n    char d_str[512] = { 0 }; \\\n    uint16_t len = 0; \\\n    const int rows = M->rows, columns = M->columns; \\\n\\\n    /* write magic string, major number and minor number */ \\\n    fwrite(\"\\x93NUMPY\\x01\\x00\", sizeof(char), 8, stream); \\\n\\\n    /* write length of header and header */ \\\n    snprintf(d_str, sizeof(d_str)/sizeof(d_str[0]), \"{'descr': '%s', 'fortran_order': True, 'shape': (%d, %d), }\", DTYPE, rows, columns); \\\n\\\n    len = strlen(d_str); \\\n\\\n    fwrite(&len,  sizeof(len),  1,   stream); \\\n    fwrite(d_str, sizeof(char), len, stream); \\\n\\\n    /* write matrix */ \\\n    fwrite(M->M, sizeof(TYPE), M->size, stream); \\\n}\n\n/** @brief Save real matrix A to stream\n *\n * Save real matrix A to a file handle given by stream. The datatype\n * corresponds to Numpy's npy file format.\n *\n * @param [in] A      matrix to be dumped to file\n * @param [in] stream file handle of opened file\n */\nMATRIX_SAVE_TO_STREAM(matrix_save_to_stream, double, matrix_t, \"<f8\");\n\n/** @brief Save complex matrix A to stream\n *\n * Save complex matrix A to a file handle given by stream. The datatype\n * corresponds to Numpy's npy file format.\n *\n * @param [in] A      matrix to be dumped to file\n * @param [in] stream file handle of opened file\n */\nMATRIX_SAVE_TO_STREAM(matrix_complex_save_to_stream, complex_t, matrix_complex_t, \"<c16\");\n\n\n#define MATRIX_SAVE(FUNCTION_NAME, MATRIX_TYPE, SAVE_FUNCTION) \\\nint FUNCTION_NAME(MATRIX_TYPE *M, const char *filename) \\\n{ \\\n    FILE *stream = fopen(filename, \"w\"); \\\n    if(stream == NULL) \\\n        return LIBHADES_ERROR_IO; \\\n\\\n    SAVE_FUNCTION(M, stream); \\\n\\\n    fclose(stream); \\\n\\\n    return 0; \\\n};\n\n/** @brief Save real matrix A to file\n *\n * Save real matrix A to file given by filename. The datatype corresponds to\n * Numpy's .npy file format.\n *\n * @param [in] A        matrix to be dumped to file\n * @param [in] filename path to the file\n * @retval 0 if successful\n * @retval LIBHADES_ERROR_IO if file could not be opened\n */\nMATRIX_SAVE(matrix_save, matrix_t, matrix_save_to_stream);\n\n/** @brief Save complex matrix A to file\n *\n * Save complex matrix A to file given by filename. The datatype corresponds to\n * Numpy's .npy file format.\n *\n * @param [in] A        matrix to be dumped to file\n * @param [in] filename path to the file\n * @retval 0 if successful\n * @retval LIBHADES_ERROR_IO if file could not be opened\n */\nMATRIX_SAVE(matrix_complex_save, matrix_complex_t, matrix_complex_save_to_stream);\n\n/** @}*/\n", "meta": {"hexsha": "7edbdeb1e6e70c973bd216748aaa683438aab435", "size": 52569, "ext": "c", "lang": "C", "max_stars_repo_path": "src/libhades.c", "max_stars_repo_name": "michael-hartmann/libhades", "max_stars_repo_head_hexsha": "81a2ab18dbf59975f8fbae0693a757b054b4501c", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2015-11-03T15:07:53.000Z", "max_stars_repo_stars_event_max_datetime": "2019-08-28T20:09:32.000Z", "max_issues_repo_path": "src/libhades.c", "max_issues_repo_name": "michael-hartmann/libhades", "max_issues_repo_head_hexsha": "81a2ab18dbf59975f8fbae0693a757b054b4501c", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/libhades.c", "max_forks_repo_name": "michael-hartmann/libhades", "max_forks_repo_head_hexsha": "81a2ab18dbf59975f8fbae0693a757b054b4501c", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.3503759398, "max_line_length": 176, "alphanum_fraction": 0.6059084251, "num_tokens": 15193, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3073580041760868, "lm_q2_score": 0.05500528442066434, "lm_q1q2_score": 0.01690631443867339}}
{"text": "/*\n * \n * \n * \n */\n\n#include <inttypes.h>\n#include <stdlib.h>\n#include <stdio.h>\n#include <assert.h>\n#include <cblas.h>\n#include <string.h> // memcpy\n#include <math.h>\n#include <stdarg.h>\n\n#include \"cgraph.h\"\n#include \"cg_operation.h\"\n#include \"cg_types.h\"\n#include \"cg_variables.h\"\n#include \"cg_errors.h\"\n#include \"cg_constants.h\"\n#include \"cg_enums.h\"\n#include \"cg_factory.h\"\n#include \"cg_math.h\"\n#include \"cg_ops.h\"\n\n\nvoid cg_assert(int cond, const char * rawcond, const char * fmt, ...)\n{\n\tif(cond)\n\t\treturn;\n\n\tchar temp[1024];\n\tva_list vl;\n\tva_start(vl, fmt);\n\tvsprintf(temp, fmt, vl);\n\tva_end(vl);\n\tfprintf(stdout, \"Fatal error, assertion failed: %s\\n\", rawcond);\n\tfprintf(stdout, temp);\n\tfprintf(stdout, \"\\n\");\n\n\texit(-1);\n}\n\n\n#define CHECK_RESULT(node) \\\nif(node->error != NULL){\\\n\treturn node;\\\n}\n\n/*\n * Works only with constant types\n */\nCGNode* copyNode(CGNode* node){\n\tCGNode* n = calloc(1, sizeof(CGNode));\n\tif(node->type != CGNT_CONSTANT){\n\t\tfprintf(stderr, \"Call to copyNode with a non-constant node.\\n... This should not happen, but who knows these days.\\n\");\n\t\tfprintf(stderr, \"copy node with nodetype = %d\\n\", node->type);\n\t\texit(-1);\n\t}\n\t\n\tn->type = CGNT_CONSTANT;\n\tn->constant = calloc(1, sizeof(CGPConstant));\n\tn->constant->type = node->constant->type;\n\tn->result = NULL;\n\tn->diff = NULL;\n\t\n\tswitch(node->constant->type){\n\t\tcase CGVT_DOUBLE: {\n\t\t\tCGDouble* d = calloc(1, sizeof(CGDouble));\n\t\t\td->value = ((CGDouble*)node->constant->value)->value;\n\t\t\t\n\t\t\tn->constant->value = d;\n\t\t\tbreak;\n\t\t}\n\t\t\n\t\tcase CGVT_VECTOR: {\n\t\t\tCGVector* V = calloc(1, sizeof(CGVector));\n\t\t\tCGVector* src = (CGVector*)node->constant->value;\n\t\t\t\n\t\t\tV->len = src->len;\n\t\t\tif(src->data != NULL) {\n\t\t\t\tV->data = calloc(V->len, sizeof(cg_float));\n\t\t\t\tmemcpy(V->data, src->data, V->len * sizeof(cg_float));\n\t\t\t}\n\n#ifdef CG_USE_OPENCL\n\t        V->buf = NULL;\n\t        V->loc = CG_DATALOC_HOST_MEM;\n#endif\n\t\t\tn->constant->value = V;\n\t\t\tbreak;\n\t\t}\n\t\t\n\t\tcase CGVT_MATRIX: {\n\t\t\tCGMatrix* M = calloc(1, sizeof(CGMatrix));\n\t\t\tCGMatrix* src = (CGMatrix*)node->constant->value;\n\t\t\t\n\t\t\tuint64_t size = src->cols * src->rows;\n\t\t\t\n\t\t\tM->rows = src->rows;\n\t\t\tM->cols = src->cols;\n\n\t\t\tif(src->data != NULL) {\n\t\t\t\tM->data = calloc(size, sizeof(cg_float));\n\t\t\t\tmemcpy(M->data, src->data, size*sizeof(cg_float));\n\t\t\t}\n\n#ifdef CG_USE_OPENCL\n\t\t\tM->buf = NULL;\n\t\t\tM->loc = CG_DATALOC_HOST_MEM;\n#endif\n\t\t\tn->constant->value = M;\n\t\t\tbreak;\n\t\t}\n\t}\n\t\n\treturn n;\n}\n\n// @Deprecated @NotUsed\nvoid* copyNodeValue(CGNode* node){\n\tif(node->type != CGNT_CONSTANT){\n\t\tfprintf(stderr, \"Call to copyNodeValue with a non-constant node.\\n... This should not happen, but who knows these days.\");\n\t\texit(-1);\n\t}\n\t\n\tswitch(node->constant->type){\n\t\tcase CGVT_DOUBLE: {\n\t\t\tCGDouble* d = calloc(1, sizeof(CGDouble));\n\t\t\td->value = ((CGDouble*)node->constant->value)->value;\n\t\t\t\n\t\t\treturn d;\n\t\t}\n\t\t\n\t\tcase CGVT_VECTOR: {\n\t\t\tCGVector* V = calloc(1, sizeof(CGVector));\n\t\t\tCGVector* src = (CGVector*)node->constant->value;\n\t\t\t\n\t\t\tV->len = src->len;\n\t\t\tV->data = calloc(V->len, sizeof(cg_float));\n\t\t\t\n\t\t\tmemcpy(V->data, src->data, V->len*sizeof(cg_float));\n\t\t\treturn V;\n\t\t}\n\t\t\n\t\tcase CGVT_MATRIX: {\n\t\t\tCGMatrix* M = calloc(1, sizeof(CGMatrix));\n\t\t\tCGMatrix* src = (CGMatrix*)node->constant->value;\n\t\t\t\n\t\t\tuint64_t size = src->cols * src->rows;\n\t\t\t\n\t\t\tM->rows = src->rows;\n\t\t\tM->cols = src->cols;\n\t\t\tM->data = calloc(size, sizeof(cg_float));\n\t\t\t\n\t\t\tmemcpy(M->data, src->data, size*sizeof(cg_float));\n\t\t\treturn M;\n\t\t}\n\t}\n}\n\n/*\n * @Deprecated\n */\nvoid* copyRNodeValue(CGResultNode* node){\n\tswitch(node->type){\n\t\tcase CGVT_DOUBLE: {\n\t\t\tCGDouble* d = calloc(1, sizeof(CGDouble));\n\t\t\td->value = ((CGDouble*)node->value)->value;\n\t\t\t\n\t\t\treturn d;\n\t\t}\n\t\t\n\t\tcase CGVT_VECTOR: {\n\t\t\tCGVector* V = calloc(1, sizeof(CGVector));\n\t\t\tCGVector* src = (CGVector*)node->value;\n\t\t\t\n\t\t\tV->len = src->len;\n\t\t\tV->data = calloc(V->len, sizeof(cg_float));\n\t\t\t\n\t\t\tmemcpy(V->data, src->data, V->len*sizeof(cg_float));\n\t\t\treturn V;\n\t\t}\n\t\t\n\t\tcase CGVT_MATRIX: {\n\t\t\tCGMatrix* M = calloc(1, sizeof(CGMatrix));\n\t\t\tCGMatrix* src = (CGMatrix*)node->value;\n\t\t\t\n\t\t\tuint64_t size = src->cols * src->rows;\n\t\t\t\n\t\t\tM->rows = src->rows;\n\t\t\tM->cols = src->cols;\n\t\t\tM->data = calloc(size, sizeof(cg_float));\n\t\t\t\n\t\t\tmemcpy(M->data, src->data, size*sizeof(cg_float));\n\t\t\treturn M;\n\t\t}\n\t}\n}\n\n\nCGResultNode* copyResultNode(CGResultNode* node){\n\tCGResultNode* res = calloc(1, sizeof(CGResultNode));\n\t\n\tswitch(node->type){\n\t\tcase CGVT_DOUBLE: {\n\t\t\tCGDouble* d = calloc(1, sizeof(CGDouble));\n\t\t\tCGDouble* d2 = (CGDouble*)node->value;\n\t\t\td->value = d2->value;\n\t\t\t\n\t\t\tres->value = d;\n\t\t\tbreak;\n\t\t}\n\t\t\n\t\tcase CGVT_VECTOR: {\n\t\t\tCGVector* V = calloc(1, sizeof(CGVector));\n\t\t\tCGVector* src = (CGVector*)node->value;\n\t\t\t\n\t\t\tV->len = src->len;\n\t\t\tV->data = calloc(V->len, sizeof(cg_float));\n\n#ifdef CG_USE_OPENCL\n\t\t\tV->buf = src->buf;\n#endif\n\t\t\tmemcpy(V->data, src->data, V->len*sizeof(cg_float));\n\t\t\t\n\t\t\tres->value = V;\n\t\t\tbreak;\n\t\t}\n\t\t\n\t\tcase CGVT_MATRIX: {\n\t\t\tCGMatrix* M = calloc(1, sizeof(CGMatrix));\n\t\t\tCGMatrix* src = (CGMatrix*)node->value;\n\t\t\t\n\t\t\tuint64_t size = src->cols * src->rows;\n\t\t\t\n\t\t\tM->rows = src->rows;\n\t\t\tM->cols = src->cols;\n\t\t\tM->data = calloc(size, sizeof(cg_float));\n#ifdef CG_USE_OPENCL\n            M->buf = src->buf;\n#endif\n\t\t\t\n\t\t\tmemcpy(M->data, src->data, size*sizeof(cg_float));\n\t\t\t\n\t\t\tres->value = M;\n\t\t\tbreak;\n\t\t}\n\t}\n\tres->type = node->type;\n\t\n\treturn res;\n}\n\nCGMatrix* vectorToMatrix(CGVector* v){\n\tCGMatrix* m = calloc(1, sizeof(CGMatrix));\n\tm->rows = v->len;\n\tm->cols = 1;\n\tm->data = v->data;\n\t\n\treturn m;\n}\n\n\n/*\n * Computational Graph traversing\n */\n\nCGResultNode* processUnaryOperation(CGraph* graph, CGUnaryOperationType type, CGNode* uhs, CGNode* parentNode){\n\tCGVarType uhsType = CGVT_DOUBLE;\n\tvoid* uhsValue = NULL;\n\tCGResultNode* newres = NULL;\n\t\n\tCGResultNode* lhsResult = computeCGNode(graph, uhs);\n\tCHECK_RESULT(lhsResult)\n\tuhsType = lhsResult->type;\n\tuhsValue = lhsResult->value;\n\t\n\tswitch(type){\n\t\tcase CGUOT_EXP:{\n\t\t\tif(uhsType == CGVT_DOUBLE){\n\t\t\t\tnewres = expD((CGDouble*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif(uhsType == CGVT_VECTOR){\n\t\t\t\tnewres = expV((CGVector*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif(uhsType == CGVT_MATRIX){\n\t\t\t\tnewres = expM((CGMatrix*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\t\n\t\tcase CGUOT_LOG:{\n\t\t\tif(uhsType == CGVT_DOUBLE){\n\t\t\t\tnewres = logD((CGDouble*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif(uhsType == CGVT_VECTOR){\n\t\t\t\tnewres = logV((CGVector*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif(uhsType == CGVT_MATRIX){\n\t\t\t\tnewres = logM((CGMatrix*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\n\t\tcase CGUOT_MINUS:{\n\t\t\tif(uhsType == CGVT_DOUBLE){\n\t\t\t\tCGDouble* rhs = calloc(1, sizeof(CGDouble));\n\t\t\t\trhs->value = -1;\n\t\t\t\t\n\t\t\t\tCGResultNode* res = mulDD((CGDouble*)uhsValue, rhs, graph, parentNode);\n\t\t\t\t\n\t\t\t\tfreeDoubleValue(rhs);\n\t\t\t\t\n\t\t\t\tparentNode->result = res;\n\t\t\t\treturn res;\n\t\t\t}\n\t\t\t\n\t\t\tif(uhsType == CGVT_VECTOR){\n\t\t\t\tCGDouble* lhs = calloc(1, sizeof(CGDouble));\n\t\t\t\tlhs->value = -1;\n\t\t\t\t\n\t\t\t\tCGResultNode* res = mulDV(lhs, (CGVector*)uhsValue, graph, parentNode);\n\t\t\t\n\t\t\t\tfree(lhs);\n\t\t\t\tparentNode->result = res;\n\t\t\t\treturn res;\n\t\t\t}\n\t\t\t\n\t\t\tif(uhsType == CGVT_MATRIX){\n\t\t\t\tCGDouble* lhs = calloc(1, sizeof(CGDouble));\n\t\t\t\tlhs->value = -1;\n\t\t\t\tCGResultNode* res = mulDM(lhs, (CGMatrix*)uhsValue, graph, parentNode);\n\t\t\t\t\n\t\t\t\tfree(lhs);\n\t\t\t\t\n\t\t\t\tparentNode->result = res;\n\t\t\t\treturn res;\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\t\n\t\tcase CGUOT_SIN:{\n\t\t\tif(uhsType == CGVT_DOUBLE){\n\t\t\t\tnewres = sinD((CGDouble*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif(uhsType == CGVT_VECTOR){\n\t\t\t\tnewres = sinV((CGVector*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif(uhsType == CGVT_MATRIX){\n\t\t\t\tnewres = sinM((CGMatrix*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\t\n\t\tcase CGUOT_COS:{\n\t\t\tif(uhsType == CGVT_DOUBLE){\n\t\t\t\tnewres = cosD((CGDouble*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif(uhsType == CGVT_VECTOR){\n\t\t\t\tnewres = cosV((CGVector*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif(uhsType == CGVT_MATRIX){\n\t\t\t\tnewres = cosM((CGMatrix*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\t\n\t\tcase CGUOT_TAN:{\n\t\t\tif(uhsType == CGVT_DOUBLE){\n\t\t\t\tnewres = tanD((CGDouble*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif(uhsType == CGVT_VECTOR){\n\t\t\t\tnewres = tanV((CGVector*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif(uhsType == CGVT_MATRIX){\n\t\t\t\tnewres = tanM((CGMatrix*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\t\n\t\tcase CGUOT_TANH:{\n\t\t\tif(uhsType == CGVT_DOUBLE){\n\t\t\t\tnewres = tanhD((CGDouble*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif(uhsType == CGVT_VECTOR){\n\t\t\t\tnewres = tanhV((CGVector*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif(uhsType == CGVT_MATRIX){\n\t\t\t\tnewres = tanhM((CGMatrix*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\t\n\t\tcase CGUOT_INV:{\n\t\t\tchar msg[MAX_ERR_FMT_LEN];\n\t\t\tsnprintf(msg, MAX_ERR_FMT_LEN, \"Operation `%s` is not implemented/supported\", getUnaryOperationTypeString(type));\n\t\t\tnewres = returnResultError(graph, CGET_OPERATION_NOT_IMPLEMENTED, parentNode, msg);\n\t\t}\n\t\t\t\n\t\tcase CGUOT_TRANSPOSE:{\n\t\t\t\n\t\t\tif(uhsType == CGVT_DOUBLE){\n\t\t\t\tnewres = transposeD((CGDouble*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif(uhsType == CGVT_VECTOR){\n\t\t\t\tnewres = transposeV((CGVector*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\t\n\t\t\tif(uhsType == CGVT_MATRIX){\n\t\t\t\tnewres = transposeM((CGMatrix*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tbreak;\n\t\t}\n\t\n\t\tcase CGUOT_RELU:{\n\t\t\tif(uhsType == CGVT_DOUBLE){\n\t\t\t\tnewres = reluD((CGDouble*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\n\t\t\tif(uhsType == CGVT_VECTOR){\n\t\t\t\tnewres = reluV((CGVector*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\n\n\t\t\tif(uhsType == CGVT_MATRIX){\n\t\t\t\tnewres = reluM((CGMatrix*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\n\t\t\tbreak;\n\t\t}\n\n        case CGUOT_SOFTPLUS:{\n\t\t\tif(uhsType == CGVT_DOUBLE){\n\t\t\t\tnewres = softplusD((CGDouble*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\n\t\t\tif(uhsType == CGVT_VECTOR){\n\t\t\t\tnewres = softplusV((CGVector*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\n\n\t\t\tif(uhsType == CGVT_MATRIX){\n\t\t\t\tnewres = softplusM((CGMatrix*)uhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\n\t\t\tbreak;\n        }\n\t}\n\tchar msg[MAX_ERR_FMT_LEN];\n\tsnprintf(msg, MAX_ERR_FMT_LEN, \"Operation [%s %s] cannot be applied\", getVariableTypeString(uhsType), getUnaryOperationTypeString(type));\n\tnewres = returnResultError(graph, CGET_INCOMPATIBLE_ARGS_EXCEPTION, parentNode, msg);\n\treturn newres;\n}\n\nCGResultNode* processBinaryOperation(CGraph* graph, CGBinaryOperationType type, CGNode* lhs, CGNode* rhs, CGNode* parentNode){\n\tCGVarType lhsType = CGVT_DOUBLE;\n\tCGVarType rhsType = CGVT_DOUBLE;\n\tCGResultNode* newres = NULL;\n\tvoid* lhsValue = NULL;\n\tvoid* rhsValue = NULL;\n\t\n\tCGResultNode* lhsResult = computeCGNode(graph, lhs);\n\tCHECK_RESULT(lhsResult)\n\tlhsType = lhsResult->type;\n\tlhsValue = lhsResult->value;\n\t\t\n\tCGResultNode* rhsResult = computeCGNode(graph, rhs);\n\tCHECK_RESULT(rhsResult)\n\trhsType = rhsResult->type;\n\trhsValue = rhsResult->value;\n\t\n\tswitch(type){\n\t\tcase CGBOT_ADD:{\n\t\t\tif((lhsType == CGVT_DOUBLE) && (rhsType == CGVT_DOUBLE)){\n\t\t\t\tnewres = addDD((CGDouble*)lhsValue, (CGDouble*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_VECTOR) && (rhsType == CGVT_DOUBLE)){\n\t\t\t\tnewres = addVD((CGVector*)lhsValue, (CGDouble*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\t\n\t\t\tif((lhsType == CGVT_DOUBLE) && (rhsType == CGVT_VECTOR)){\n\t\t\t\tnewres = addVD((CGVector*)rhsValue, (CGDouble*)lhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_MATRIX) && (rhsType == CGVT_DOUBLE)){\n\t\t\t\tnewres = addMD((CGMatrix*)lhsValue, (CGDouble*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_DOUBLE) && (rhsType == CGVT_MATRIX)){\n\t\t\t\tnewres = addMD((CGMatrix*)rhsValue, (CGDouble*)lhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_VECTOR) && (rhsType == CGVT_VECTOR)){\n\t\t\t\tnewres = addVV((CGVector*)lhsValue, (CGVector*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_MATRIX) && (rhsType == CGVT_VECTOR)){\n\t\t\t\tnewres = addMV((CGMatrix*)lhsValue, (CGVector*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_VECTOR) && (rhsType == CGVT_MATRIX)){\n\t\t\t\tnewres = addMV((CGMatrix*)rhsValue, (CGVector*)lhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_MATRIX) && (rhsType == CGVT_MATRIX)){\n\t\t\t\tnewres = addMM((CGMatrix*)lhsValue, (CGMatrix*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\t\n\t\tcase CGBOT_SUB:{\n\t\t\tif((lhsType == CGVT_DOUBLE) && (rhsType == CGVT_DOUBLE)){\n\t\t\t\tnewres = subDD((CGDouble*)lhsValue, (CGDouble*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_VECTOR) && (rhsType == CGVT_DOUBLE)){\n\t\t\t\tnewres = subVD((CGVector*)lhsValue, (CGDouble*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_DOUBLE) && (rhsType == CGVT_VECTOR)){\n\t\t\t\tnewres = subDV((CGDouble*)lhsValue, (CGVector*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_MATRIX) && (rhsType == CGVT_DOUBLE)){\n\t\t\t\tnewres = subMD((CGMatrix*)lhsValue, (CGDouble*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_DOUBLE) && (rhsType == CGVT_MATRIX)){\n\t\t\t\tnewres = subDM((CGDouble*)lhsValue, (CGMatrix*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_VECTOR) && (rhsType == CGVT_VECTOR)){\n\t\t\t\tnewres = subVV((CGVector*)lhsValue, (CGVector*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_MATRIX) && (rhsType == CGVT_MATRIX)){\n\t\t\t\tnewres = subMM((CGMatrix*)lhsValue, (CGMatrix*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_MATRIX) && (rhsType == CGVT_VECTOR)){\n\t\t\t\tnewres = subMV((CGMatrix*)lhsValue, (CGVector*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_VECTOR) && (rhsType == CGVT_MATRIX)){\n\t\t\t\tnewres = subVM((CGVector*)lhsValue, (CGMatrix*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\t\n\t\tcase CGBOT_DIV:{\n\t\t\tif((lhsType == CGVT_DOUBLE) && (rhsType == CGVT_DOUBLE)){\n\t\t\t\tnewres = divDD((CGDouble*)lhsValue, (CGDouble*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_VECTOR) && (rhsType == CGVT_DOUBLE)){\n\t\t\t\tnewres = divVD((CGVector*)lhsValue, (CGDouble*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_DOUBLE) && (rhsType == CGVT_VECTOR)){\n\t\t\t\tnewres = divDV((CGDouble*)lhsValue, (CGVector*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_VECTOR) && (rhsType == CGVT_VECTOR)){\n\t\t\t\tnewres = divVV((CGVector*)lhsValue, (CGVector*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_MATRIX) && (rhsType == CGVT_DOUBLE)){\n\t\t\t\tnewres = divMD((CGMatrix*)lhsValue, (CGDouble*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_MATRIX) && (rhsType == CGVT_VECTOR)){\n\t\t\t\tnewres = divMV((CGMatrix*)lhsValue, (CGVector*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_DOUBLE) && (rhsType == CGVT_MATRIX)){\n\t\t\t\tnewres = divDM((CGDouble*)lhsValue, (CGMatrix*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tbreak;\n\t\t}\n\t\t\n\t\tcase CGBOT_MULT:{\n\t\t\t// TODO: update\n\t\t\tif((lhsType == CGVT_MATRIX) && (rhsType == CGVT_MATRIX)){\n\t\t\t\tnewres = mulMM((CGMatrix*)lhsValue, (CGMatrix*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\t// TODO: update\n\t\t\tif((lhsType == CGVT_MATRIX) && (rhsType == CGVT_VECTOR)){\n\t\t\t\tnewres = mulMV((CGMatrix*)lhsValue, (CGVector*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\t// TODO: update\n\t\t\tif((lhsType == CGVT_VECTOR) && (rhsType == CGVT_MATRIX)){\n\t\t\t\tnewres = mulMV((CGMatrix*)rhsValue, (CGVector*)lhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_DOUBLE) && (rhsType == CGVT_DOUBLE)){\n\t\t\t\tnewres = mulDD((CGDouble*)lhsValue, (CGDouble*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_DOUBLE) && (rhsType == CGVT_VECTOR)){\n\t\t\t\tnewres = mulDV((CGDouble*)lhsValue, (CGVector*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_VECTOR) && (rhsType == CGVT_DOUBLE)){\n\t\t\t\tnewres = mulDV((CGDouble*)rhsValue, (CGVector*)lhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_DOUBLE) && (rhsType == CGVT_MATRIX)){\n\t\t\t\tnewres = mulDM((CGDouble*)lhsValue, (CGMatrix*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_MATRIX) && (rhsType == CGVT_DOUBLE)){\n\t\t\t\tnewres = mulDM((CGDouble*)rhsValue, (CGMatrix*)lhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_VECTOR) && (rhsType == CGVT_VECTOR)){\n\t\t\t\tnewres = crossVV((CGVector*)rhsValue, (CGVector*)lhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\t\n\t\tcase CGBOT_POW:{\n\t\t\tif((lhsType == CGVT_DOUBLE) && (rhsType == CGVT_DOUBLE)){\n\t\t\t\tnewres = powDD((CGDouble*)lhsValue, (CGDouble*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_VECTOR) && (rhsType == CGVT_DOUBLE)){\n\t\t\t\tnewres = powVD((CGVector*)lhsValue, (CGDouble*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_MATRIX) && (rhsType == CGVT_DOUBLE)){\n\t\t\t\tnewres = powMD((CGMatrix*)lhsValue, (CGDouble*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\t\n\t\tcase CGBOT_DOT: {\n\t\t\t/*\n\t\t\t * The following are the same as MUL\n\t\t\t */\n\t\t\tif((lhsType == CGVT_DOUBLE) && (rhsType == CGVT_DOUBLE)){\n\t\t\t\tnewres = mulDD((CGDouble*)lhsValue, (CGDouble*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_DOUBLE) && (rhsType == CGVT_VECTOR)){\n\t\t\t\tnewres = mulDV((CGDouble*)lhsValue, (CGVector*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_VECTOR) && (rhsType == CGVT_DOUBLE)){\n\t\t\t\tnewres = mulDV((CGDouble*)rhsValue, (CGVector*)lhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_DOUBLE) && (rhsType == CGVT_MATRIX)){\n\t\t\t\tnewres = mulDM((CGDouble*)lhsValue, (CGMatrix*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_MATRIX) && (rhsType == CGVT_DOUBLE)){\n\t\t\t\tnewres = mulDM((CGDouble*)rhsValue, (CGMatrix*)lhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\t/* here starts dot specific impl */\n\t\t\t\n\t\t\t\n\t\t\tif((lhsType == CGVT_MATRIX) && (rhsType == CGVT_MATRIX)){\n\t\t\t\tnewres = dotMM((CGMatrix*)lhsValue, (CGMatrix*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_MATRIX) && (rhsType == CGVT_VECTOR)){\n\t\t\t\tnewres = dotMV((CGMatrix*)lhsValue, (CGVector*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\tif((lhsType == CGVT_VECTOR) && (rhsType == CGVT_MATRIX)){\n\t\t\t\tnewres = dotVM((CGVector*)lhsValue, (CGMatrix*)rhsValue, graph, parentNode);\n\t\t\t\t//newres = dotMM(vectorToMatrix((CGVector*)lhsValue), (CGMatrix*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t\n\t\t\t/*\n\t\t\tif((lhsType == CGVT_VECTOR) && (rhsType == CGVT_MATRIX)){\n\t\t\t\tnewres = mulMV((CGMatrix*)rhsValue, (CGVector*)lhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\t*/\n\t\t\t\n\t\t\tif((lhsType == CGVT_VECTOR) && (rhsType == CGVT_VECTOR)){\n\t\t\t\tnewres = dotVV((CGVector*)lhsValue, (CGVector*)rhsValue, graph, parentNode);\n\t\t\t\tparentNode->result = newres;\n\t\t\t\treturn newres;\n\t\t\t}\n\t\t\tbreak;\n\t\t}\n\t\t\n\t\tcase CGBOT_TMULT:{\n\t\t\tchar msg[MAX_ERR_FMT_LEN];\n\t\t\tsnprintf(msg, MAX_ERR_FMT_LEN, \"Operation `%s` is not implemented/supported\", getBinaryOperationTypeString(type));\n\t\t\treturn returnResultError(graph, CGET_OPERATION_NOT_IMPLEMENTED, parentNode, msg);\n\t\t}\n\t}\n\t\n\tchar msg[MAX_ERR_FMT_LEN];\n\tsnprintf(msg, MAX_ERR_FMT_LEN, \"Operation [%s %s %s] cannot be applied\", getVariableTypeString(lhsType), getBinaryOperationTypeString(type), getVariableTypeString(rhsType));\n\treturn returnResultError(graph, CGET_INCOMPATIBLE_ARGS_EXCEPTION, parentNode, msg);\n}\n\nCGResultNode* computeRawNode(CGNode* node){\n\tCGraph* tmp_G = makeGraph(\"temp_g\");\n\t\n\ttmp_G->root = node;\n\tstoreNodesInGraph(tmp_G, node);\n\t\n\tCGResultNode* res = computeGraph(tmp_G);\n\tres = copyResultNode(res);\n\tfreeGraph(tmp_G);\n\tfree(tmp_G);\n\t\n\treturn res;\n}\n\n\nCGResultNode* computeCGNode(CGraph* graph, CGNode* node){\n\tCGResultNode* result = NULL;\n\t\n\tif(node->result != NULL){\n\t\treturn node->result;\n\t}\n\t\n\tswitch(node->type){\n\t\tcase CGNT_CONSTANT:{\n\t\t\tresult = constantNodeToResultNodeCopy(node);\n\t\t\tbreak;\n\t\t}\n\n\t\tcase CGNT_VARIABLE:{\n\t\t\tif(graph == NULL)\n\t\t\t{\n\t\t\t\tchar msg[MAX_ERR_FMT_LEN];\n\t\t\t\tsnprintf(msg, MAX_ERR_FMT_LEN, \"Cannot compute variable`%s` without the graph instance\", node->var->name);\n\t\t\t\treturn returnResultError(graph, CGET_NO_GRAPH_INSTANCE, node, msg);\n\t\t\t}\n\t\t\t\n\t\t\t\n\t\t\tCGNode* constantNode = *map_get(&graph->vars, node->var->name);\n\t\t\tif(constantNode == NULL)\n\t\t\t{\n\t\t\t\tchar msg[MAX_ERR_FMT_LEN];\n\t\t\t\tsnprintf(msg, MAX_ERR_FMT_LEN, \"No variable `%s` was found in graph `%s`\", node->var->name, graph!=NULL?graph->name:\"[anonymous]\");\n\t\t\t\treturn returnResultError(graph, CGET_VARIABLE_DOES_NOT_EXIST, node, msg);\n\t\t\t}\n\t\t\t\n\t\t\tCGResultNode* rnode = computeCGNode(graph, constantNode);\n\t\t\tCHECK_RESULT(rnode)\n\t\t\tconstantNode->result = rnode;\n\t\t\tnode->result = copyResultNode(rnode);\n\t\t\t\n\t\t\tresult = node->result;\n\t\t\tbreak;\n\t\t}\n\t\tcase CGNT_BINARY_OPERATION:\n\t\t\tresult = processBinaryOperation(graph, node->bop->type, node->bop->lhs, node->bop->rhs, node);\n\t\t\tbreak;\n\t\tcase CGNT_UNARY_OPERATION:\n\t\t\tresult = processUnaryOperation(graph, node->uop->type, node->uop->uhs, node);\n\t\t\tbreak;\n\t\t\n\t\t/* \n\t\t * TODO: add this test to unittest\n\t\t */\n\t\tcase CGNT_AXIS_BOUND_OPERATION:\n\t\t{\n            //CGResultNode* res = computeCGNode(graph, node->axop->uhs);\n\n\t\t\tswitch(node->axop->type){\n\t\t\t\tcase CGABOT_SUM:{\n\t\t\t\t\tCGResultNode* newres = computeCGNode(graph, node->axop->uhs);\n\t\t\t\t\tCHECK_RESULT(newres)\n\n\t\t\t\t\tif(newres->type == CGVT_DOUBLE){\n\t\t\t\t\t\tresult = sumD((CGDouble*)newres->value, graph, node);\n\t\t\t\t\t}\n\n\t\t\t\t\tif(newres->type == CGVT_VECTOR){\n\t\t\t\t\t\tresult = sumV((CGVector*)newres->value, graph, node);\n\t\t\t\t\t}\n\n\t\t\t\t\tif(newres->type == CGVT_MATRIX){\n\t\t\t\t\t\tresult = sumM((CGMatrix*)newres->value, graph, node, node->axop->axis);\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tcase CGABOT_MAX:{\n\t\t\t\t\tresult = max(node, graph);\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tcase CGABOT_MIN:{\n\t\t\t\t\tresult = min(node, graph);\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tcase CGABOT_MEAN:{\n\t\t\t\t\tresult = mean(node, graph);\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tcase CGABOT_SOFTMAX:{\n\t\t\t\t\tchar msg[MAX_ERR_FMT_LEN];\n\t\t\t\t\tsnprintf(msg, MAX_ERR_FMT_LEN, \"Operation [CGABOT_SOFTMAX] is not implemented/supported\");\n\t\t\t\t\treturn returnResultError(graph, CGET_OPERATION_NOT_IMPLEMENTED, node, msg);\n\t\t\t\t\t//CGResultNode* res = computeCGNode(graph, node->axop->uhs);\n\t\t\t\t\t//break;\n\t\t\t\t}\n\n\t\t\t\tcase CGABOT_ARGMAX:{\n\t\t\t\t    result = argmax(node, graph);\n                    break;\n\t\t\t\t}\n\n                case CGABOT_ARGMIN:{\n                    result = argmin(node, graph);\n                    break;\n                }\n\n\t\t\t\tdefault:\n\t\t\t\t    break;\n\t\t\t}\n\n\t\t\tbreak;\n\t\t}\n\t\tcase CGNT_GRAPH:{\n\t\t\tresult = computeGraph(node->graph);\n\t\t\tbreak;\n\t\t\t/*\n\t\t\tchar msg[MAX_ERR_FMT_LEN];\n\t\t\tsnprintf(msg, MAX_ERR_FMT_LEN, \"Operation [GRAPH] is not implemented/supported\");\n\t\t\treturn returnResultError(graph, CGET_OPERATION_NOT_IMPLEMENTED, node, msg);\n\t\t\t*/\n\t\t}\n\t\t\n\t\tcase CGNT_CROSS_ENTROPY_LOSS_FUNC:\n\t\t{\n\t\t\tCGResultNode* X_res = computeCGNode(graph, node->crossEntropyLoss->x);\n\t\t\tCGNode* X = resultNodeToConstantNodeCopy(X_res);\n\t\t\n\t\t\tCGNode* X_val = softmax_node(X);\n\t\t\t\n\t\t\t\t\t\t\n\t\t\tCGResultNode* x_res = computeRawNode(X_val);\n\n\t\t\tCGResultNode* y_res = computeCGNode(graph, node->crossEntropyLoss->y);\n\t\t\t\n\t\t\tresult = crossEntropy(x_res, y_res, node->crossEntropyLoss->num_classes);\n\t\t\t\n\t\t\tfreeResultNode(x_res);\n\t\t\tfree(x_res);\n\t\t\tbreak;\n\t\t}\n\t}\n\t\n\tnode->result = reduceDim(result);\n\t\n\t\n\tif(node->diff == NULL)\n\t\tswitch(node->result->type){\n\t\t\tcase CGVT_DOUBLE:\n\t\t\t\tnode->diff = makeZeroDoubleConstantNode();\n\t\t\t\tbreak;\n\t\t\tcase CGVT_VECTOR:{\n\t\t\t\tCGVector* v = (CGVector*)node->result ->value;\n\t\t\t\tnode->diff = makeZeroVectorConstantNode(v->len);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\t\n\t\t\tcase CGVT_MATRIX:{\n\t\t\t\tCGMatrix* v = (CGMatrix*)node->result ->value;\n\t\t\t\tnode->diff = makeZeroMatrixConstantNode(v->rows, v->cols);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\n\treturn node->result;\n}\n\nCGResultNode* reduceDim(CGResultNode* result){\n    //return result;\n\n\tswitch(result->type){\n\t\tcase CGVT_DOUBLE:{\n\t\t\treturn result;\n\t\t}\n\t\t\n\t\tcase CGVT_VECTOR:{\n\t\t\tCGVector* vec = (CGVector*)result->value;\n\t\t\tif (vec->len > 1)\n\t\t\t\treturn result;\n\n#ifdef CG_USE_OPENCL\n\t\t\tcopyDataToHost(result);\n#endif\n\t\t\t\n\t\t\tCGDouble* d = calloc(1, sizeof(CGDouble));\n\t\t\td->value = vec->data[0];\n\t\t\t\n\t\t\tfreeVectorValue(result->value);\n\t\t\tfree(result->value);\n\t\t\t\n\t\t\tresult->type = CGVT_DOUBLE;\n\t\t\tresult->value = d;\n\t\t\t\n\t\t\treturn result;\n\t\t}\n\t\t\n\t\tcase CGVT_MATRIX:{\n\t\t\tCGMatrix* mat = (CGMatrix*)result->value;\n\t\t\t\n\t\t\tif((mat->rows>1) &&(mat->cols>1))\n\t\t\t\treturn result;\n\t\t\t\n\t\t\tif((mat->rows == 1) && (mat->cols == 1)){\n                copyDataToHost(result);\n\n\t\t\t\tCGDouble* d = calloc(1, sizeof(CGDouble));\n\t\t\t\td->value = mat->data[0];\n\t\t\t\t\n\t\t\t\t\n\t\t\t\tfreeMatrixValue(result->value);\n\t\t\t\tfree(result->value);\n\t\t\t\t\n\t\t\t\tresult->type = CGVT_DOUBLE;\n\t\t\t\tresult->value = d;\n\t\t\t\t\n\t\t\t\treturn result;\n\t\t\t}\n\t\t\t\n\t\t\tif(mat->rows == 1){\n\t\t\t\tCGVector* vec = calloc(1, sizeof(CGVector));\n\t\t\t\tvec->len = mat->cols;\n\t\t\t\tvec->data = mat->data;\n\t\t\t\t//TODO: Memory leak here\n#ifdef CG_USE_OPENCL\n\t\t\t\tvec->buf = mat->buf;\n#endif\n\t\t\t\t\n\t\t\t\t//freeMatrixValue(result->value);\n\t\t\t\tfree(result->value);\n\t\t\t\t\n\t\t\t\tresult->type = CGVT_VECTOR;\n\t\t\t\tresult->value = vec;\n\t\t\t\t\n\t\t\t\treturn result;\n\t\t\t}\n\t\t\t\n\t\t\treturn result;\n\t\t}\n\t}\n}\n\nCGResultNode* computeGraph(CGraph* graph){\n\tresetGraphResultNodes(graph, graph->root);\n\tCGResultNode* res = computeCGNode(graph, graph->root);\n\tcopyDataToHost(res);\n\n\treturn res;\n}\n\nCGResultNode* computeGraphNode(CGraph* graph, CGNode* node){\n\tstoreNodesInGraph(graph, node);\n\tresetGraphResultNodes(graph, node);\n\treturn computeCGNode(graph, node);\n}\n\n\nvoid storeNodesInGraph(CGraph* graph, CGNode* node){\n\tint idx = -1;\n\t\n\tvec_find(&graph->nodes, node, idx);\n\t\n\tif(idx != -1)\n\t\treturn;\n\t\n\tvec_push(&graph->nodes, node);\n\t\n\t\n\tswitch(node->type){\n\t\tcase CGNT_CONSTANT:\n\t\t\tbreak;\n\t\tcase CGNT_VARIABLE:\n\t\t\tbreak;\n\t\tcase CGNT_BINARY_OPERATION:\n\t\t\tstoreNodesInGraph(graph, node->bop->lhs);\n\t\t\tstoreNodesInGraph(graph, node->bop->rhs);\n\t\t\tbreak;\n\t\tcase CGNT_UNARY_OPERATION:\n\t\t\tstoreNodesInGraph(graph, node->uop->uhs);\n\t\t\tbreak;\n\t\tcase CGNT_AXIS_BOUND_OPERATION:\n\t\t\tstoreNodesInGraph(graph, node->axop->uhs);\n\t\t\tbreak;\n\t\tcase CGNT_GRAPH:\n\t\t\tstoreNodesInGraph(graph, node->graph->root);\n\t\t\tbreak;\n\t\tcase CGNT_CROSS_ENTROPY_LOSS_FUNC:\n\t\t\tstoreNodesInGraph(graph, node->crossEntropyLoss->x);\n\t\t\tstoreNodesInGraph(graph, node->crossEntropyLoss->y);\n\t\t\tbreak;\n\t}\n}\n\nvoid resetGraphResultNodes(CGraph* graph, CGNode* node){\n\tif(node->result != NULL){\n\t\tfreeResultNode(node->result);\n\t\tfree(node->result);\n\t\tnode->result = NULL;\n\t}\n\t\n\tif(node->diff != NULL){\n\t\tfreeNode(graph, node->diff);\n\t\tfree(node->diff);\n\t\tnode->diff = NULL;\n\t}\n\t\n\tswitch(node->type){\n\t\tcase CGNT_CONSTANT:\n\t\t\tbreak;\n\t\tcase CGNT_VARIABLE:{\n\t\t\tCGNode* var = graphGetVar(graph, node->var->name);\n\t\t\tif(var != NULL)\n\t\t\t\tresetGraphResultNodes(graph, var);\n\t\t\tbreak;\n\t\t}\n\t\tcase CGNT_BINARY_OPERATION:\n\t\t\tresetGraphResultNodes(graph, node->bop->lhs);\n\t\t\tresetGraphResultNodes(graph, node->bop->rhs);\n\t\t\tbreak;\n\t\tcase CGNT_UNARY_OPERATION:\n\t\t\tresetGraphResultNodes(graph, node->uop->uhs);\n\t\t\tbreak;\n\t\tcase CGNT_AXIS_BOUND_OPERATION:\n\t\t\tresetGraphResultNodes(graph, node->axop->uhs);\n\t\t\tbreak;\n\t\tcase CGNT_GRAPH:\n\t\t\tresetGraphResultNodes(graph, node->graph->root);\n\t\t\tbreak;\n\t\tcase CGNT_CROSS_ENTROPY_LOSS_FUNC:\n\t\t\tresetGraphResultNodes(graph, node->crossEntropyLoss->x);\n\t\t\tresetGraphResultNodes(graph, node->crossEntropyLoss->y);\n\t\t\tbreak;\n\t}\n}\n\n\nvoid graphSetVar_lua(CGraph* graph, const char* name, CGNode* value){\n\tCGNode** old = map_get(&graph->vars, name); \n\tif(old != NULL){\n\t\t//freeNode(graph, *old);\n\t\tmap_remove(&graph->vars, name);\n\t}\n\t\n\tint res = map_set(&graph->vars, name, value);\n}\n", "meta": {"hexsha": "3bce30b8ef797fe056ec696a66b1d0ccdb857bfd", "size": 31035, "ext": "c", "lang": "C", "max_stars_repo_path": "source/libcgraph/source/cgraph.c", "max_stars_repo_name": "Enehcruon/cgraph", "max_stars_repo_head_hexsha": "cc12d6e195d0d260584e1d4bc822bcc34d24a9af", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 8.0, "max_stars_repo_stars_event_min_datetime": "2018-01-29T17:55:57.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-28T03:25:53.000Z", "max_issues_repo_path": "source/libcgraph/source/cgraph.c", "max_issues_repo_name": "Enehcruon/cgraph", "max_issues_repo_head_hexsha": "cc12d6e195d0d260584e1d4bc822bcc34d24a9af", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 27.0, "max_issues_repo_issues_event_min_datetime": "2018-01-22T18:39:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-03-08T12:27:17.000Z", "max_forks_repo_path": "source/libcgraph/source/cgraph.c", "max_forks_repo_name": "praisethemoon/ccgraph", "max_forks_repo_head_hexsha": "ff5ff885dcddc19cfe1c6a21550a39c19684680f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2019-02-26T13:55:26.000Z", "max_forks_repo_forks_event_max_datetime": "2019-07-21T05:16:24.000Z", "avg_line_length": 25.293398533, "max_line_length": 174, "alphanum_fraction": 0.6425326245, "num_tokens": 9223, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.45326186278634367, "lm_q2_score": 0.03676946686724094, "lm_q1q2_score": 0.016666197045906373}}
{"text": "/* monte/gsl_monte_plain.h\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Michael Booth\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Plain Monte-Carlo. */\n\n/* Author: MJB */\n\n#ifndef __GSL_MONTE_PLAIN_H__\n#define __GSL_MONTE_PLAIN_H__\n\n#if !defined( GSL_FUN )\n#  if !defined( GSL_DLL )\n#    define GSL_FUN extern\n#  elif defined( BUILD_GSL_DLL )\n#    define GSL_FUN extern __declspec(dllexport)\n#  else\n#    define GSL_FUN extern __declspec(dllimport)\n#  endif\n#endif\n\n#include <stdio.h>\n#include <gsl/gsl_monte.h>\n#include <gsl/gsl_rng.h>\n\n#undef __BEGIN_DECLS\n#undef __END_DECLS\n#ifdef __cplusplus\n# define __BEGIN_DECLS extern \"C\" {\n# define __END_DECLS }\n#else\n# define __BEGIN_DECLS /* empty */\n# define __END_DECLS /* empty */\n#endif\n\n__BEGIN_DECLS\n\ntypedef struct {\n  size_t dim;\n  double *x;\n} gsl_monte_plain_state;\n\nGSL_FUN int\ngsl_monte_plain_integrate (const gsl_monte_function * f,\n                           const double xl[], const double xu[],\n                           const size_t dim,\n                           const size_t calls, \n                           gsl_rng * r,\n                           gsl_monte_plain_state * state,\n                           double *result, double *abserr);\n\nGSL_FUN gsl_monte_plain_state* gsl_monte_plain_alloc(size_t dim);\n\nGSL_FUN int gsl_monte_plain_init(gsl_monte_plain_state* state);\n\nGSL_FUN void gsl_monte_plain_free (gsl_monte_plain_state* state);\n\n__END_DECLS\n\n#endif /* __GSL_MONTE_PLAIN_H__ */\n", "meta": {"hexsha": "a62879650bc67801f863cb9c46c93ab9de484c42", "size": 2149, "ext": "h", "lang": "C", "max_stars_repo_path": "Chimera/3rd_Party/GSL_MSVC/gsl/gsl_monte_plain.h", "max_stars_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_stars_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-09-28T08:20:20.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-28T08:20:20.000Z", "max_issues_repo_path": "Chimera/3rd_Party/GSL_MSVC/gsl/gsl_monte_plain.h", "max_issues_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_issues_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chimera/3rd_Party/GSL_MSVC/gsl/gsl_monte_plain.h", "max_forks_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_forks_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-10-14T12:45:35.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-14T12:45:35.000Z", "avg_line_length": 28.2763157895, "max_line_length": 81, "alphanum_fraction": 0.6942764076, "num_tokens": 541, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.35936413143782797, "lm_q2_score": 0.046033901581263824, "lm_q1q2_score": 0.01654293305844533}}
{"text": "///\n/// @file\n///\n/// @author Mirko Myllykoski (mirkom@cs.umu.se), Umeå University\n///\n/// @internal LICENSE\n///\n/// Copyright (c) 2019-2020, Umeå Universitet\n///\n/// Redistribution and use in source and binary forms, with or without\n/// modification, are permitted provided that the following conditions are met:\n///\n/// 1. Redistributions of source code must retain the above copyright notice,\n///    this list of conditions and the following disclaimer.\n///\n/// 2. Redistributions in binary form must reproduce the above copyright notice,\n///    this list of conditions and the following disclaimer in the documentation\n///    and/or other materials provided with the distribution.\n///\n/// 3. Neither the name of the copyright holder nor the names of its\n///    contributors may be used to endorse or promote products derived from this\n///    software without specific prior written permission.\n///\n/// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n/// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n/// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n/// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n/// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n/// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n/// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n/// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n/// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n/// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n/// POSSIBILITY OF SUCH DAMAGE.\n///\n\n#include <starneig_config.h>\n#include <starneig/configuration.h>\n#include \"cpu.h\"\n#include \"../common/common.h\"\n#include \"../common/sanity.h\"\n#include \"../common/tiles.h\"\n#include \"../common/trace.h\"\n#include <starpu.h>\n#include <starpu_scheduler.h>\n#include <hwloc.h>\n#include <cblas.h>\n#include <omp.h>\n\nvoid starneig_hessenberg_cpu_prepare_column(\n    void *buffers[], void *cl_args)\n{\n    // LAPACK subroutine that generates a real elementary reflector H\n    extern void dlarfg_(int const *, double *, double *, int const *, double *);\n\n    int i; // the index of the currect column inside the panel\n    struct range_packing_info v_pi;\n    starpu_codelet_unpack_args(cl_args, &i, &v_pi);\n\n    int k = 0;\n\n    double *Y = NULL; int ldY = 0;\n    if (0 < i) {\n        Y = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n        ldY = STARPU_MATRIX_GET_LD(buffers[k]);\n        k++;\n    }\n\n    double *V = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n    int ldV = STARPU_MATRIX_GET_LD(buffers[k]);\n    int m = STARPU_MATRIX_GET_NX(buffers[k]);\n    int nb = STARPU_MATRIX_GET_NY(buffers[k]);\n    k++;\n\n    double *T = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n    int ldT = STARPU_MATRIX_GET_LD(buffers[k]);\n    k++;\n\n    double *P = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n    int ldP = STARPU_MATRIX_GET_LD(buffers[k]);\n    k++;\n\n    // an intemediate vector interface for the trailing matrix operation\n    struct starpu_vector_interface **v_i =\n        (struct starpu_vector_interface **)buffers + k;\n    k += v_pi.handles;\n\n    // current column\n    double *p = P+i*ldP;\n\n    //\n    // update the current column\n    //\n\n    if (0 < i) {\n\n        // A <- A - Y * V' (update column from the right)\n        cblas_dgemv(CblasColMajor, CblasNoTrans, m, i,\n            -1.0, Y, ldY, V+i-1, ldV, 1.0, p, 1);\n\n        //\n        // update column from the left\n        //\n\n        // we use the last column of T as a work space\n        double *w = T+(nb-1)*ldT;\n\n        // w <- V1' * b1 (upper part)\n        cblas_dcopy(i, p, 1, w, 1);\n        cblas_dtrmv(\n            CblasColMajor, CblasLower, CblasTrans, CblasUnit, i, V, ldV, w, 1);\n\n        // w <- w + V2' * b2 (lower part)\n        cblas_dgemv(CblasColMajor, CblasTrans, m-i, i,\n            1.0, V+i, ldV, p+i, 1, 1.0, w, 1);\n\n        // w <- T' * w\n        cblas_dtrmv(\n            CblasColMajor, CblasUpper, CblasTrans, CblasNonUnit, i,\n            T, ldT, w, 1);\n\n        // b2 <- b2 - V2 * w\n        cblas_dgemv(CblasColMajor, CblasNoTrans, m-i, i,\n            -1.0, V+i, ldV, w, 1, 1.0, p+i, 1);\n\n        // b1 <- b1 - V1 * w\n        cblas_dtrmv(\n            CblasColMajor, CblasLower, CblasNoTrans, CblasUnit, i,\n            V, ldV, w, 1);\n        cblas_daxpy(i, -1.0, w, 1, p, 1);\n    }\n\n    //\n    // compute the current unit vector\n    //\n\n    int height = m-i;\n    double tau, *v = V+i*ldV+i;\n    memcpy(v, p+i, height*sizeof(double));\n    dlarfg_(&height, p+i, v+1, (const int[]){1}, &tau);\n    v[0] = 1.0;\n\n    //\n    // copy the current unit vector to the intemediate vector interface\n    //\n\n    starneig_join_range(&v_pi, v_i, v, 1);\n\n    //\n    // set elements below the subdiagonal to zero\n    //\n\n    for (int j = i+1; j < m; j++)\n        p[j] = 0.0;\n\n    //\n    // store tau for future use\n    //\n\n    T[i*ldT+i] = tau;\n}\n\nvoid starneig_hessenberg_cpu_compute_column(\n    void *buffers[], void *cl_args)\n{\n    struct packing_info A_pi;\n    struct range_packing_info v_pi, y_pi;\n    starpu_codelet_unpack_args(cl_args, &A_pi, &v_pi, &y_pi);\n\n    STARNEIG_EVENT_BEGIN(&A_pi, starneig_event_red);\n\n    int k = 0;\n\n    // involved trailing matrix tiles\n    struct starpu_matrix_interface **A_i =\n        (struct starpu_matrix_interface **)buffers + k;\n    k += A_pi.handles;\n\n    // intemediate vector interface for the trailing matrix operation\n    struct starpu_vector_interface **v_i =\n        (struct starpu_vector_interface **)buffers + k;\n    k += v_pi.handles;\n\n    // intemediate vector interface from the trailing matrix operation\n    struct starpu_vector_interface **y_i =\n        (struct starpu_vector_interface **)buffers + k;\n    k += y_pi.handles;\n\n    int t_rows = (A_pi.rend-1) / A_pi.bm + 1 - (A_pi.rbegin-1) / A_pi.bm;\n    int t_cols = (A_pi.cend-1) / A_pi.bn + 1 - (A_pi.cbegin-1) / A_pi.bn;\n\n    //\n    // loop oper tile rows\n    //\n\n    for (int i = 0; i < t_rows; i++) {\n\n        double *y = (double *) STARPU_VECTOR_GET_PTR(y_i[i]);\n\n        int rbegin = MAX(     0,  A_pi.rbegin - i * A_pi.bm);\n        int rend =   MIN(A_pi.bm, A_pi.rend   - i * A_pi.bm);\n\n        //\n        // loop over tile columns\n        //\n\n        for (int j = 0; j < t_cols; j++) {\n\n            double *A = (double *) STARPU_MATRIX_GET_PTR(A_i[j*t_rows+i]);\n            int ldA = STARPU_MATRIX_GET_LD(A_i[j*t_rows+i]);\n\n            double *v = (double *) STARPU_VECTOR_GET_PTR(v_i[j]);\n\n            int cbegin = MAX(      0, A_pi.cbegin - j * A_pi.bn);\n            int cend =   MIN(A_pi.bn, A_pi.cend   - j * A_pi.bn);\n\n            cblas_dgemv(\n                CblasColMajor, CblasNoTrans, rend-rbegin, cend-cbegin,\n                1.0, A+cbegin*ldA+rbegin, ldA, v+cbegin, 1, 1.0, y+rbegin, 1);\n        }\n    }\n\n    STARNEIG_EVENT_END();\n}\n\nvoid starneig_hessenberg_cpu_finish_column(\n    void *buffers[], void *cl_args)\n{\n    struct range_packing_info y_pi;\n    int i;\n    starpu_codelet_unpack_args(cl_args, &i, &y_pi);\n\n    int k = 0;\n\n    double *V = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n    int m = STARPU_MATRIX_GET_NX(buffers[k]);\n    int ldV = STARPU_MATRIX_GET_LD(buffers[k]);\n    k++;\n\n    double *T = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n    int ldT = STARPU_MATRIX_GET_LD(buffers[k]);\n    k++;\n\n    double *Y = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n    int ldY = STARPU_MATRIX_GET_LD(buffers[k]);\n    k++;\n\n    // intemediate vector interface from the trailing matrix operation\n    struct starpu_vector_interface **y_i =\n        (struct starpu_vector_interface **)buffers + k;\n    k += y_pi.handles;\n\n    double tau = T[i*ldT+i];\n    double *v = V+i*ldV+i;\n\n    //\n    // finish Y update\n    //\n\n    starneig_join_range(&y_pi, y_i, Y+i*ldY, 0);\n\n    // w <- V' * v (shared result)\n    cblas_dgemv(CblasColMajor, CblasTrans, m-i, i,\n        1.0, V+i, ldV, v, 1, 0.0, T+i*ldT, 1);\n\n    // Y(:,i) <- Y(:,i) - Y * w\n    cblas_dgemv(CblasColMajor, CblasNoTrans, m, i,\n        -1.0, Y, ldY, T+i*ldT, 1, 1.0, Y+i*ldY, 1);\n\n    cblas_dscal(m, tau, Y+i*ldY, 1);\n\n    //\n    // update T\n    //\n\n    // w <- tau * w\n    cblas_dscal(i, -tau, T+i*ldT, 1);\n\n    // T(0:i,i) = T * w\n    cblas_dtrmv(\n        CblasColMajor, CblasUpper, CblasNoTrans, CblasNonUnit, i,\n        T, ldT, T+i*ldT, 1);\n\n    T[i*ldT+i] = tau;\n}\n\nvoid starneig_hessenberg_cpu_update_trail_right(\n    void *buffers[], void *cl_args)\n{\n    struct packing_info A_pi;\n    int nb, roffset, coffset;\n    starpu_codelet_unpack_args(cl_args, &A_pi, &nb, &roffset, &coffset);\n\n    STARNEIG_EVENT_BEGIN(&A_pi, starneig_event_blue);\n\n    int m = A_pi.rend - A_pi.rbegin;\n    int n = A_pi.cend - A_pi.cbegin;\n\n    double *V = (double *) STARPU_MATRIX_GET_PTR(buffers[0]);\n    int ldV = STARPU_MATRIX_GET_LD(buffers[0]);\n\n    double *Y = (double *) STARPU_MATRIX_GET_PTR(buffers[1]);\n    int ldY = STARPU_MATRIX_GET_LD(buffers[1]);\n\n    double *A = (double *) STARPU_MATRIX_GET_PTR(buffers[2]);\n    int ldA = STARPU_MATRIX_GET_LD(buffers[2]);\n\n    struct starpu_matrix_interface **A_i =\n        (struct starpu_matrix_interface **)buffers + 3;\n\n    // join tiles\n    starneig_join_window(&A_pi, ldA, A_i, A, 0);\n\n    // A <- Y V^T\n    cblas_dgemm(CblasColMajor, CblasNoTrans, CblasTrans,\n        m, n, nb, -1.0, Y+roffset, ldY, V+coffset+nb-1, ldV, 1.0, A, ldA);\n\n    // split tiles\n    starneig_join_window(&A_pi, ldA, A_i, A, 1);\n\n    STARNEIG_EVENT_END();\n}\n\nvoid starneig_hessenberg_cpu_update_left_a(\n    void *buffers[], void *cl_args)\n{\n    struct packing_info A_pi, W_pi;\n    int nb, offset;\n    starpu_codelet_unpack_args(cl_args, &A_pi, &W_pi, &nb, &offset);\n\n    STARNEIG_EVENT_BEGIN(&A_pi, starneig_event_green);\n\n    int m = A_pi.rend - A_pi.rbegin;\n    int n = A_pi.cend - A_pi.cbegin;\n\n    int k = 0;\n\n    double *V = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n    int ldV = STARPU_MATRIX_GET_LD(buffers[k]);\n    k++;\n\n    double *T = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n    int ldT = STARPU_MATRIX_GET_LD(buffers[k]);\n    k++;\n\n    double *A = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n    int ldA = STARPU_MATRIX_GET_LD(buffers[k]);\n    k++;\n\n    double *W = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n    int ldW = STARPU_MATRIX_GET_LD(buffers[k]);\n    k++;\n\n    double *P = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n    int ldP = STARPU_MATRIX_GET_LD(buffers[k]);\n    k++;\n\n    struct starpu_matrix_interface **A_i =\n        (struct starpu_matrix_interface **)buffers + k;\n    k += A_pi.handles;\n\n    struct starpu_matrix_interface **W_i =\n        (struct starpu_matrix_interface **)buffers + k;\n    k += W_pi.handles;\n\n    // join A tiles\n    starneig_join_window(&A_pi, ldA, A_i, A, 0);\n\n    // join W tiles\n    starneig_join_window(&W_pi, ldW, W_i, W, 0);\n\n    // P <- A^T * V\n    cblas_dgemm(\n        CblasColMajor, CblasTrans, CblasNoTrans, n, nb, m,\n        1.0, A, ldA, V+offset, ldV, 0.0, P, ldP);\n\n    // P <- P * T\n    cblas_dtrmm(\n        CblasColMajor, CblasRight, CblasUpper, CblasNoTrans,\n        CblasNonUnit, n, nb, 1.0, T, ldT, P, ldP);\n\n    // W <- W + P\n    for (int j = 0; j < nb; j++)\n        cblas_daxpy(n, 1.0, P+j*ldP, 1, W+j*ldW, 1);\n\n    // split W tiles\n    starneig_join_window(&W_pi, ldW, W_i, W, 1);\n\n    STARNEIG_EVENT_END();\n}\n\nvoid starneig_hessenberg_cpu_update_left_b(\n    void *buffers[], void *cl_args)\n{\n    struct packing_info A_pi, W_pi;\n    int nb, offset;\n    starpu_codelet_unpack_args(cl_args, &A_pi, &W_pi, &nb, &offset);\n\n    STARNEIG_EVENT_BEGIN(&packing_info, starneig_event_green);\n\n    int m = A_pi.rend - A_pi.rbegin;\n    int n = A_pi.cend - A_pi.cbegin;\n\n    int k = 0;\n\n    double *V = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n    int ldV = STARPU_MATRIX_GET_LD(buffers[k]);\n    k++;\n\n    double *W = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n    int ldW = STARPU_MATRIX_GET_LD(buffers[k]);\n    k++;\n\n    double *A = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n    int ldA = STARPU_MATRIX_GET_LD(buffers[k]);\n    k++;\n\n    struct starpu_matrix_interface **W_i =\n        (struct starpu_matrix_interface **)buffers + k;\n    k += W_pi.handles;\n\n    struct starpu_matrix_interface **A_i =\n        (struct starpu_matrix_interface **)buffers + k;\n    k += A_pi.handles;\n\n    // join A tiles\n    starneig_join_window(&A_pi, ldA, A_i, A, 0);\n\n    // join W tiles\n    starneig_join_window(&W_pi, ldW, W_i, W, 0);\n\n    //  A <- A - V * W^T\n    cblas_dgemm(\n        CblasColMajor, CblasNoTrans, CblasTrans, m, n,\n        nb, -1.0, V+offset, ldV, W, ldW, 1.0, A, ldA);\n\n    // split A tiles\n    starneig_join_window(&A_pi, ldA, A_i, A, 1);\n\n    STARNEIG_EVENT_END();\n}\n\nvoid starneig_hessenberg_cpu_update_right_a(\n    void *buffers[], void *cl_args)\n{\n    struct packing_info A_pi, W_pi;\n    int nb, offset;\n    starpu_codelet_unpack_args(cl_args, &A_pi, &W_pi, &nb, &offset);\n\n    STARNEIG_EVENT_BEGIN(&packing_info, starneig_event_blue);\n\n    int m = A_pi.rend - A_pi.rbegin;\n    int n = A_pi.cend - A_pi.cbegin;\n\n    int k = 0;\n\n    double *V = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n    int ldV = STARPU_MATRIX_GET_LD(buffers[k]);\n    k++;\n\n    double *T = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n    int ldT = STARPU_MATRIX_GET_LD(buffers[k]);\n    k++;\n\n    double *A = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n    int ldA = STARPU_MATRIX_GET_LD(buffers[k]);\n    k++;\n\n    double *W = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n    int ldW = STARPU_MATRIX_GET_LD(buffers[k]);\n    k++;\n\n    double *P = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n    int ldP = STARPU_MATRIX_GET_LD(buffers[k]);\n    k++;\n\n    struct starpu_matrix_interface **A_i =\n        (struct starpu_matrix_interface **)buffers + k;\n    k += A_pi.handles;\n\n    struct starpu_matrix_interface **W_i =\n        (struct starpu_matrix_interface **)buffers + k;\n    k += W_pi.handles;\n\n    // join A tiles\n    starneig_join_window(&A_pi, ldA, A_i, A, 0);\n\n    // join W tiles\n    starneig_join_window(&W_pi, ldW, W_i, W, 0);\n\n    // P <- A * V\n    cblas_dgemm(\n        CblasColMajor, CblasNoTrans, CblasNoTrans, m, nb, n,\n        1.0, A, ldA, V+offset, ldV, 0.0, P, ldP);\n\n    // P <- P * T\n    cblas_dtrmm(\n        CblasColMajor, CblasRight, CblasUpper, CblasNoTrans,\n        CblasNonUnit, m, nb, 1.0, T, ldT, P, ldP);\n\n    // W <- W + P\n    for (int j = 0; j < nb; j++)\n        cblas_daxpy(m, 1.0, P+j*ldP, 1, W+j*ldW, 1);\n\n    // split W tiles\n    starneig_join_window(&W_pi, ldW, W_i, W, 1);\n\n    STARNEIG_EVENT_END();\n}\n\nvoid starneig_hessenberg_cpu_update_right_b(\n    void *buffers[], void *cl_args)\n{\n    struct packing_info A_pi, W_pi;\n    int nb, offset;\n    starpu_codelet_unpack_args(cl_args, &A_pi, &W_pi, &nb, &offset);\n\n    STARNEIG_EVENT_BEGIN(&packing_info, starneig_event_blue);\n\n    int m = A_pi.rend - A_pi.rbegin;\n    int n = A_pi.cend - A_pi.cbegin;\n\n    int k = 0;\n\n    double *V = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n    int ldV = STARPU_MATRIX_GET_LD(buffers[k]);\n    k++;\n\n    double *W = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n    int ldW = STARPU_MATRIX_GET_LD(buffers[k]);\n    k++;\n\n    double *A = (double *) STARPU_MATRIX_GET_PTR(buffers[k]);\n    int ldA = STARPU_MATRIX_GET_LD(buffers[k]);\n    k++;\n\n    struct starpu_matrix_interface **W_i =\n        (struct starpu_matrix_interface **)buffers + k;\n    k += W_pi.handles;\n\n    struct starpu_matrix_interface **A_i =\n        (struct starpu_matrix_interface **)buffers + k;\n    k += A_pi.handles;\n\n    // join A tiles\n    starneig_join_window(&A_pi, ldA, A_i, A, 0);\n\n    // join W tiles\n    starneig_join_window(&W_pi, ldW, W_i, W, 0);\n\n    //  A <- A - W * V\n    cblas_dgemm(\n        CblasColMajor, CblasNoTrans, CblasTrans, m, n,\n        nb, -1.0, W, ldW, V+offset, ldV, 1.0, A, ldA);\n\n    // split A tiles\n    starneig_join_window(&A_pi, ldA, A_i, A, 1);\n\n    STARNEIG_EVENT_END();\n}\n", "meta": {"hexsha": "0d7e9dee5e25ab3bc50d76a8583f333e667f510f", "size": 15938, "ext": "c", "lang": "C", "max_stars_repo_path": "src/hessenberg/cpu.c", "max_stars_repo_name": "NLAFET/StarNEig", "max_stars_repo_head_hexsha": "d47ed4dfbcdaec52e44f0b02d14a6e0cde64d286", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 12.0, "max_stars_repo_stars_event_min_datetime": "2019-04-28T17:13:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-24T12:30:19.000Z", "max_issues_repo_path": "src/hessenberg/cpu.c", "max_issues_repo_name": "NLAFET/StarNEig", "max_issues_repo_head_hexsha": "d47ed4dfbcdaec52e44f0b02d14a6e0cde64d286", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/hessenberg/cpu.c", "max_forks_repo_name": "NLAFET/StarNEig", "max_forks_repo_head_hexsha": "d47ed4dfbcdaec52e44f0b02d14a6e0cde64d286", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2019-04-30T12:14:12.000Z", "max_forks_repo_forks_event_max_datetime": "2020-04-14T09:41:23.000Z", "avg_line_length": 28.4099821747, "max_line_length": 80, "alphanum_fraction": 0.6213452127, "num_tokens": 4965, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.49218813572079556, "lm_q2_score": 0.032589743826428076, "lm_q1q2_score": 0.016040285257547943}}
{"text": "/* -*- mode: C; c-basic-offset: 4 -*- */\n/* ex: set shiftwidth=4 tabstop=4 expandtab: */\n/*\n * Copyright (c) 2018, Colorado School of Mines\n * All rights reserved.\n *\n * Author(s): Neil T. Dantam <ndantam@miens.edu>\n * Georgia Tech Humanoid Robotics Lab\n * Under Direction of Prof. Mike Stilman <mstilman@cc.gatech.edu>\n *\n *\n * This file is provided under the following \"BSD-style\" License:\n *\n *\n *   Redistribution and use in source and binary forms, with or\n *   without modification, are permitted provided that the following\n *   conditions are met:\n *\n *   * Redistributions of source code must retain the above copyright\n *     notice, this list of conditions and the following disclaimer.\n *\n *   * Redistributions in binary form must reproduce the above\n *     copyright notice, this list of conditions and the following\n *     disclaimer in the documentation and/or other materials provided\n *     with the distribution.\n *\n *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND\n *   CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES,\n *   INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\n *   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n *   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR\n *   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,\n *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\n *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF\n *   USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED\n *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\n *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN\n *   ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n *   POSSIBILITY OF SUCH DAMAGE.\n *\n */\n\n// uncomment to check that local allocs actually get freed\n// #define AA_ALLOC_STACK_MAX 0\n\n\n#include <stdlib.h>\n#include <cblas.h>\n\n#include \"amino.h\"\n#include \"amino/mat.h\"\n#include \"amino/mat_internal.h\"\n\n#define VEC_LEN(X) ((int)(X->len))\n#define MAT_ROWS(X) ((int)(X->rows))\n#define MAT_COLS(X) ((int)(X->cols))\n\n/******************/\n/* Error Handling */\n/******************/\n\nstatic void\ns_err_default( const char *message )\n{\n    fprintf(stderr, \"AMINO ERROR: %s\\n\",message);\n    abort();\n    exit(EXIT_FAILURE);\n}\n\nstatic aa_la_err_fun  *s_err_fun = s_err_default;\n\nvoid\naa_la_set_err( aa_la_err_fun *fun )\n{\n    s_err_fun = fun;\n}\n\nAA_API void\naa_la_err( const char *message ) {\n    s_err_fun(message);\n}\n\nAA_API void\naa_la_fail_size( size_t a, size_t b )\n{\n        const size_t size = 256;\n        char buf[size];\n        snprintf(buf,size, \"Mismatched sizes: %lu != %lu\\n\", a, b);\n        aa_la_err(buf);\n}\n\n/****************/\n/* Construction */\n/****************/\n\nAA_API void\naa_dvec_view( struct aa_dvec *vec, size_t len, double *data, size_t inc )\n{\n    *vec = AA_DVEC_INIT(len,data,inc);\n}\n\n\nAA_API void\naa_dvec_slice( const struct aa_dvec *src,\n               size_t start,\n               size_t stop,\n               size_t step,\n               struct aa_dvec *dst )\n{\n    if( stop > src->len || stop < start ) {\n        aa_la_err(\"Slice out-of-bounds\\n\");\n    }\n    *dst = AA_DVEC_INIT( (stop - start) / step,\n                         src->data + src->inc*start,\n                         src->inc*step );\n}\n\n\nAA_API void\naa_dmat_row_vec( const struct aa_dmat *src, size_t row, struct aa_dvec *dst )\n{\n    if( row >= src->rows ) {\n        aa_la_err(\"Row vector out-of-bounds\\n\");\n    }\n    aa_dvec_view(dst,src->cols, src->data + row, src->ld);\n}\n\nAA_API void\naa_dmat_col_vec( const struct aa_dmat *src, size_t col, struct aa_dvec *dst )\n{\n    if( col >= src->cols ) {\n        aa_la_err(\"Row vector out-of-bounds\\n\");\n    }\n    aa_dvec_view(dst, src->rows, src->data + col*src->ld, 1);\n}\n\nAA_API void\naa_dmat_diag_vec( const struct aa_dmat *src, struct aa_dvec *dst )\n{\n    aa_dvec_view(dst, AA_MIN(src->rows, src->cols), src->data, src->ld + 1);\n}\n\nAA_API void\naa_dmat_view( struct aa_dmat *mat, size_t rows, size_t cols,\n              double *data, size_t ld )\n{\n    *mat = AA_DMAT_INIT(rows,cols,data,ld);\n}\n\nAA_API void\naa_dmat_view_block(  struct aa_dmat *dst,\n                     const struct aa_dmat *src,\n                     size_t row_start, size_t col_start,\n                     size_t rows, size_t cols )\n{\n    aa_dmat_block( src,\n                   row_start, col_start,\n                   row_start + rows, col_start + cols,\n                   dst );\n}\n\nAA_API void\naa_dmat_block( const struct aa_dmat *src,\n               size_t row_start, size_t col_start,\n               size_t row_end, size_t col_end,\n               struct aa_dmat *dst )\n{\n    size_t m = src->rows, n = src->cols;\n    if( row_start >= row_end ||\n        row_start >= m ||\n        row_end > m ||\n        col_start >= col_end ||\n        col_start >= n ||\n        col_end > n )\n    {\n        aa_la_err(\"Block out-of-bounds\\n\");\n    }\n\n    aa_dmat_view( dst,\n                  row_end - row_start, col_end - col_start,\n                  src->data + col_start*src->ld + row_start, src->ld );\n}\n\n\nAA_API struct aa_dvec *\naa_dvec_malloc( size_t len ) {\n    struct aa_dvec *r;\n    const size_t s_desc = sizeof(*r);\n    const size_t s_elem = sizeof(r->data[0]);\n    const size_t pad =  s_elem - (s_desc % s_elem);\n    const size_t size = s_desc + pad + len * s_elem;\n\n    const size_t off = s_desc + pad;\n\n    char *ptr = (char*)malloc( size );\n\n    r = (struct aa_dvec*)ptr;\n    aa_dvec_view(r, len, (double*)(ptr+off), 1);\n    return r;\n}\n\nAA_API struct aa_dvec *\naa_dvec_alloc( struct aa_mem_region *reg, size_t len ) {\n    struct aa_dvec *r;\n    const size_t s_desc = sizeof(*r);\n    const size_t s_elem = sizeof(r->data[0]);\n    const size_t pad =  s_elem - (s_desc % s_elem);\n    char *ptr = (char*)aa_mem_region_alloc(reg, s_desc + pad + len * s_elem );\n\n    r = (struct aa_dvec*)ptr;\n    aa_dvec_view(r, len, (double*)(ptr+s_desc+pad), 1);\n    return r;\n}\n\nAA_API struct aa_dvec *\naa_dvec_dup( struct aa_mem_region *reg, const struct aa_dvec *src)\n{\n    struct aa_dvec *dst = aa_dvec_alloc(reg,src->len);\n    aa_dvec_copy(src,dst);\n    return dst;\n}\n\nAA_API struct aa_dmat *\naa_dmat_dup( struct aa_mem_region *reg, const struct aa_dmat *src)\n{\n    struct aa_dmat *dst = aa_dmat_alloc(reg,src->rows,src->cols);\n    aa_dmat_copy(src,dst);\n    return dst;\n}\n\nAA_API struct aa_dmat *\naa_dmat_malloc( size_t rows, size_t cols )\n{\n    struct aa_dmat *r;\n    const size_t s_desc = sizeof(*r);\n    const size_t s_elem = sizeof(r->data[0]);\n    const size_t pad =  s_elem - (s_desc % s_elem);\n    char *ptr = (char*)malloc( s_desc + pad + rows*cols * s_elem );\n\n    r = (struct aa_dmat*)ptr;\n    aa_dmat_view(r, rows, cols, (double*)(ptr+s_desc+pad), rows);\n\n    return r;\n}\n\nAA_API struct aa_dmat *\naa_dmat_alloc( struct aa_mem_region *reg, size_t rows, size_t cols )\n{\n    struct aa_dmat *r;\n    const size_t s_desc = sizeof(*r);\n    const size_t s_elem = sizeof(r->data[0]);\n    const size_t pad =  s_elem - (s_desc % s_elem);\n    size_t size = s_desc + pad + rows*cols * s_elem ;\n\n    char *ptr = (char*)aa_mem_region_alloc(reg, size);\n\n    r = (struct aa_dmat*)ptr;\n    aa_dmat_view( r, rows, cols, (double*)(ptr+s_desc+pad), rows );\n\n    return r;\n}\n\nAA_API void\naa_dmat_set( struct aa_dmat *A, double alpha, double beta )\n{\n    int mi   = (int)(A->rows);\n    int ni   = (int)(A->cols);\n    int ldai = (int)(A->ld);\n\n    dlaset_( \"G\", &mi, &ni,\n             &alpha, &beta,\n             A->data, &ldai );\n\n}\n\nAA_API void\naa_dvec_set( struct aa_dvec *vec, double alpha )\n{\n    double *end = vec->data + vec->len*vec->inc;\n    for( double *x = vec->data; x < end; x += vec->inc ) {\n        *x = alpha;\n    }\n}\n\nvoid\naa_dvec_zero( struct aa_dvec *vec )\n{\n    aa_dvec_set(vec,0);\n}\n\n\nAA_API void\naa_dmat_zero( struct aa_dmat *mat )\n{\n    aa_dmat_set(mat, 0, 0);\n}\n\n\n/* Level 1 BLAS */\nAA_API void\naa_dvec_swap( struct aa_dvec *x, struct aa_dvec *y )\n{\n    aa_la_check_size(x->len, y->len);\n    cblas_dswap( VEC_LEN(x), AA_VEC_ARGS(x), AA_VEC_ARGS(y) );\n}\n\nAA_API void\naa_dvec_scal( double a, struct aa_dvec *x )\n{\n    cblas_dscal( VEC_LEN(x), a, AA_VEC_ARGS(x) );\n}\n\nstatic void s_inc( size_t n, double alpha, double *x, size_t inc ) {\n    for( double *end = x + n*inc; x < end; x += inc ) {\n        *x += alpha;\n    }\n}\n\nAA_API void\naa_dvec_inc( double alpha, struct aa_dvec *x )\n{\n    s_inc( x->len, alpha, x->data, x->inc );\n}\n\nAA_API void\naa_dvec_copy( const struct aa_dvec *x, struct aa_dvec *y )\n{\n    aa_la_check_size(x->len, y->len);\n    cblas_dcopy( VEC_LEN(x), AA_VEC_ARGS(x), AA_VEC_ARGS(y) );\n}\n\nAA_API void\naa_dvec_axpy( double a, const struct aa_dvec *x, struct aa_dvec *y )\n{\n    aa_la_check_size(x->len, y->len);\n    cblas_daxpy( VEC_LEN(x), a, AA_VEC_ARGS(x), AA_VEC_ARGS(y) );\n}\n\nAA_API double\naa_dvec_dot( const struct aa_dvec *x, struct aa_dvec *y )\n{\n    aa_la_check_size(x->len, y->len);\n    return cblas_ddot( VEC_LEN(x), AA_VEC_ARGS(x), AA_VEC_ARGS(y) );\n}\n\nAA_API double\naa_dvec_nrm2( const struct aa_dvec *x )\n{\n    return cblas_dnrm2( VEC_LEN(x), AA_VEC_ARGS(x) );\n}\n\n/* Level 2 BLAS */\nAA_API void\naa_dmat_gemv( CBLAS_TRANSPOSE trans,\n              double alpha, const struct aa_dmat *A,\n              const struct aa_dvec *x,\n              double beta, struct aa_dvec *y )\n{\n    if( CblasTrans == trans ) {\n        aa_la_check_size( A->rows, x->len );\n        aa_la_check_size( A->cols, y->len );\n    } else {\n        aa_la_check_size( A->rows, y->len );\n        aa_la_check_size( A->cols, x->len );\n    }\n\n    cblas_dgemv( CblasColMajor, trans,\n                 MAT_ROWS(A), MAT_COLS(A),\n                 alpha, AA_MAT_ARGS(A),\n                 AA_VEC_ARGS(x),\n                 beta, AA_VEC_ARGS(y) );\n\n}\n\n/* Level 3 BLAS */\nAA_API void\naa_dmat_gemm( CBLAS_TRANSPOSE transA, CBLAS_TRANSPOSE transB,\n              double alpha, const struct aa_dmat *A,\n              const struct aa_dmat *B,\n              double beta, struct aa_dmat *C )\n{\n    aa_la_check_size( A->rows, C->rows );\n    aa_la_check_size( A->cols, B->rows );\n    aa_la_check_size( B->cols, C->cols );\n\n    assert( A->rows <= A->ld );\n    assert( B->rows <= B->ld );\n    assert( C->rows <= C->ld );\n\n    cblas_dgemm( CblasColMajor,\n                 transA, transB,\n                 MAT_ROWS(A), MAT_COLS(B), MAT_COLS(A),\n                 alpha, AA_MAT_ARGS(A),\n                 AA_MAT_ARGS(B),\n                 beta, AA_MAT_ARGS(C) );\n}\n\n/* LAPACK */\n\nAA_API void\naa_dmat_lacpy( const char uplo[1],\n               const struct aa_dmat *A,\n               struct aa_dmat *B )\n{\n\n    aa_la_check_size(A->rows,B->rows);\n    aa_la_check_size(A->cols,B->cols);\n    int mi   = (int)(A->rows);\n    int ni   = (int)(A->cols);\n    int ldai = (int)(A->ld);\n    int ldbi = (int)(B->ld);\n\n    dlacpy_(uplo, &mi, &ni,\n            A->data, &ldai,\n            B->data, &ldbi);\n}\n\nAA_API void\naa_dmat_copy(  const struct aa_dmat *A, struct aa_dmat *B)\n{\n    aa_dmat_lacpy(\"G\",A,B);\n}\n\n\n/* Matrix Functions */\n\nstatic double s_ssd( size_t n,\n                     double a,\n                     double *x, size_t incx,\n                     double *y, size_t incy )\n{\n    for( double *e = x + n*incx; x < e; x += incx, y+=incy ) {\n        double d = *x - *y;\n        a += d*d;\n    }\n    return a;\n}\n\n\nAA_API double\naa_dvec_ssd( const struct aa_dvec *x, const struct aa_dvec *y)\n{\n    aa_la_check_size( x->len, y->len );\n    return s_ssd( x->len, 0,\n                  x->data, x->inc,\n                  y->data, y->inc );\n}\n\nAA_API double\naa_dmat_ssd( const struct aa_dmat *A, const struct aa_dmat *B)\n{\n    size_t m = A->rows, n = A->cols;\n    aa_la_check_size( m, B->rows );\n    aa_la_check_size( n, B->cols );\n    double a = 0;\n    for( double *Ac=A->data, *Bc=B->data, *ec=A->data + n*A->ld;\n         Ac < ec;\n         Ac+=A->ld, Bc+=B->ld )\n    {\n        a = s_ssd( m, a, Ac, 1, Bc, 1 );\n    }\n    return a;\n}\n\nAA_API double\naa_dmat_nrm2( const struct aa_dmat *A )\n{\n    int m=(int)A->rows, n=(int)A->cols, ld=(int)A->ld;\n    return dlange_(\"F\", &m, &n, A->data, &ld, NULL );\n}\n\nAA_API void\naa_dmat_scal( struct aa_dmat *x, double alpha )\n{\n    int m = (int)x->rows, n=(int)x->cols, ld=(int)x->ld;\n    double cfrom=1;\n    int info;\n    dlascl_(\"G\", NULL, NULL,\n            &cfrom, &alpha,\n            &m, &n, x->data, &ld,\n            &info);\n}\n\nAA_API void\naa_dmat_inc( struct aa_dmat *A, double alpha )\n{\n    size_t m=A->rows, n=A->cols, ld=A->ld;\n    double *x = A->data;\n\n    if( m == n ) {\n        s_inc(m*n, alpha, x, 1);\n    } else {\n        for( double *e = x + n*ld; x < e; x+=ld ) {\n            s_inc(m, alpha, x, 1);\n        }\n    }\n\n}\n\nAA_API void\naa_dmat_axpy( double alpha, const struct aa_dmat *X, struct aa_dmat *Y)\n{\n    size_t m=X->rows, n=X->cols, ldX=X->ld, ldY=Y->ld;\n    double *x=X->data, *y=Y->data;\n\n    aa_la_check_size(m, Y->rows);\n    aa_la_check_size(n, Y->cols);\n\n\n    if( m == ldX && m == ldY ) {\n        cblas_daxpy( (int)(m*n), alpha, x,1, y,1 );\n    } else {\n        int mi = (int)m;\n        for( double *e = x + n*ldX; x < e; x+=ldX, y+=ldY ) {\n            cblas_daxpy( mi, alpha, x,1, y,1 );\n        }\n    }\n}\n\nvoid\naa_dmat_trans( const struct aa_dmat *A, struct aa_dmat *B)\n{\n    const size_t m   = A->rows;\n    const size_t n   = A->cols;\n    const size_t lda = A->ld;\n    const size_t ldb = B->ld;\n\n    aa_la_check_size(m, B->cols);\n    aa_la_check_size(n, B->rows);\n\n    for ( double *Acol = A->data, *Brow=B->data, *Be=B->data + n;\n          Brow < Be;\n          Brow++, Acol+=lda )\n    {\n        cblas_dcopy( (int)m, Acol, 1, Brow, (int)ldb );\n    }\n}\n\nAA_API int\naa_dmat_inv( struct aa_dmat *A )\n{\n    aa_la_check_size(A->rows,A->cols);\n    int info;\n\n    int *ipiv = (int*)\n        aa_mem_region_local_alloc(sizeof(int)*A->rows);\n\n    // LU-factor\n    info = aa_cla_dgetrf( MAT_ROWS(A), MAT_COLS(A), AA_MAT_ARGS(A), ipiv );\n\n    int lwork = -1;\n    while(1) {\n        double *work = (double*)\n            aa_mem_region_local_tmpalloc( sizeof(double)*\n                                      (size_t)(lwork < 0 ? 1 : lwork) );\n        aa_cla_dgetri( MAT_ROWS(A), AA_MAT_ARGS(A), ipiv, work, lwork );\n        if( lwork > 0 ) break;\n        assert( -1 == lwork );\n        lwork = (int)work[0];\n    }\n\n    aa_mem_region_local_pop(ipiv);\n\n    return info;\n}\n\n\nint s_svd_helper ( const struct aa_dmat *A,\n                   struct aa_mem_region *reg,\n                   size_t *pkmin, size_t *pkmax,\n                   double **pU, double **pVt, double **pS )\n{\n\n    size_t m = A->rows;\n    size_t n = A->cols;\n\n    // find  min/max dimensions\n    if( m < n ) {\n        *pkmin = m;\n        *pkmax = n;\n    } else {\n        *pkmin = n;\n        *pkmax = m;\n    }\n\n    // This method uses the SVD\n    double *W  = (double*)aa_mem_region_alloc( reg, sizeof(double) * (m*m + n*n + *pkmin) );\n    *pU  = W;        // size m*m\n    *pVt = *pU + m*m; // size n*n\n    *pS  = *pVt + n*n; // size min(m,n)\n\n    // A = U S V^T\n    aa_la_d_svd( m,n,\n                 A->data, A->ld,\n                 *pU, m, *pS, *pVt, n );\n\n\n    return 0;\n}\n\n\nint\naa_dmat_pinv( const struct aa_dmat *A, double tol, struct aa_dmat *As )\n{\n\n    aa_la_check_size(A->rows, As->cols);\n    aa_la_check_size(A->cols, As->rows);\n\n    struct aa_mem_region *reg =  aa_mem_region_local_get();\n    void *ptrtop = aa_mem_region_ptr(reg);\n\n    size_t kmin, kmax;\n    double *U, *Vt, *S;\n    s_svd_helper( A, reg,\n                  &kmin, &kmax, &U, &Vt, &S );\n\n    size_t m = A->rows;\n    const int mi = (int)(A->rows);\n    const int ni = (int)(A->cols);\n\n    if( tol < 0 ) {\n        tol = (double)kmax * S[0] * DBL_EPSILON;\n    }\n\n    // \\sum 1/s_i * v_i * u_i^T\n    aa_dmat_zero(As);\n    double *Asd = As->data;\n    for( size_t i = 0; i < kmin && S[i] > tol; i ++ ) {\n        cblas_dger( CblasColMajor, ni, mi, 1/S[i],\n                    Vt + i, ni,\n                    U + m*i, 1,\n                    Asd, ni\n            );\n    }\n\n    aa_mem_region_pop( reg, ptrtop );\n\n    return 0;\n\n    /* struct aa_mem_region *reg = aa_mem_region_local_get(); */\n    /* struct aa_dmat *Ap = aa_dmat_alloc(reg,m,n); */\n\n    /* // B = AA^T */\n    /* double *B; */\n    /* int ldb; */\n    /* if( m <= n ) { */\n    /*     /\\* Use A_star as workspace when it's big enough *\\/ */\n    /*     B = As->data; */\n    /*     ldb = (int)(As->ld); */\n    /* } else { */\n    /*     B = AA_MEM_REGION_NEW_N( reg, double, m*m ); */\n    /*     ldb = (int)m; */\n    /* } */\n\n    /* aa_la_dlacpy( \"A\", A, Ap ); */\n\n    /* // B is symmetric.  Only compute the upper half. */\n    /* cblas_dsyrk( CblasColMajor, CblasUpper, CblasNoTrans, */\n    /*              MAT_ROWS(Ap), MAT_COLS(Ap), */\n    /*              1, AA_MAT_ARGS(Ap), */\n    /*              0, B, ldb ); */\n\n    /* // B += kI */\n    /* /\\* for( size_t i = 0; i < m*(size_t)ldb; i += ((size_t)ldb+1) ) *\\/ */\n    /* /\\*     B[i] += k; *\\/ */\n\n    /* /\\* Solve via Cholesky Decomp *\\/ */\n    /* /\\* B^T (A^*)^T = A    and     B = B^T (Hermitian) *\\/ */\n\n    /* aa_cla_dposv( 'U', (int)m, (int)n, */\n    /*               B, ldb, */\n    /*               AA_MAT_ARGS(Ap) ); */\n\n    /* aa_dmat_trans( Ap, As ); */\n\n    /* aa_mem_region_pop( reg, Ap ); */\n\n}\n\nint\naa_dmat_dpinv( const struct aa_dmat *A, double k, struct aa_dmat *As)\n{\n    aa_la_check_size(A->rows, As->cols);\n    aa_la_check_size(A->cols, As->rows);\n\n    // TODO: Try DGESV for non-positive-definite matrices\n\n    size_t m = A->rows;\n    size_t n = A->cols;\n\n    struct aa_mem_region *reg = aa_mem_region_local_get();\n    void *ptrtop = aa_mem_region_ptr(reg);\n    int r = -1;\n\n    /* As = inv(A'*A - k*I) * A' A'*inv(A*A' - k*I) */\n    if( m <= n ) {\n        /*\n         * (A^*) = A^T*inv(A*A^T - k*I)\n         * (A^*) = A^T*inv(B)\n         * (A^*)*B = A^T\n         * B^T (A^*)^T = A    and     B = B^T (Hermitian)\n         *\n         */\n\n        /* Use A_star as workspace for B */\n        double *B = As->data;\n        int ldb = (int)(As->ld);\n\n        /* Ap = A */\n        struct aa_dmat *Ap = aa_dmat_alloc(reg,m,n);\n        aa_dmat_lacpy( \"A\", A, Ap );\n\n        // B is symmetric.  Only compute the upper half.\n        // B = A * A'\n        cblas_dsyrk( CblasColMajor, CblasUpper, CblasNoTrans,\n                     MAT_ROWS(Ap), MAT_COLS(Ap),\n                     1, AA_MAT_ARGS(Ap),\n                     0, B, ldb );\n\n        /* B += kI */\n        for( double *x = B, *e = B+(int)m*ldb; x < e; x+=ldb+1 )\n            *x += k;\n\n        /* B^T (A^*)^T = A    and     B = B^T (Hermitian) */\n\n        /* Solve via Cholesky (positive definite) */\n        r = aa_cla_dposv( 'U', (int)m, (int)n,\n                           B, ldb,\n                           AA_MAT_ARGS(Ap) );\n\n        /* Solve via LU */\n        /* int *ipiv = AA_MEM_REGION_NEW_N(reg,int,m); */\n        /* r = aa_la_d_sysv( \"U\", m, n, */\n        /*                   B, (size_t)ldb, */\n        /*                   ipiv, */\n        /*                   Ap->data, Ap->ld ); */\n\n\n        aa_dmat_trans( Ap, As );\n\n    } else {\n\n        /*\n         * (A^*) = inv(A^T*A - k*I) * A^T\n         * (A^*) = inv(B) * A^T\n         * B*(A^*) = A^T\n         */\n\n        /* Use A_star as workspace for B */\n        double *B = AA_MEM_REGION_NEW_N(reg,double,n*n);\n        int ldb = (int)(n);\n\n        /* As = A^T */\n        aa_dmat_trans( A, As );\n\n        // B is symmetric.  Only compute the upper half.\n        // B = A' * A = As * As'\n        cblas_dsyrk( CblasColMajor, CblasUpper, CblasNoTrans,\n                     MAT_ROWS(As), MAT_COLS(As),\n                     1, AA_MAT_ARGS(As),\n                     0, B, ldb );\n\n        /* B += kI */\n        //for( size_t i = 0; i < n*(size_t)ldb; i += ((size_t)ldb+1) )\n        for( double *x = B, *e = B+n*n; x < e; x+=ldb+1 )\n            *x += k;\n\n        /* B * (A^*)^T = A    and     B = B^T (Hermitian) */\n\n        /* Solve via Cholesky (positive definite) */\n        r = aa_cla_dposv( 'U', (int)n, (int)m,\n                           B, ldb,\n                           AA_MAT_ARGS(As) );\n\n        /* Solve via LU */\n        /* int *ipiv = AA_MEM_REGION_NEW_N(reg,int,n); */\n        /* r = aa_la_d_sysv( \"U\", n, m, */\n        /*                   B, (size_t)ldb, */\n        /*                   ipiv, */\n        /*                   As->data, As->ld ); */\n\n    }\n\n\n    aa_mem_region_pop( reg, ptrtop );\n\n    return r;\n}\n\nint\naa_dmat_dzdpinv(  const struct aa_dmat *A, double s_min, struct aa_dmat *As)\n{\n\n    aa_la_check_size(A->rows, As->cols);\n    aa_la_check_size(A->cols, As->rows);\n\n    struct aa_mem_region *reg =  aa_mem_region_local_get();\n    void *ptrtop = aa_mem_region_ptr(reg);\n\n    size_t kmin, kmax;\n    double *U, *Vt, *S;\n    s_svd_helper( A, reg,\n                  &kmin, &kmax, &U, &Vt, &S );\n\n    size_t m = A->rows;\n    const int mi = (int)(A->rows);\n    const int ni = (int)(A->cols);\n\n    // \\sum s_i/(s_i**2+k) * v_i * u_i^T\n    aa_dmat_zero(As);\n    double *Asd = As->data;\n    size_t i = 0;\n\n    // Undamped parts\n    for( ; i < kmin && S[i] >= s_min; i ++ ) {\n        cblas_dger( CblasColMajor, ni, mi, 1/S[i],\n                    Vt + i, ni,\n                    U + m*i, 1,\n                    Asd, ni\n            );\n    }\n\n    // Damped parts\n    double s2 = s_min*s_min;\n    for( ; i < kmin; i ++ ) {\n        cblas_dger( CblasColMajor, ni, mi, S[i]/s2,\n                    Vt + i, ni,\n                    U + m*i, 1,\n                    Asd, ni\n            );\n    }\n\n    aa_mem_region_pop( reg, ptrtop );\n\n    return 0;\n\n}\n", "meta": {"hexsha": "b3291373a492b8f84300d23f0eab446b921be827", "size": 21383, "ext": "c", "lang": "C", "max_stars_repo_path": "src/mat.c", "max_stars_repo_name": "dyalab/amino", "max_stars_repo_head_hexsha": "e3063ceeeed7d1a3d55fc0d3071c9aacb4466b22", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 32.0, "max_stars_repo_stars_event_min_datetime": "2015-06-02T20:06:09.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-14T16:49:22.000Z", "max_issues_repo_path": "src/mat.c", "max_issues_repo_name": "dyalab/amino", "max_issues_repo_head_hexsha": "e3063ceeeed7d1a3d55fc0d3071c9aacb4466b22", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 28.0, "max_issues_repo_issues_event_min_datetime": "2016-05-18T20:54:44.000Z", "max_issues_repo_issues_event_max_datetime": "2021-03-22T23:43:23.000Z", "max_forks_repo_path": "src/mat.c", "max_forks_repo_name": "dyalab/amino", "max_forks_repo_head_hexsha": "e3063ceeeed7d1a3d55fc0d3071c9aacb4466b22", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 20.0, "max_forks_repo_forks_event_min_datetime": "2016-01-05T18:55:14.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-22T01:32:20.000Z", "avg_line_length": 25.5167064439, "max_line_length": 92, "alphanum_fraction": 0.5378104101, "num_tokens": 6691, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.36658972248186006, "lm_q2_score": 0.04336579629119585, "lm_q1q2_score": 0.01589745522759436}}
{"text": "\n/*\n* -----------------------------------------------------------------\n*  Binary Search Tree Library --- bst_lib.c\n*  Version: 1.6180\n*  Date: Mar 12, 2010\n* ----------------------------------------------------------------- \n*  Programmer: Americo Barbosa da Cunha Junior\n*              americo.cunhajr@gmail.com\n* -----------------------------------------------------------------\n*  Copyright (c) 2010 by Americo Barbosa da Cunha Junior\n*\n*  This program is free software: you can redistribute it and/or\n*  modify it under the terms of the GNU General Public License as\n*  published by the Free Software Foundation, either version 3 of\n*  the License, or (at your option) any later version.\n*\n*  This program is distributed in the hope that it will be useful,\n*  but WITHOUT ANY WARRANTY; without even the implied warranty of\n*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n*  GNU General Public License for more details.\n*\n*  A copy of the GNU General Public License is available in\n*  LICENSE.txt or http://www.gnu.org/licenses/.\n* -----------------------------------------------------------------\n*  This is the implementation file of a library\n*  to work with binary search trees.\n* -----------------------------------------------------------------\n*/\n\n\n\n\n#include <stdlib.h>\n#include <gsl/gsl_blas.h>\n#include <gsl/gsl_errno.h>\n\n#include \"../include/bst_lib.h\"\n\n\n\n\n/*\n*------------------------------------------------------------\n*   bst_leaf_alloc\n*\n*   This function allocates a struct leaf.\n*\n*   Input:\n*   void\n*\n*   Output:\n*   leaf - pointer to a struct leaf\n*\n*   last update: May 10, 2009\n*------------------------------------------------------------\n*/\n\nbst_leaf *bst_leaf_alloc()\n{\n    bst_leaf *leaf = NULL;\n    \n    /* memory allocation for bst_leaf */\n    leaf = (bst_leaf *) malloc(sizeof(bst_leaf));\n    if ( leaf == NULL )\n        return NULL;\n    \n    /* setting bst_leaf elements equal to NULL */\n    leaf->phi  = NULL;\n    leaf->Rphi = NULL;\n    leaf->A    = NULL;\n    leaf->L    = NULL;\n    \n    return leaf;\n}\n/*------------------------------------------------------------*/\n\n\n\n\n\n/*\n*------------------------------------------------------------\n*   bst_node_alloc\n*\n*   This function allocates a struct node.\n*\n*   Input:\n*   void\n*\n*   Output:\n*   node - pointer to a struct node\n*\n*   last update: May 10, 2009\n*------------------------------------------------------------\n*/\n\nbst_node* bst_node_alloc()\n{\n    bst_node *node = NULL;\n    \n    /* memory allocation for bst_node */\n    node = (bst_node *) malloc(sizeof(bst_node));\n    if ( node == NULL )\n        return NULL;\n    \n    /* setting bst_node elements equal to NULL */\n    node->v      = NULL;\n    node->r_node = NULL;\n    node->l_node = NULL;\n    node->r_leaf = NULL;\n    node->l_leaf = NULL;\n\n    return node;\n}\n/*------------------------------------------------------------*/\n\n\n\n\n\n/*\n*------------------------------------------------------------\n*   bst_leaf_free\n*\n*   This function frees the memory used by a struct leaf.\n*\n*   Input:\n*   leaf - pointer to a struct leaf\n*\n*   Output:\n*   void\n*\n*   last update: May 9, 2009\n*------------------------------------------------------------\n*/\n\nvoid bst_leaf_free(void **leaf_bl)\n{\n    bst_leaf *leaf = NULL;\n    \n    /* checking if leaf_bl is NULL */\n    if ( *leaf_bl == NULL )\n        return;\n    \n    leaf = (bst_leaf *) (*leaf_bl);\n    \n    /* releasing bst_leaf elements */\n    if( leaf->phi != NULL )\n    {\n        gsl_vector_free(leaf->phi);\n        leaf->phi = NULL;\n    }\n    \n    if( leaf->Rphi != NULL )\n    {\n        gsl_vector_free(leaf->Rphi);\n        leaf->Rphi = NULL;\n    }\n    \n    if( leaf->A != NULL )\n    {\n        gsl_matrix_free(leaf->A);\n        leaf->A = NULL;\n    }\n    \n    if( leaf->L != NULL )\n    {\n        gsl_matrix_free(leaf->L);\n        leaf->L = NULL;\n    }\n    \n    /* releasing allocated memory by bst_leaf */\n    free(*leaf_bl);\n    *leaf_bl = NULL;\n    \n    return;\n}\n/*------------------------------------------------------------*/\n\n\n\n\n\n/*\n*------------------------------------------------------------\n*   bst_node_free\n*\n*   This function frees the memory used by a struct node.\n*\n*   Input:\n*   node - pointer to a struct node\n*\n*   Output:\n*   void\n*\n*   last update: Feb 19, 2010\n*------------------------------------------------------------\n*/\n\nvoid bst_node_free(void **node_bl)\n{\n    bst_node *node = NULL;\n    \n    /* checking if node_bl is NULL */\n    if ( *node_bl == NULL )\n        return;\n    \n    node = (bst_node *) (*node_bl);\n    \n    /* releasing allocated memory by bst_node elements */\n    if( node->l_leaf != NULL )\n    {\n        bst_leaf_free((void **)&(node->l_leaf));\n        node->l_leaf = NULL;\n    }\n    \n    if( node->r_leaf != NULL )\n    {\n        bst_leaf_free((void **)&(node->r_leaf));\n        node->r_leaf = NULL;\n    }\n    \n    if( node->l_node != NULL )\n    {\n        bst_node_free((void **)&(node->l_node));\n        node->l_node = NULL;\n    }\n    \n    if( node->r_node != NULL )\n    {\n        bst_node_free((void **)&(node->r_node));\n        node->r_node = NULL;\n    }\n    \n    if( node->v != NULL )\n    {\n        gsl_vector_free(node->v);\n        node->v = NULL;\n    }\n    \n    /* releasing allocated memory by bst_node */\n    free(*node_bl);\n    *node_bl = NULL;\n\n    return;\n}\n/*------------------------------------------------------------*/\n\n\n\n\n\n/*\n*------------------------------------------------------------\n*   bst_leaf_set\n*\n*   This function sets the bst_leaf elements equal to\n*   the input elements and returns GSL_SUCCESS if\n*   there is no problem during its execution.\n*\n*   Input:\n*   phi  - composition\n*   Rphi - reaction mapping\n*   A    - mapping gradient matrix\n*   L    - ellipsoid Cholesky matrix\n*\n*   Output:\n*   leaf - pointer to a struct leaf\n*   success or error\n*\n*   last update: Feb 22, 2009\n*------------------------------------------------------------\n*/\n\nint bst_leaf_set(gsl_vector *phi,gsl_vector *Rphi,\n                    gsl_matrix *A,gsl_matrix *L,bst_leaf *leaf)\n{\n    /* checking if leaf is NULL */\n    if ( leaf == NULL )\n        return GSL_EFAILED;\n    \n    /* setting phi equal to the input vector phi */\n    if ( leaf->phi == NULL )\n        leaf->phi = gsl_vector_calloc(phi->size);\n    \n    gsl_vector_memcpy(leaf->phi,phi);\n    \n    /* setting Rphi equal to the input vector Rphi */\n    if ( leaf->Rphi == NULL )\n        leaf->Rphi = gsl_vector_calloc(Rphi->size);\n    \n    gsl_vector_memcpy(leaf->Rphi,Rphi);\n    \n    /* setting A equal to the input matrix A */\n    if ( leaf->A == NULL )\n        leaf->A = gsl_matrix_calloc(A->size1,A->size2);\n    \n    gsl_matrix_memcpy(leaf->A,A);\n    \n    /* setting L equal to the input matrix L */\n    if ( leaf->L == NULL )\n        leaf->L = gsl_matrix_calloc(L->size1,L->size2);\n    \n    gsl_matrix_memcpy(leaf->L,L);\n    \n    return GSL_SUCCESS;\n}\n/*------------------------------------------------------------*/\n\n\n\n\n\n/*\n*------------------------------------------------------------\n*   bst_cutplane\n*\n*   This function compute the vector ( v = phi_r - phi_l )\n*   and the scalar ( a = (|phi_r|^2-|phi_l|^2)/2 )\n*   which define a cutting plane used to search any\n*   information in the binary search tree.\n*   \n*   Input:\n*   phi_l - left  composition\n*   phi_r - right compositon\n*\n*   Output:\n*   v    - cutting plane normal vector\n*   a    - cutting plane scalar\n*\n*   last update: Feb 27, 2009\n*------------------------------------------------------------\n*/\n\ndouble bst_cutplane(gsl_vector *phi_l,gsl_vector *phi_r,gsl_vector *v)\n{\n    double a1, a2;\n\n    /* v := phi_r */\n    gsl_vector_memcpy(v,phi_r);\n    \n    /* v := phi_r - phi_l */\n    gsl_vector_sub(v,phi_l);\n    \n    /* a1 := |phi_r|^2 */\n    gsl_blas_ddot(phi_r,phi_r,&a1);\n\n    /* a2 := |phi_l|^2 */\n    gsl_blas_ddot(phi_l,phi_l,&a2);\n    \n    return 0.5*(a1-a2);\n}\n/*------------------------------------------------------------*/\n\n\n\n\n\n/*\n*------------------------------------------------------------\n*   bst_node_set\n*\n*   This function set the bst_node elements equal to\n*   the input elements and define the vector and\n*   scalar to do the search for a information.\n*\n*   Input:\n*   l_leaf - left  leaf\n*   r_leaf - right leaf\n*\n*   Output:\n*   node - pointer to a struct node\n*   success or error\n*\n*   last update: Feb 27, 2009\n*------------------------------------------------------------\n*/\n\nint bst_node_set(bst_leaf *l_leaf,bst_leaf *r_leaf,bst_node *node)\n{\n    /* checking if node is NULL */\n    if ( node == NULL )\n        return GSL_EFAILED;\n    \n    /* memory allocation for v */\n    if ( node->v == NULL )\n    \tnode->v = gsl_vector_calloc(r_leaf->phi->size);\n    \n    /* setting v and a */\n    node->a = bst_cutplane(l_leaf->phi,r_leaf->phi,node->v);\n\n    /* setting leaf elements equal to the input leaves */\n    node->l_leaf = l_leaf;\n    node->r_leaf = r_leaf;\n    \n    /* setting node elements equal to NULL */\n    node->l_node = NULL;\n    node->r_node = NULL;\n    \n    return GSL_SUCCESS;\n}\n/*------------------------------------------------------------*/\n\n\n\n\n\n/*\n*------------------------------------------------------------\n*   bst_node_add\n*\n*   This function adds a new node to a given side\n*   of a old node and returns GSL_SUCCESS if\n*   there is no problem during its execution.\n*\n*   Input:\n*   side     - new node side\n*   old_node - pointer to the old node\n*   new_node - pointer to the new node\n*\n*   Output:\n*   success or error\n*\n*   last update: Feb 22, 2009\n*------------------------------------------------------------\n*/\n\nint bst_node_add(int side,bst_node *old_node,bst_node *new_node)\n{\n    if( side == RIGHT )\n    {\n        if( old_node->r_node != NULL )\n            return GSL_EFAILED;\n        else\n        {\n            /* adding a new right node */\n            old_node->r_node = new_node;\n            old_node->r_leaf = NULL;\n            \n            return GSL_SUCCESS;\n        }\n    }\n    else if( side == LEFT )\n    {\n        if( old_node->l_node != NULL )\n            return GSL_EFAILED;\n        else\n        {\n            /* adding a new left node */\n            old_node->l_node = new_node;\n            old_node->l_leaf = NULL;\n            \n            return GSL_SUCCESS;\n        }\n    }\n    else\n        return GSL_EFAILED;\n}\n/*------------------------------------------------------------*/\n\n\n\n\n\n/*\n*------------------------------------------------------------\n*   bst_search\n*\n*   This function searchs for a near composition phi0 in the\n*   binary search tree.\n*\n*   Input:\n*   root     - binary tree root\n*   phi      - composition\n*\n*   Output:\n*   end_leaf - leaf with the near composition\n*   end_node - node with the near composition\n*   side     - near compositon leaf side\n*\n*   last update: Feb 3, 2009\n*------------------------------------------------------------\n*/\n\nint bst_search(bst_node *root,gsl_vector *phi,\n                        bst_node **end_node,bst_leaf **end_leaf)\n{\n    double dot;\n    \n    if( root == NULL )\n    {\n        *end_leaf = NULL;\n        *end_node = NULL;\n        \n        return GSL_EFAILED;\n    }\n    \n    /* dot := v^T*phi */\n    gsl_blas_ddot(root->v,phi,&dot);\n    \n    /* if dot > a then right node else left node */\n    if( dot > root->a )\n    {\n        /* extern node */\n        if( root->r_node == NULL )\n        {\n            *end_leaf = root->r_leaf;\n            *end_node = root;\n            \n            return RIGHT;\n        }\n        else\n            return bst_search(root->r_node,phi,end_node,end_leaf);\n    }\n    else\n    {\n        /* extern node */\n        if( root->l_node == NULL )\n        {\n            *end_leaf = root->l_leaf;\n            *end_node = root;\n            \n            return LEFT;\n        }\n        else\n            return bst_search(root->l_node,phi,end_node,end_leaf);\n    }\n}\n/*------------------------------------------------------------*/\n\n\n\n\n/*\n*------------------------------------------------------------\n*   bst_height\n*\n*   This function computes the binary search tree height.\n*\n*   Input:\n*   root - binary tree root\n*\n*   Output:\n*   height - binary search tree height\n*\n*   last update: Nov 2, 2009\n*------------------------------------------------------------\n*/\n\nint bst_height(bst_node *root)\n{\n    int l_tree_height = 0;\n    int r_tree_height = 0;\n    \n    if ( root != NULL )\n    {\n        l_tree_height = bst_height(root->l_node);\n        r_tree_height = bst_height(root->r_node);\n        \n        if ( l_tree_height > r_tree_height )\n            return l_tree_height + 1;\n        else\n            return r_tree_height + 1;\n    }\n    else\n        return 0;\n    \n}\n/*------------------------------------------------------------*/\n\n", "meta": {"hexsha": "fddb9d328bd60e2b2970c6cbfe137d316e4631d7", "size": 12674, "ext": "c", "lang": "C", "max_stars_repo_path": "CRFlowLib-1.0/src/bst_lib.c", "max_stars_repo_name": "americocunhajr/CRFlowLib", "max_stars_repo_head_hexsha": "35b67f798c1c33118c028691f42b98ba06220eeb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-12-29T12:56:14.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-29T12:56:14.000Z", "max_issues_repo_path": "CRFlowLib-1.0/src/bst_lib.c", "max_issues_repo_name": "americocunhajr/CRFlowLib", "max_issues_repo_head_hexsha": "35b67f798c1c33118c028691f42b98ba06220eeb", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "CRFlowLib-1.0/src/bst_lib.c", "max_forks_repo_name": "americocunhajr/CRFlowLib", "max_forks_repo_head_hexsha": "35b67f798c1c33118c028691f42b98ba06220eeb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-11-15T03:57:44.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-30T01:44:13.000Z", "avg_line_length": 22.1573426573, "max_line_length": 70, "alphanum_fraction": 0.4674925043, "num_tokens": 2997, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4610167941228964, "lm_q2_score": 0.034100426571226035, "lm_q1q2_score": 0.01572086933608986}}
{"text": "#include <stdlib.h>\n#include <stddef.h>\n#include <assert.h>\n#include <stdio.h>\n#include <string.h>\n#include <cblas.h>\n#include \"LCP_Solver.h\"\n#include \"debug.h\"\n\nvoid numericsError(char * functionName, char* message)\n{\n  char output[200] = \"Numerics error - \";\n  strcat(output, functionName);\n  strcat(output, message);\n  strcat(output, \".\\n\");\n  fprintf(stderr, \"%s\", output);\n  exit(EXIT_FAILURE);\n}\n\nvoid prodNumericsMatrix(int sizeX, int sizeY, double alpha, const NumericsMatrix* const A, const double* const x, double beta, double* y)\n{\n  assert(A);\n  assert(x);\n  assert(y);\n  assert(A->size0 == sizeY);\n  assert(A->size1 == sizeX);\n  cblas_dgemv(CblasColMajor, CblasNoTrans, sizeY, sizeX, alpha, A->matrix0, sizeY, x, 1, beta, y, 1);\n}\n\nvoid deleteSolverOptions(SolverOptions* op)\n{\n  if(op)\n  {\n    if (op->iparam != NULL)\n      free(op->iparam);\n    op->iparam = NULL;\n    if (op->dparam != NULL)\n      free(op->dparam);\n    op->dparam = NULL;\n  }\n}\n\nvoid lcp_lexicolemke(LinearComplementarityProblem* problem, double *zlem , double *wlem , int *info , SolverOptions* options)\n{\n  /* matrix M of the lcp */\n  double * M = problem->M->matrix0;\n  assert(M);\n  /* size of the LCP */\n  int dim = problem->size;\n  assert(dim>0);\n  int dim2 = 2 * (dim + 1);\n\n  int i, drive, block, Ifound;\n  int ic, jc;\n  int ITER;\n  int nobasis;\n  int itermax = options->iparam[0];\n\n  i=0;\n  int n = problem->size;\n  double *q = problem->q;\n  \n  while ((i < (n - 1)) && (q[i] >= 0.)) \n    i++;\n  \n  if ((i == (n - 1)) && (q[n - 1] >= 0.))\n  {\n    /* TRIVIAL CASE : q >= 0\n     * z = 0 and w = q is solution of LCP(q,M)\n     */\n    for (int j = 0 ; j < n; j++)\n    {\n      zlem[j] = 0.0;\n      wlem[j] = q[j];\n    }\n    *info = 0;\n    options->iparam[1] = 0;   /* Number of iterations done */\n    options->dparam[1] = 0.0; /* Error */\n    if (options->verboseMode > 0)\n      printf(\"lcp_lexicolemke: found trivial solution for the LCP (positive vector q => z = 0 and w = q). \\n\");\n    return ;\n  }\n  \n  double z0, zb, dblock;\n  double pivot, tovip;\n  double tmp;\n  int *basis;\n  double** A;\n\n  /*output*/\n  options->iparam[1] = 0;\n\n  /* Allocation */\n  basis = (int *)malloc(dim * sizeof(int));\n  A = (double **)malloc(dim * sizeof(double*));\n\n  for (ic = 0 ; ic < dim; ++ic)\n    A[ic] = (double *)malloc(dim2 * sizeof(double));\n\n  /* construction of A matrix such that\n   * A = [ q | Id | -d | -M ] with d = (1,...1)\n   */\n  /* We need to init only the part corresponding to Id */\n  for (ic = 0 ; ic < dim; ++ic)\n    for (jc = 1 ; jc <= dim; ++jc)\n      A[ic][jc] = 0.0;\n\n  for (ic = 0 ; ic < dim; ++ic)\n    for (jc = 0 ; jc < dim; ++jc)\n      A[ic][jc + dim + 2] = -M[dim * jc + ic];\n\n  assert(problem->q);\n\n  for (ic = 0 ; ic < dim; ++ic) A[ic][0] = problem->q[ic];\n\n  for (ic = 0 ; ic < dim; ++ic) A[ic][ic + 1 ] =  1.0;\n  for (ic = 0 ; ic < dim; ++ic) A[ic][dim + 1] = -1.0;\n\n  DEBUG_PRINT(\"total matrix\\n\");\n  DEBUG_EXPR_WE(for (unsigned int i = 0; i < dim; ++i)\n      { for(unsigned int j = 0 ; j < dim2; ++j)\n      { DEBUG_PRINTF(\"%1.2e \", A[i][j]) }\n      DEBUG_PRINT(\"\\n\")});\n  /* End of construction of A */\n\n  Ifound = 0;\n\n\n  for (ic = 0 ; ic < dim  ; ++ic) basis[ic] = ic + 1;\n\n  drive = dim + 1;\n  block = 0;\n  z0 = A[block][0];\n  ITER = 0;\n\n  /* Start research of argmin lexico */\n  /* With this first step the covering vector enter in the basis */\n  for (ic = 1 ; ic < dim ; ++ic)\n  {\n    zb = A[ic][0];\n    if (zb < z0)\n    {\n      z0    = zb;\n      block = ic;\n    }\n    else if (zb == z0)\n    {\n      for (jc = 0 ; jc < dim ; ++jc)\n      {\n        dblock = A[block][1 + jc] - A[ic][1 + jc];\n        if (dblock < 0)\n        {\n          break;\n        }\n        else if (dblock > 0)\n        {\n          block = ic;\n          break;\n        }\n      }\n    }\n  }\n\n  /* Stop research of argmin lexico */\n  DEBUG_PRINTF(\"Pivoting %i and %i\\n\", block, drive);\n\n  pivot = A[block][drive];\n  tovip = 1.0 / pivot;\n\n  /* Pivot < block , drive > */\n  A[block][drive] = 1;\n  for (ic = 0       ; ic < drive ; ++ic) A[block][ic] = A[block][ic] * tovip;\n  for (ic = drive + 1 ; ic < dim2  ; ++ic) A[block][ic] = A[block][ic] * tovip;\n\n  /* */\n\n  for (ic = 0 ; ic < block ; ++ic)\n  {\n    tmp = A[ic][drive];\n    for (jc = 0 ; jc < dim2 ; ++jc) A[ic][jc] -=  tmp * A[block][jc];\n  }\n  for (ic = block + 1 ; ic < dim ; ++ic)\n  {\n    tmp = A[ic][drive];\n    for (jc = 0 ; jc < dim2 ; ++jc) A[ic][jc] -=  tmp * A[block][jc];\n  }\n\n   nobasis = basis[block];\n  basis[block] = drive;\n\n  DEBUG_EXPR_WE( DEBUG_PRINT(\"new basis: \")\n      for (unsigned int i = 0; i < dim; ++i)\n      { DEBUG_PRINTF(\"%i \", basis[i])}\n      DEBUG_PRINT(\"\\n\"));\n  DEBUG_PRINT(\"total matrix\\n\");\n  DEBUG_EXPR_WE(for (unsigned int i = 0; i < dim; ++i)\n      { for(unsigned int j = 0 ; j < dim2; ++j)\n      { DEBUG_PRINTF(\"%1.2e \", A[i][j]) }\n      DEBUG_PRINT(\"\\n\")});\n\n  while (ITER < itermax && !Ifound)\n  {\n\n    ++ITER;\n\n    if (nobasis < dim + 1)      drive = nobasis + (dim + 1);\n    else if (nobasis > dim + 1) drive = nobasis - (dim + 1);\n\n    DEBUG_PRINTF(\"driving variable %i \\n\", drive);\n\n    /* Start research of argmin lexico for minimum ratio test */\n    pivot = 1e20;\n    block = -1;\n\n    for (ic = 0 ; ic < dim ; ++ic)\n    {\n      zb = A[ic][drive];\n      if (zb > 0.0)\n      {\n        z0 = A[ic][0] / zb;\n        if (z0 > pivot) continue;\n        if (z0 < pivot)\n        {\n          pivot = z0;\n          block = ic;\n        }\n        else\n        {\n          for (jc = 1 ; jc < dim + 1 ; ++jc)\n          {\n            assert(block >=0 && \"lcp_lexicolemke: block <0\");\n            dblock = A[block][jc] / pivot - A[ic][jc] / zb;\n            if (dblock < 0.0) break;\n            else if (dblock > 0.0)\n            {\n              block = ic;\n              break;\n            }\n          }\n        }\n      }\n    }\n    if (block == -1)\n    {\n      Ifound = 1;\n      DEBUG_PRINT(\"The pivot column is nonpositive !\\n\"\n          \"It either means that the algorithm failed or that the LCP is infeasible\\n\"\n          \"Check the class of the M matrix to find out the meaning of this\\n\");\n      break;\n    }\n\n    if (basis[block] == dim + 1) Ifound = 1;\n\n    /* Pivot < block , drive > */\n    pivot = A[block][drive];\n    tovip = 1.0 / pivot;\n    A[block][drive] = 1;\n\n    for (ic = 0       ; ic < drive ; ++ic) A[block][ic] = A[block][ic] * tovip;\n    for (ic = drive + 1 ; ic < dim2  ; ++ic) A[block][ic] = A[block][ic] * tovip;\n\n    /* */\n\n    for (ic = 0 ; ic < block ; ++ic)\n    {\n      tmp = A[ic][drive];\n      for (jc = 0 ; jc < dim2 ; ++jc) A[ic][jc] -=  tmp * A[block][jc];\n    }\n    for (ic = block + 1 ; ic < dim ; ++ic)\n    {\n      tmp = A[ic][drive];\n      for (jc = 0 ; jc < dim2 ; ++jc) A[ic][jc] -=  tmp * A[block][jc];\n    }\n\n    nobasis = basis[block];\n    basis[block] = drive;\n\n    DEBUG_EXPR_WE( DEBUG_PRINT(\"new basis: \")\n      for (unsigned int i = 0; i < dim; ++i)\n      { DEBUG_PRINTF(\"%i \", basis[i])}\n      DEBUG_PRINT(\"\\n\"));\n\n    DEBUG_PRINT(\"total matrix\\n\");\n    DEBUG_EXPR_WE(for (unsigned int i = 0; i < dim; ++i)\n      { for(unsigned int j = 0 ; j < dim2; ++j)\n      { DEBUG_PRINTF(\"%1.2e \", A[i][j]) }\n      DEBUG_PRINT(\"\\n\")});\n\n  } /* end while*/\n\n  DEBUG_EXPR_WE( DEBUG_PRINT(\"new basis: \")\n      for (unsigned int i = 0; i < dim; ++i)\n      { DEBUG_PRINTF(\"%i \", basis[i])}\n      DEBUG_PRINT(\"\\n\"));\n\n  DEBUG_PRINT(\"total matrix\\n\");\n  DEBUG_EXPR_WE(for (unsigned int i = 0; i < dim; ++i)\n      { for(unsigned int j = 0 ; j < dim2; ++j)\n      { DEBUG_PRINTF(\"%1.2e \", A[i][j]) }\n      DEBUG_PRINT(\"\\n\")});\n\n  for (ic = 0 ; ic < dim; ++ic)\n  {\n    drive = basis[ic];\n    if (drive < dim + 1)\n    {\n      zlem[drive - 1] = 0.0;\n      wlem[drive - 1] = A[ic][0];\n    }\n    else if (drive > dim + 1)\n    {\n      zlem[drive - dim - 2] = A[ic][0];\n      wlem[drive - dim - 2] = 0.0;\n    }\n  }\n\n  options->iparam[1] = ITER;\n\n  if (Ifound) *info = 0;\n  else *info = 1;\n\n  free(basis);\n\n  for (i = 0 ; i < dim ; ++i) free(A[i]);\n  free(A);\n}\n\nint linearComplementarity_driver(LinearComplementarityProblem* problem, double *z , double *w, SolverOptions* options)\n{\n  /********************\n   * 0 - Check inputs *\n   ********************/\n\n  if (options == NULL)\n    numericsError(\"lcp_driver\", \"null input for solver options\");\n  if (problem == NULL || z == NULL || w == NULL)\n    numericsError(\"lcp_driver\", \"null input for LinearComplementarityProblem and/or unknowns (z,w)\");\n\n  int NoDefaultOptions = options->isSet; /* true(1) if the SolverOptions structure has been filled in else false(0) */\n\n  if (NoDefaultOptions == 0)\n  {\n    numericsError(\"lcp_driver_DenseMatrix\", \"options for solver have not been set\");\n  }\n\n  if (options->verboseMode > 0)\n    printSolverOptions(options);\n\n  /* Output info. : 0: ok -  >0: problem (depends on solver) */\n  int info = -1;\n\n  /******************************************\n   *  1 - Check for trivial solution\n   ******************************************/\n\n  int i = 0;\n  int n = problem->size;\n  double *q = problem->q;\n/*  if (!((options->solverId == SICONOS_LCP_ENUM) && (options->iparam[0] == 1 )))*/\n    {      \n      while ((i < (n - 1)) && (q[i] >= 0.)) i++;\n      if ((i == (n - 1)) && (q[n - 1] >= 0.))\n      {\n        /* TRIVIAL CASE : q >= 0\n         * z = 0 and w = q is solution of LCP(q,M)\n         */\n        for (int j = 0 ; j < n; j++)\n        {\n          z[j] = 0.0;\n          w[j] = q[j];\n        }\n        info = 0;\n        options->dparam[1] = 0.0; /* Error */\n        if (options->verboseMode > 0)\n          printf(\"LCP_driver_DenseMatrix: found trivial solution for the LCP (positive vector q => z = 0 and w = q). \\n\");\n        return info;\n      }\n    }\n\n  /*************************************************\n   *  2 - Call Lemke solver (if no trivial sol.)\n   *************************************************/\n\n  if (options->verboseMode == 1)\n    printf(\" ========================== Call Lemke solver for Linear Complementarity problem ==========================\\n\");\n\n  /****** Lemke algorithm ******/\n  /* IN: itermax\n     OUT: iter */\n   lcp_lexicolemke(problem, z , w , &info , options);\n\n  /*************************************************\n   *  3 - Computes w = Mz + q and checks validity\n   *************************************************/\n  if (options->filterOn > 0)\n  {\n    int info_ = lcp_compute_error(problem, z, w, options->dparam[0], &(options->dparam[1]),\n\t\t\t\t  options->verboseMode);\n    if (info <= 0) /* info was not setor the solver was happy */\n      info = info_;\n  }\n  \n  return info;\n}\n\nvoid lcp_compute_error_only(unsigned int n, double *z , double *w, double * error)\n{\n  /* Checks complementarity */\n\n  *error = 0.;\n  double zi, wi;\n  for (unsigned int i = 0 ; i < n ; i++)\n  {\n    zi = z[i];\n    wi = w[i];\n    if (zi < 0.0)\n    {\n      *error += -zi;\n      if (wi < 0.0) *error += zi * wi;\n    }\n    if (wi < 0.0) *error += -wi;\n    if ((zi > 0.0) && (wi > 0.0)) *error += zi * wi;\n  }\n}\n\nint lcp_compute_error(LinearComplementarityProblem* problem, double *z , double *w, double tolerance, \n\t\t      double * error, int verbose)\n{\n  /* Checks inputs */\n  if (problem == NULL || z == NULL || w == NULL)\n    numericsError(\"lcp_compute_error\", \"null input for problem and/or z and/or w\");\n\n  /* Computes w = Mz + q */\n  int incx = 1, incy = 1;\n  unsigned int n = problem->size;\n  cblas_dcopy(n , problem->q , incx , w , incy);  // w <-q\n  prodNumericsMatrix(n, n, 1.0, problem->M, z, 1.0, w);\n  double normq = cblas_dnrm2(n , problem->q , incx);\n  lcp_compute_error_only(n, z, w, error);\n  *error = *error / (normq + 1.0); /* Need some comments on why this is needed */\n  if (*error > tolerance)\n  {\n    if (verbose > 0) \n\tprintf(\" Numerics - lcp_compute_error : error = %g > tolerance = %g.\\n\", *error, tolerance);\n    return 1;\n  }\n  else\n    return 0;\n}\n\nint linearComplementarity_lexicolemke_setDefaultSolverOptions(SolverOptions* options)\n{\n  /* if (options->verboseMode > 0) */\n  /* { */\n  /*   printf(\"Set the Default SolverOptions for the Lemke Solver\\n\"); */\n  /* } */\n\n  options->isSet = 1;\n  options->filterOn = 1;\n  options->iSize = 5;\n  options->dSize = 5;\n  options->iparam = (int *)calloc(options->iSize, sizeof(int));\n  options->dparam = (double *)calloc(options->dSize, sizeof(double));\n  options->verboseMode = 0;\n  options->dparam[0] = 1e-6;\n  options->iparam[0] = 10000;\n  return 0;\n}\n\nvoid printSolverOptions(SolverOptions* options)\n{\n  printf(\"\\n ========== Numerics Non Smooth Solver parameters: \\n\");\n  if (options->isSet == 0)\n    printf(\"The solver parameters have not been set. \\t options->isSet = %i \\n\", options->isSet);\n  else\n  {\n    printf(\"The solver parameters below have  been set \\t options->isSet = %i\\n\", options->isSet);\n    printf(\"Name of the solver\\t\\t\\t\\t Lemke \\n\");\n    if (options->iparam != NULL)\n    {\n      printf(\"int parameters \\t\\t\\t\\t\\t options->iparam\\n\");\n      printf(\"size of the int parameters\\t\\t\\t options->iSize = %i\\n\", options->iSize);\n      for (int i = 0; i < options->iSize; ++i)\n        printf(\"\\t\\t\\t\\t\\t\\t options->iparam[%i] = %d\\n\", i, options->iparam[i]);\n    }\n    if (options->dparam != NULL)\n    {\n      printf(\"double parameters \\t\\t\\t\\t options->dparam\\n\");\n      printf(\"size of the double parameters\\t\\t\\t options->dSize = %i\\n\", options->dSize);\n      for (int i = 0; i < options->iSize; ++i)\n        printf(\"\\t\\t\\t\\t\\t\\t options->dparam[%i] = %.6le\\n\", i, options->dparam[i]);\n    }\n  }\n\n  printf(\"See Lemke documentation for parameters definition)\\n\");\n  printf(\"\\n\");\n}\n", "meta": {"hexsha": "06d261667033f9295a553048e6bbf8bfbe5a4863", "size": 13446, "ext": "c", "lang": "C", "max_stars_repo_path": "src/LCP_Solver.c", "max_stars_repo_name": "fairbrot/Cones.jl", "max_stars_repo_head_hexsha": "653c19c6553643a15a535e82d763901c2fe90356", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2020-11-07T23:52:10.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-15T17:21:29.000Z", "max_issues_repo_path": "src/LCP_Solver.c", "max_issues_repo_name": "fairbrot/Cones.jl", "max_issues_repo_head_hexsha": "653c19c6553643a15a535e82d763901c2fe90356", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/LCP_Solver.c", "max_forks_repo_name": "fairbrot/Cones.jl", "max_forks_repo_head_hexsha": "653c19c6553643a15a535e82d763901c2fe90356", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.0, "max_line_length": 137, "alphanum_fraction": 0.5145768258, "num_tokens": 4384, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4960938294709195, "lm_q2_score": 0.03161876441702708, "lm_q1q2_score": 0.01568587392278181}}
{"text": "\n/*\n* -----------------------------------------------------------------\n*  In Situ Adaptive Tabulation Library --- isat_lib.c\n*  Version: 1.6180\n*  Date: Nov 15, 2010\n* ----------------------------------------------------------------- \n*  Programmer: Americo Barbosa da Cunha Junior\n*              americo.cunhajr@gmail.com\n* -----------------------------------------------------------------\n*  Copyright (c) 2010 by Americo Barbosa da Cunha Junior\n*\n*  This program is free software: you can redistribute it and/or\n*  modify it under the terms of the GNU General Public License as\n*  published by the Free Software Foundation, either version 3 of\n*  the License, or (at your option) any later version.\n*\n*  This program is distributed in the hope that it will be useful,\n*  but WITHOUT ANY WARRANTY; without even the implied warranty of\n*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n*  GNU General Public License for more details.\n*\n*  A copy of the GNU General Public License is available in\n*  LICENSE.txt or http://www.gnu.org/licenses/.\n* -----------------------------------------------------------------\n*  This is the implementation file of a library\n*  to work with ISAT algorithm.\n* -----------------------------------------------------------------\n*/\n\n\n\n\n#include <stdlib.h>\n#include <math.h>\n#include <time.h>\n#include <gsl/gsl_math.h>\n#include <gsl/gsl_errno.h>\n\n#include \"../include/thrm_lib.h\"\n#include \"../include/ell_lib.h\"\n#include \"../include/ode_lib.h\"\n#include \"../include/isat_lib.h\"\n\n\n\n\n/*\n*------------------------------------------------------------\n*   isat_alloc\n*\n*   This function alocates memory for a struct isat.\n*\n*   Output:\n*   isat - pointer to a struct isat\n*\n*   last update: Jul 13, 2010\n*------------------------------------------------------------\n*/\n\nisat_wrk *isat_alloc()\n{\n    /* memory allocation for isat_wrk */\n    isat_wrk *isat = NULL;\n    isat = (isat_wrk *) malloc(sizeof(isat_wrk));\n    if ( isat == NULL )\n        return NULL;\n    \n    /* setting isat_wrk elements equal NULL and 0.0 */\n    isat->root     = NULL;\n    isat->lf       = 0;\n    isat->nd       = 0;\n    isat->add      = 0;\n    isat->grw      = 0;\n    isat->rtv      = 0;\n    isat->dev      = 0;\n    isat->hgt      = 0;\n    isat->max_lf   = 0;\n    isat->time_add = 0.0;\n    isat->time_grw = 0.0;\n    isat->time_rtv = 0.0;\n    isat->time_dev = 0.0;\n    \n    return isat;\n}\n/*------------------------------------------------------------*/\n\n\n\n\n/*\n*------------------------------------------------------------\n*   isat_free\n*\n*   This function frees the memory used by a struct isat.\n*\n*   Input:\n*   isat - pointer to a struct isat\n*\n*   last update: May 10, 2009\n*------------------------------------------------------------\n*/\n\nvoid isat_free(void **isat_bl)\n{\n    isat_wrk *isat = NULL;\n    \n    /* checking if isat_bl is NULL */\n    if ( *isat_bl == NULL )\n        return;\n    \n    isat = (isat_wrk *) (*isat_bl);\n    \n    /* releasing allocated memory by isat_wrk elements */\n    if( isat->root != NULL )\n    {\n        bst_node_free((void **)&(isat->root));\n        isat->root = NULL;\n    }\n    \n    /* releasing allocated memory by isat_wrk */\n    free(*isat_bl);\n    *isat_bl = NULL;\n    \n    return;\n}\n/*------------------------------------------------------------*/\n\n\n\n\n/*\n*------------------------------------------------------------\n*   isat_set\n*\n*   This function initiates ISAT binary search tree.\n*\n*   Input:\n*   isat - pointer to a struct isat\n*\n*   last update: May 13, 2009\n*------------------------------------------------------------\n*/\n\nint isat_set(isat_wrk *isat)\n{\n    /* checking if isat is NULL */\n    if ( isat == NULL )\n        return GSL_EINVAL;\n    \n    /* memory allocation for binary search tree root */\n    if ( isat->root == NULL )\n    {\n        isat->root = bst_node_alloc();\n        if ( isat->root == NULL )\n        {\n            free(isat);\n            isat = NULL;\n            return GSL_EINVAL;\n        }\n    }\n    \n    return GSL_SUCCESS;\n}\n/*------------------------------------------------------------*/\n\n\n\n\n/*\n*------------------------------------------------------------\n*   isat_statistics\n*\n*   This function prints on the screen informations\n*   about the isat workspace.\n*\n*   Input:\n*   isat - pointer to a struct isat\n*\n*   last update: Jul 13, 2010\n*------------------------------------------------------------\n*/\n\nvoid isat_statistics(isat_wrk *isat)\n{\n    double time_add;\n    double time_grw;\n    double time_rtv;\n    double time_dev;\n    \n    time_add = (double) (isat->time_add / CLOCKS_PER_SEC) / isat->add;\n    time_grw = (double) (isat->time_grw / CLOCKS_PER_SEC) / isat->grw;\n    time_rtv = (double) (isat->time_rtv / CLOCKS_PER_SEC) / isat->rtv;\n    time_dev = (double) (isat->time_dev / CLOCKS_PER_SEC) / isat->dev;\n    \n    printf(\"\\n ISAT statistics:\");\n    printf(\"\\n # of adds         = %d\",   isat->add);\n    printf(\"\\n # of grows        = %d\",   isat->grw);\n    printf(\"\\n # of retrieves    = %d\",   isat->rtv);\n    printf(\"\\n # of dir. eval.   = %d\",   isat->dev);\n    printf(\"\\n # of leaves       = %d\",   isat->lf);\n    printf(\"\\n # of nodes        = %d\",   isat->nd);\n    printf(\"\\n tree height       = %d\\n\", isat->hgt);\n    \n    printf(\"\\n average values for CPU time (s):\");\n    printf(\"\\n add: %+.6e\",time_add);\n    printf(\"\\n grw: %+.6e\",time_grw);\n    printf(\"\\n rtv: %+.6e\",time_rtv);\n    printf(\"\\n dev: %+.6e\",time_dev);\n    \n    return;\n}\n/*------------------------------------------------------------*/\n\n\n\n\n/*\n* -----------------------------------------------------------------\n*   isat_input\n*\n*   This function receives ISAT parameters.\n*\n*   Input:\n*   max_lf - maximum value of tree leaves\n*   etol   - ISAT error tolerance\n*   n0     - factor to multiply by unit roundoff\n*\n*   Output:\n*   success or error\n*\n*   last update: Feb 25, 2010\n* -----------------------------------------------------------------\n*/\n\nint isat_input(unsigned int *max_lf,double *etol,double *n0)\n{\n    printf(\"\\n Input ISAT parameters:\\n\");\n    \n    printf(\"\\n maximum of tree leaves:\");\n    scanf(\"%d\", max_lf);\n    printf(\"\\n %d\\n\", *max_lf);\n    if( *max_lf <= 0 )\n\tGSL_ERROR(\" max_lf must be a positive integer (max_lf > 0)\",GSL_EINVAL);\n\n    printf(\"\\n ISAT error tolerance:\");\n    scanf(\"%lf\", etol);\n    printf(\"\\n %+.1e\\n\", *etol);\n    if( *etol < 0.0 )\n\tGSL_ERROR(\" etol must be grather than zero (etol > 0.0)\",GSL_EINVAL);\n    \n    printf(\"\\n Unit roundoff multiple:\");\n    scanf(\"%lf\", n0);\n    printf(\"\\n %+.1e\\n\", *n0);\n    if( *n0 < 0.0 )\n\tGSL_ERROR(\" n0 must be grather than zero (n0 > 0.0)\",GSL_EINVAL);\n    \n    return GSL_SUCCESS;\n}\n/*----------------------------------------------------------------*/\n\n\n\n\n/*\n*------------------------------------------------------------\n*   isat_eoa_matrix\n*\n*   This function computes the EOA matrix in Cholesky form.\n*   \n*   Input:\n*   A    - gradient matrix\n*   n0   - factor to multiply by unit roundoff\n*   etol - error tolerance\n*\n*   Output:\n*   L    - EOA Cholesky matrix\n*\n*   last update: Feb 19, 2010\n*------------------------------------------------------------\n*/\n\nvoid isat_eoa_mtrx(gsl_matrix *A,double etol,double n0,\n\t\t\t\t\t\tgsl_matrix *L)\n{\n    unsigned int i;\n    double  eps_max   = 0.5;\n    double  eps_min   = etol/(n0*DBL_EPSILON);\n    gsl_matrix *Aetol = NULL;\n    gsl_matrix *V     = NULL;\n    gsl_vector *sig   = NULL;\n\n    /* memory allocation */\n    Aetol = gsl_matrix_calloc(A->size2,A->size2);\n    V     = gsl_matrix_calloc(A->size2,A->size2);\n    sig   = gsl_vector_calloc(A->size2);\n    \n    /* Aetol := A */\n    gsl_matrix_memcpy(Aetol,A);\n    \n    /* Aetol := (1/etol).A */\n    gsl_matrix_scale (Aetol,1.0/etol);\n\n    /* Aetol = U*sig*V^T */\n    ell_psd2eig(Aetol,V,sig);\n\n    /* eliminating small and large singular values */\n    for ( i = 0; i < sig->size; i++ )\n        sig->data[i] = GSL_MIN( GSL_MAX(sig->data[i],eps_max), eps_min);\n    \n    /* V*sig^2*V^T = L*L^T */\n    ell_eig2chol(V,sig,L);\n    \n    /* releasing allocated memory */\n    gsl_vector_free(sig);\n    gsl_matrix_free(V);\n    gsl_matrix_free(Aetol);\n    sig   = NULL;\n    V     = NULL;\n    Aetol = NULL;\n    \n    return;\n}\n/*------------------------------------------------------------*/\n\n\n\n\n/*\n*------------------------------------------------------------\n*   isat_lerror\n*\n*   This function computes the local error defined as\n*\n*   eps = 2-norm(Rl(phi)- R(phi)) where\n*\n*   Rl(phi) = R(phi0) + A*(phi-phi0).\n*\n*   Input:\n*   Rphi  - reaction mapping of phi\n*   Rphi0 - reaction mapping of phi0\n*   A     - mapping gradient matrix\n*   phi   - query composition\n*   phi0  - initial composition\n*\n*   Output:\n*   eps   - local error\n*\n*   last update: Feb 19, 2010\n*------------------------------------------------------------\n*/\n\ndouble isat_lerror(gsl_vector *Rphi,gsl_vector *Rphi0,\n\t\tgsl_matrix *A,gsl_vector *phi,gsl_vector *phi0)\n{\n    double eps;\n    gsl_vector *Rlphi = NULL;\n    \n    /* memory allocation for Rlphi */\n    Rlphi = gsl_vector_calloc(phi->size);\n    \n    /* Rlphi := R(phi0) + A*(phi-phi0) */\n    linear_approx(phi,phi0,Rphi0,A,Rlphi);\n    \n    /* Rlphi := Rl(phi) - R(phi) */\n    gsl_vector_sub(Rlphi,Rphi);\n    \n    /* eps := 2-norm(Rl(phi) - R(phi)) */\n    eps = gsl_blas_dnrm2(Rlphi);\n    \n    /* releasing allocated memory */\n    gsl_vector_free(Rlphi);\n    Rlphi = NULL;\n    \n    return eps;\n}\n/*------------------------------------------------------------*/\n\n\n\n\n/*\n*------------------------------------------------------------\n*   isat4\n*\n*   This function executes the 4-th version of the\n*   in situ adaptive tabulation algorithm.\n*\n*   \n*   Input:\n*   isat      - isat workspace\n*   thrm_data - thermochemistry workspace\n*   etol      - error tolerance\n*   n0        - factor to multiply by unit roundoff\n*   t0        - initial time\n*   delta_t   - time step\n*   phi       - query composition\n*   A         - mapping gradient matrix\n*   L         - EOA Cholesky matrix\n*\n*   Output:\n*   Rphi      - reaction mapping\n*   success or error\n*\n*   last update: Nov 15, 2010\n*------------------------------------------------------------\n*/\n\nint isat4(isat_wrk *isat,void *thrm_data,void *cvode_mem,\n\t    double etol,double n0,double t0,double delta_t,\n    gsl_vector *phi,gsl_matrix *A,gsl_matrix *L,gsl_vector *Rphi)\n{\n    clock_t cpu_start = clock();\n    \n    /* ISAT first step */\n    if( isat->lf == 0 )\n    {\n        int flag;\n        bst_leaf *first_leaf = NULL;\n\t\n\t/* memory allocation for first_leaf */\n        first_leaf = bst_leaf_alloc();\n\tif ( first_leaf == NULL )\n                return GSL_ENOMEM;\n        \n        /* performing direct integration */\n        flag = odesolver_reinit(thrm_eqs,thrm_data,t0,\n                                        ATOL,RTOL,phi,cvode_mem);\n        if ( flag != GSL_SUCCESS )\n            return flag;\n        \n        flag = odesolver(cvode_mem,delta_t,Rphi);\n        if ( flag != GSL_SUCCESS )\n            return flag;\n        \n        /* computing the mapping gradient matrix */\n        flag = gradient(thrm_eqs,thrm_data,cvode_mem,t0,delta_t,\n                                                ATOL,RTOL,phi,Rphi,A);\n        if ( flag != GSL_SUCCESS )\n            return flag;\n        \n        /* computing EOA Cholesky matrix */\n        isat_eoa_mtrx(A,etol,n0,L);\n        \n        /* setting first leaf elements */\n        bst_leaf_set(phi,Rphi,A,L,first_leaf);\n        isat->root->r_leaf = first_leaf;\n        \n        /* updating leaves and height counters */\n        isat->lf++;\n        isat->hgt = bst_height(isat->root);\n        \n        return GSL_SUCCESS;\n    }\n    \n    \n    /* ISAT second and following steps */\n    int side, flag;\n    double dot         = 0.0;\n    bst_leaf *end_leaf = NULL;\n    bst_node *end_node = NULL;\n    \n    \n    /* searching for the near composition in binary search tree */\n    if( isat->lf > 1 )\n\tside = bst_search(isat->root,phi,&end_node,&end_leaf);\n    else\n    {\n        end_node = isat->root;\n        end_leaf = isat->root->r_leaf;\n        side     = RIGHT;\n    }\n    \n    /* checking if the near composition is inside EOA */\n    dot = ell_pt_in(phi,end_leaf->phi,end_leaf->L);\n    if( gsl_fcmp(dot,1.0,ATOL) < 1 )\n    {\n        /* computing linear approximation */\n        linear_approx(phi,end_leaf->phi,end_leaf->Rphi,end_leaf->A,Rphi);\n        \n        /* updating counters */\n        isat->rtv++;\n\tisat->time_rtv += clock() - cpu_start;\n        \n        return GSL_SUCCESS;\n    }\n    else\n    {\n        double lerror = 0.0;\n\t\n        /* performing direct integration */\n        flag = odesolver_reinit(thrm_eqs,thrm_data,t0,\n                                        ATOL,RTOL,phi,cvode_mem);\n        if ( flag != GSL_SUCCESS )\n            return flag;\n        \n        flag = odesolver(cvode_mem,delta_t,Rphi);\n        if ( flag != GSL_SUCCESS )\n            return flag;\n        \n        /* computing ISAT local error */\n        lerror = isat_lerror(Rphi,end_leaf->Rphi,\n                            end_leaf->A,phi,end_leaf->phi);\n        \n        /* checking if lerror is greater than etol */\n        if( gsl_fcmp(lerror,etol,ATOL) < 1 )\n        {\n            /* growing the EOA */\n            ell_pt_modify(phi,end_leaf->phi,end_leaf->L);\n            \n            /* updating counters */\n            isat->grw++;\n\t    isat->time_grw += clock() - cpu_start;\n            \n            return GSL_SUCCESS;\n        }\n        else\n        {\n\t    /* checking if the maximum # of leaves was excced */\n\t    if( isat->lf > isat->max_lf )\n\t    {\n\t        /*  updating counter */\n\t        isat->dev++;\n\t\tisat->time_dev +=  clock() - cpu_start;\n\t\t\n\t\treturn GSL_SUCCESS;\n\t    }\n\t    \n            bst_leaf *new_leaf = NULL;\n            \n\t    /* memory allocation */\n            new_leaf = bst_leaf_alloc();\n            if ( new_leaf == NULL )\n                return GSL_ENOMEM;\n            \n            /* computing the mapping gradient matrix */\n            flag = gradient(thrm_eqs,thrm_data,cvode_mem,t0,delta_t,\n                                                ATOL,RTOL,phi,Rphi,A);\n            if ( flag != GSL_SUCCESS )\n\t\treturn flag;\n            \n            /* computing EOA Cholesky matrix */\n            isat_eoa_mtrx(A,etol,n0,L);\n            \n            /* setting new_leaf elements */\n            bst_leaf_set(phi,Rphi,A,L,new_leaf);\n            \n            /* cheking if binary search tree has more than one leaf */\n            if( isat->lf > 1 )\n            {\n                bst_node *new_node = NULL;\n\t\t\n\t\t/* memory allocation for new node */\n                new_node = bst_node_alloc();\n                if ( new_node == NULL )\n                    return GSL_ENOMEM;\n                \n\t\t/* setting the leaves of the new node */\n                bst_node_set(end_leaf,new_leaf,new_node);\n\t\t\n\t\t/* adding the new node to the tree */\n                bst_node_add(side,end_node,new_node);\n            }\n\t    else\n                bst_node_set(end_leaf,new_leaf,end_node);\n            \n            /* updating counters */\n            isat->add++;\n            isat->lf++;\n            isat->nd++;\n            isat->hgt = bst_height(isat->root);\n\t    isat->time_add += clock() - cpu_start;\n            \n            return GSL_SUCCESS;\n        }\n    }\n}\n/*------------------------------------------------------------*/\n", "meta": {"hexsha": "7449bade9589b495b01864a58239d732efc987f0", "size": 15285, "ext": "c", "lang": "C", "max_stars_repo_path": "CRFlowLib-1.0/src/isat_lib.c", "max_stars_repo_name": "americocunhajr/CRFlowLib", "max_stars_repo_head_hexsha": "35b67f798c1c33118c028691f42b98ba06220eeb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-12-29T12:56:14.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-29T12:56:14.000Z", "max_issues_repo_path": "CRFlowLib-1.0/src/isat_lib.c", "max_issues_repo_name": "americocunhajr/CRFlowLib", "max_issues_repo_head_hexsha": "35b67f798c1c33118c028691f42b98ba06220eeb", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "CRFlowLib-1.0/src/isat_lib.c", "max_forks_repo_name": "americocunhajr/CRFlowLib", "max_forks_repo_head_hexsha": "35b67f798c1c33118c028691f42b98ba06220eeb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-11-15T03:57:44.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-30T01:44:13.000Z", "avg_line_length": 26.3989637306, "max_line_length": 73, "alphanum_fraction": 0.4877330716, "num_tokens": 3945, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.38121955219593834, "lm_q2_score": 0.04084571722347213, "lm_q1q2_score": 0.015571186029053972}}
{"text": "#include \"jfftw_complex_Plan.h\"\n#include <fftw.h>\n\n/*\n * Class:     jfftw_complex_Plan\n * Method:    createPlan\n * Signature: (III)V\n */\nJNIEXPORT void JNICALL Java_jfftw_complex_Plan_createPlan( JNIEnv *env, jobject obj, jint n, jint dir, jint flags )\n{\n\tjclass clazz;\n\tjfieldID id;\n\tjbyteArray arr;\n\tunsigned char* carr;\n\n\tif( sizeof( jdouble ) != sizeof( fftw_real ) )\n\t{\n\t\t(*env)->ThrowNew( env, (*env)->FindClass( env, \"java/lang/RuntimeException\" ), \"jdouble and fftw_real are incompatible\" );\n\t\treturn;\n\t}\n\n\tclazz = (*env)->GetObjectClass( env, obj );\n\tid    = (*env)->GetFieldID( env, clazz, \"plan\", \"[B\" );\n\tarr   = (*env)->NewByteArray( env, sizeof( fftw_plan ) );\n\tcarr  = (*env)->GetByteArrayElements( env, arr, 0 );\n\n\t(*env)->MonitorEnter( env, (*env)->FindClass( env, \"jfftw/Plan\" ) );\n\n\t*(fftw_plan*)carr = fftw_create_plan( n, dir, flags );\n\n\t(*env)->MonitorExit( env, (*env)->FindClass( env, \"jfftw/Plan\" ) );\n\n\t(*env)->ReleaseByteArrayElements( env, arr, carr, 0 );\n\t(*env)->SetObjectField( env, obj, id, arr );\n}\n/*\n * Class:     jfftw_complex_Plan\n * Method:    createPlanSpecific\n * Signature: (III[DI[DI)V\n */\nJNIEXPORT void JNICALL Java_jfftw_complex_Plan_createPlanSpecific( JNIEnv *env, jobject obj, jint n, jint dir, jint flags, jdoubleArray in, jint idist, jdoubleArray out, jint odist )\n{\n\tjclass clazz;\n\tjfieldID id;\n\tjbyteArray arr;\n\tunsigned char* carr;\n\tdouble *cin, *cout;\n\n\tif( sizeof( jdouble ) != sizeof( fftw_real ) )\n\t{\n\t\t(*env)->ThrowNew( env, (*env)->FindClass( env, \"java/lang/RuntimeException\" ), \"jdouble and fftw_real are incompatible\" );\n\t\treturn;\n\t}\n\n\tclazz = (*env)->GetObjectClass( env, obj );\n\tid    = (*env)->GetFieldID( env, clazz, \"plan\", \"[B\" );\n\tarr   = (*env)->NewByteArray( env, sizeof( fftw_plan ) );\n\tcarr  = (*env)->GetByteArrayElements( env, arr, 0 );\n\tcin   = (*env)->GetDoubleArrayElements( env, in, 0 );\n\tcout  = (*env)->GetDoubleArrayElements( env, out, 0 );\n\n\t(*env)->MonitorEnter( env, (*env)->FindClass( env, \"jfftw/Plan\" ) );\n\n\t*(fftw_plan*)carr = fftw_create_plan_specific( n, dir, flags, (fftw_complex*)cin, idist, (fftw_complex*)cout, odist );\n\n\t(*env)->MonitorExit( env, (*env)->FindClass( env, \"jfftw/Plan\" ) );\n\n\t(*env)->ReleaseDoubleArrayElements( env, in, cin, 0 );\n\t(*env)->ReleaseDoubleArrayElements( env, out, cout, 0 );\n\t(*env)->ReleaseByteArrayElements( env, arr, carr, 0 );\n\t(*env)->SetObjectField( env, obj, id, arr );\n}\n/*\n * Class:     jfftw_complex_Plan\n * Method:    destroyPlan\n * Signature: ()V\n */\nJNIEXPORT void JNICALL Java_jfftw_complex_Plan_destroyPlan( JNIEnv* env, jobject obj )\n{\n\tjclass clazz = (*env)->GetObjectClass( env, obj );\n\tjfieldID id = (*env)->GetFieldID( env, clazz, \"plan\", \"[B\" );\n\tjbyteArray arr = (jbyteArray)(*env)->GetObjectField( env, obj, id );\n\tunsigned char* carr = (*env)->GetByteArrayElements( env, arr, 0 );\n\n\tfftw_destroy_plan( *(fftw_plan*)carr );\n\n\t(*env)->ReleaseByteArrayElements( env, arr, carr, 0 );\n\t(*env)->SetObjectField( env, obj, id, NULL );\n}\n/*\n * Class:     jfftw_complex_Plan\n * Method:    transform\n * Signature: ([D)[D\n */\nJNIEXPORT jdoubleArray JNICALL Java_jfftw_complex_Plan_transform___3D( JNIEnv* env, jobject obj, jdoubleArray in )\n{\n\tjdouble *cin, *cout;\n\tjdoubleArray out;\n\tint i;\n\n\tjclass clazz = (*env)->GetObjectClass( env, obj );\n\tjfieldID id = (*env)->GetFieldID( env, clazz, \"plan\", \"[B\" );\n\tjbyteArray arr = (jbyteArray)(*env)->GetObjectField( env, obj, id );\n\tunsigned char* carr = (*env)->GetByteArrayElements( env, arr, 0 );\n\tfftw_plan plan = *(fftw_plan*)carr;\n\tif( plan->n * 2 != (*env)->GetArrayLength( env, in ) )\n\t{\n\t\t(*env)->ThrowNew( env, (*env)->FindClass( env, \"java/lang/IndexOutOfBoundsException\" ), \"the Plan was created for a different length\" );\n\t\t(*env)->ReleaseByteArrayElements( env, arr, carr, 0 );\n\t\treturn NULL;\n\t}\n\n\tcin = (*env)->GetDoubleArrayElements( env, in, 0 );\n\n\tif( ! plan->flags & FFTW_THREADSAFE )\n\t{\n\t\t// synchronization\n\t\t(*env)->MonitorEnter( env, obj );\n\t}\n\n\tif( plan->flags & FFTW_IN_PLACE )\n\t{\n\t\tout = in;\n\n\t\tfftw_one( plan, (fftw_complex*)cin, NULL );\n\t}\n\telse\n\t{\n\t\tout = (*env)->NewDoubleArray( env, plan->n * 2 );\n\t\tcout = (*env)->GetDoubleArrayElements( env, out, 0 );\n\n\t\tfftw_one( plan, (fftw_complex*)cin, (fftw_complex*)cout );\n\n\t\t(*env)->ReleaseDoubleArrayElements( env, out, cout, 0 );\n\t}\n\n\tif( ! plan->flags & FFTW_THREADSAFE )\n\t{\n\t\t// synchronization\n\t\t(*env)->MonitorEnter( env, obj );\n\t}\n\n\t(*env)->ReleaseByteArrayElements( env, arr, carr, 0 );\n\t(*env)->ReleaseDoubleArrayElements( env, in, cin, 0 );\n\treturn out;\n}\n/*\n * Class:     jfftw_complex_Plan\n * Method:    transform\n * Signature: (I[DII[DII)V\n */\nJNIEXPORT void JNICALL Java_jfftw_complex_Plan_transform__I_3DII_3DII( JNIEnv *env, jobject obj, jint howmany, jdoubleArray in, jint istride, jint idist, jdoubleArray out, jint ostride, jint odist )\n{\n\tjdouble *cin, *cout;\n\tint i;\n\n\tjclass clazz = (*env)->GetObjectClass( env, obj );\n\tjfieldID id = (*env)->GetFieldID( env, clazz, \"plan\", \"[B\" );\n\tjbyteArray arr = (jbyteArray)(*env)->GetObjectField( env, obj, id );\n\tunsigned char* carr = (*env)->GetByteArrayElements( env, arr, 0 );\n\tfftw_plan plan = *(fftw_plan*)carr;\n\tif( (howmany - 1) * idist * 2 + plan->n * istride * 2 != (*env)->GetArrayLength( env, in ) )\n\t{\n\t\t(*env)->ThrowNew( env, (*env)->FindClass( env, \"java/lang/IndexOutOfBoundsException\" ), \"the Plan was created for a different length (in)\" );\n\t\t(*env)->ReleaseByteArrayElements( env, arr, carr, 0 );\n\t\treturn;\n\t}\n\tif( (howmany - 1) * odist * 2 + plan->n * ostride * 2 != (*env)->GetArrayLength( env, out ) )\n\t{\n\t\t(*env)->ThrowNew( env, (*env)->FindClass( env, \"java/lang/IndexOutOfBoundsException\" ), \"the Plan was created for a different length (out)\" );\n\t\t(*env)->ReleaseByteArrayElements( env, arr, carr, 0 );\n\t\treturn;\n\t}\n\n\tcin = (*env)->GetDoubleArrayElements( env, in, 0 );\n\tcout = (*env)->GetDoubleArrayElements( env, out, 0 );\n\n\tif( ! plan->flags & FFTW_THREADSAFE )\n\t{\n\t\t// synchronization\n\t\t(*env)->MonitorEnter( env, obj );\n\t}\n\tfftw( plan, howmany, (fftw_complex*)cin, istride, idist, (fftw_complex*)cout, ostride, odist );\n\tif( ! plan->flags & FFTW_THREADSAFE )\n\t{\n\t\t// synchronization\n\t\t(*env)->MonitorExit( env, obj );\n\t}\n\n\t(*env)->ReleaseByteArrayElements( env, arr, carr, 0 );\n\t(*env)->ReleaseDoubleArrayElements( env, in, cin, 0 );\n\t(*env)->ReleaseDoubleArrayElements( env, out, cout, 0 );\n}\n\n\n", "meta": {"hexsha": "fc982c291de16efbb47a4526fa4dd0774d28da4a", "size": 6346, "ext": "c", "lang": "C", "max_stars_repo_path": "triana-toolboxes/signalproc/src/main/java/signalproc/algorithms/c/jfftw_complex_Plan.c", "max_stars_repo_name": "CSCSI/Triana", "max_stars_repo_head_hexsha": "da48ffaa0183f59e3fe7c6dc59d9f91234e65809", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 8.0, "max_stars_repo_stars_event_min_datetime": "2015-11-02T10:12:13.000Z", "max_stars_repo_stars_event_max_datetime": "2019-01-15T21:45:38.000Z", "max_issues_repo_path": "triana-toolboxes/signalproc/src/main/java/signalproc/algorithms/c/jfftw_complex_Plan.c", "max_issues_repo_name": "CSCSI/Triana", "max_issues_repo_head_hexsha": "da48ffaa0183f59e3fe7c6dc59d9f91234e65809", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2015-08-28T13:52:42.000Z", "max_issues_repo_issues_event_max_datetime": "2016-01-22T13:06:00.000Z", "max_forks_repo_path": "triana-toolboxes/signalproc/src/main/java/signalproc/algorithms/c/jfftw_complex_Plan.c", "max_forks_repo_name": "CSCSI/Triana", "max_forks_repo_head_hexsha": "da48ffaa0183f59e3fe7c6dc59d9f91234e65809", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2022-03-08T14:04:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-09T05:30:21.000Z", "avg_line_length": 32.3775510204, "max_line_length": 198, "alphanum_fraction": 0.6564765206, "num_tokens": 1999, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.44552952031526044, "lm_q2_score": 0.03461884095568607, "lm_q1q2_score": 0.015423715604857106}}
{"text": "#define ORIGIN_DATE       \"2012.01.05\"\n#define ORIGIN_VERSION    \"2.1\"\n\n#include <stdlib.h>\n#include <stdio.h>\n#include <stdbool.h>\n#include <pthread.h>\n#include <assert.h>\n#include <gsl/gsl_rng.h>\n#include <gsl/gsl_randist.h>\n#include \"common.h\"\n#include \"ivector.h\"\n#include \"species.h\"\n#include \"specieslist.h\"\n#include \"graph.h\"\n#include \"utils.h\"\n\n#define MODEL_BDM_NEUTRAL      0\n#define MODEL_BDM_SELECTION    1\n\n// Parameters of the simulations.\ntypedef struct\n{\n    int m;             // Type of model.\n    int communities;   // Number of communities.\n    int j_per_c;       // Number of individuals per community.\n    int k_gen;         // Number of generations (in thousands).\n    int init_species;  // Initial number of species.\n    double mu;         // Mutation rate.\n    double omega;      // Weight of the links between communities.\n    double s;          // Selection coefficient.\n    double r;          // Radius (for random geometric graphs).\n    double w;          // Width (for rectangle random geometric graphs).\n    char *ofilename;   // Name of the output files.\n    char *shape;       // Shape of the metacommunity.\n}\nParams;\n\n// Prototype for the function used by the threads\nvoid *sim(void *parameters);\n// The function used to setup the cumulative jagged array from the graph.\ndouble **setup_cumulative_list(const graph *g, double omega);\n\n/////////////////////////////////////////////////////////////\n// Main                                                    //\n/////////////////////////////////////////////////////////////\nint main(int argc, const char *argv[])\n{\n    // Set default values;\n    Params p;\n    p.m = MODEL_BDM_SELECTION;\n    p.communities = 10;\n    p.j_per_c = 10000;\n    p.init_species = 20;\n    p.k_gen = 100;\n    p.mu = 1e-4;\n    p.omega = 5e-4;\n    p.s = 0.15;\n    p.r = 0.25;\n    p.w = 0.25;\n    p.ofilename = (char*)malloc(50);\n    p.shape = (char*)malloc(20);\n\n    // Number of simulations;\n    int n_threads = 1;\n\n    // Options;\n    if (argc > 1 && argv[1][0] == '-' && argv[1][1] == '-')\n    {\n        // --help\n        if (argv[1][2] == 'h')\n        {\n            printf(\"Usage: ./origin [options]\\n\");\n            printf(\"Example: ./origin -x=8 -shape=circle -model=1 -s=0.10\\n\");\n            printf(\"General options:\\n\");\n            printf(\"  --help          How you got here...\\n\");\n            printf(\"  --version       Display version.\\n\");\n            printf(\"  --ref           Display reference.\\n\");\n            printf(\"Simulation parameters:\\n\");\n            printf(\"  -x\\n\");\n            printf(\"    description:  Number of simulations to run. Each simulation\\n\");\n            printf(\"                  will use a distinct POSIX thread. \\n\");\n            printf(\"    values:       Any unsigned integer.\\n\");\n            printf(\"    default:      1\\n\");\n            printf(\"  -model\\n\");\n            printf(\"    description:  Set the model used.\\n\");\n            printf(\"    values:       0, 1.\\n\");\n            printf(\"    details:      0 = Neutral BDM speciation.\\n\");\n            printf(\"                  1 = BDM speciation with selection.\\n\");\n            printf(\"    default:      1\\n\");\n            printf(\"  -shape\\n\");\n            printf(\"    description:  Set the shape of the metacommunity.\\n\");\n            printf(\"    values:       circle, complete, random, rectangle, star.\\n\");\n            printf(\"    default:      random\\n\");\n            printf(\"  -r\\n\");\n            printf(\"    description:  Threshold radius for random geometric\\n\");\n            printf(\"                  graphs.\\n\");\n            printf(\"    values:       Any double greater than 0.\\n\");\n            printf(\"    default:      0.25\\n\");\n            printf(\"  -w\\n\");\n            printf(\"    description:  The width of a rectangle random geometric\\n\");\n            printf(\"                  graph.\\n\");\n            printf(\"    values:       0 < w < 1\\n\");\n            printf(\"    default:      0.25\\n\");\n            printf(\"  -g\\n\");\n            printf(\"    description:  Number of generations in thousands.\\n\");\n            printf(\"    values:       Any positive integer.\\n\");\n            printf(\"    default:      100 (i.e.: 100 000 generations)\\n\");\n            printf(\"  -c\\n\");\n            printf(\"    description:  Number of local communities.\\n\");\n            printf(\"    values:       Any integer greater than 0.\\n\");\n            printf(\"    default:      10\\n\");\n            printf(\"  -jpc\\n\");\n            printf(\"    description:  Number of individuals per communities.\\n\");\n            printf(\"    values:       Any integer greater than 0.\\n\");\n            printf(\"    default:      10000\\n\");\n            printf(\"  -sp\\n\");\n            printf(\"    description:  Initial number of species. Must be a factor\\n\");\n            printf(\"                  of the number of individuals/community.\\n\");\n            printf(\"    values:       Any positive integer greater than 0.\\n\");\n            printf(\"    default:      20\\n\");\n            printf(\"  -s\\n\");\n            printf(\"    description:  Set the selection coefficient (model 1 only).\\n\");\n            printf(\"    values:       Any double in the (-1.0, 1.0) interval.\\n\");\n            printf(\"    default:      0.15\\n\");\n            printf(\"  -mu\\n\");\n            printf(\"    description:  Set the mutation rate.\\n\");\n            printf(\"    values:       Any positive double.\\n\");\n            printf(\"    default:      1e-4\\n\");\n            printf(\"  -omega\\n\");\n            printf(\"    description:  The weight of the proper edges.\\n\");\n            printf(\"    values:       Any nonnegative double.\\n\");\n            printf(\"    default:      5e-4\\n\");\n            printf(\"  -o\\n\");\n            printf(\"    description:  Name of the output files.\\n\");\n            printf(\"    values:       Any string.\\n\");\n            return EXIT_SUCCESS;\n        }\n        else if (argv[1][2] == 'v') // --version\n        { \n            printf(\"origin v.%s (%s)\\n\", ORIGIN_VERSION, ORIGIN_DATE);\n            printf(\"Copyright (c) 2010-2011 Philippe Desjardins-Proulx <philippe.d.proulx@gmail.com>\\n\");\n            printf(\"GPLv2 license  (see LICENSE)\\n\");\n            return EXIT_SUCCESS;\n        }\n        else if (argv[1][2] == 'r') // --ref\n        { \n            printf(\"P. Desjardins-Proul and D. Gravel. How likely is speciation in\\n  neutral ecology? The American Naturalist 179(1).\\n\");\n            return EXIT_SUCCESS;\n        }\n    } // end '--' options\n\n    // Read options\n    read_opt_i(\"g\", argv, argc, &p.k_gen);\n    read_opt_i(\"jpc\", argv, argc, &p.j_per_c);\n    read_opt_i(\"model\", argv, argc, &p.m);\n    read_opt_i(\"c\", argv, argc, &p.communities);\n    read_opt_i(\"sp\", argv, argc, &p.init_species);\n    read_opt_i(\"x\", argv, argc, &n_threads);\n    read_opt_d(\"mu\", argv, argc, &p.mu);\n    read_opt_d(\"omega\", argv, argc, &p.omega);\n    read_opt_d(\"r\", argv, argc, &p.r);\n    read_opt_d(\"w\", argv, argc, &p.w);\n    read_opt_d(\"s\", argv, argc, &p.s);\n    if (read_opt_s(\"o\", argv, argc, p.ofilename) == false)\n    {\n        sprintf(p.ofilename, \"\");\n    }\n    if (read_opt_s(\"shape\", argv, argc, p.shape) == false)\n    {\n        sprintf(p.shape, \"random\");\n    }\n\n    printf(\"<?xml version=\\\"1.0\\\"?>\\n\");\n    printf(\"<origin_ssne>\\n\");\n    printf(\"  <model>\");\n    if (p.m == MODEL_BDM_NEUTRAL)\n    {\n        printf(\"Neutral BDM speciation</model>\\n\");\n    }\n    else if (p.m == MODEL_BDM_SELECTION)\n    {\n        printf(\"BDM speciation with selection</model>\\n\");\n    }\n    printf(\"  <n>%d</n>\\n\", n_threads);\n    printf(\"  <shape_metacom>%s</shape_metacom>\\n\", p.shape);\n    printf(\"  <metacom_size>%d</metacom_size>\\n\", p.j_per_c * p.communities);\n    printf(\"  <k_gen>%d</k_gen>\\n\", p.k_gen);\n    printf(\"  <num_comm>%d</num_comm>\\n\", p.communities);\n    printf(\"  <individuals_per_comm>%d</individuals_per_comm>\\n\", p.j_per_c);\n    printf(\"  <initial_num_species>%d</initial_num_species>\\n\", p.init_species);\n    printf(\"  <mutation_rate>%.2e</mutation_rate>\\n\", p.mu);\n    printf(\"  <omega>%.2e</omega>\\n\", p.omega);\n    if (p.m == MODEL_BDM_SELECTION)\n    {\n        printf(\"  <selection>%.2e</selection>\\n\", p.s);\n    }\n    if (p.shape[0] == 'r')\n    {\n        printf(\"  <radius>%.4f</radius>\\n\", p.r);\n    }\n    if (p.shape[0] == 'r' && p.shape[1] == 'e')\n    {\n        printf(\"  <width>%.4f</width>\\n\", p.w);\n    }\n    printf(\"  <filename>%s</filename>\\n\", p.ofilename);\n\n    // The threads:\n    pthread_t threads[n_threads];\n\n    const time_t start = time(NULL);\n\n    // Create the threads:\n    for (int i = 0; i < n_threads; ++i)\n    {\n        pthread_create(&threads[i], NULL, sim, (void*)&p);\n    }\n\n    // Wait for the threads to end:\n    for (int i = 0; i < n_threads; ++i)\n    {\n        pthread_join(threads[i], NULL);\n    }\n\n    const time_t end_t = time(NULL);\n    printf(\"  <seconds>%lu</seconds>\\n\", (unsigned long)(end_t - start));\n    printf(\"  <time>%s</time>\\n\", sec_to_string(end_t - start));\n    printf(\"</origin_ssne>\\n\");\n    return EXIT_SUCCESS; // yeppie !\n}\n\n///////////////////////////////////////////\n// The simulation                        //\n///////////////////////////////////////////\nvoid *sim(void *parameters)\n{\n    const Params P = *((Params*)parameters);\n\n    char *shape = P.shape;\n    const int k_gen = P.k_gen;\n    const int communities = P.communities;\n    const int j_per_c = P.j_per_c;\n    const int init_species = P.init_species;\n    const int init_pop_size = j_per_c / init_species;\n    const double omega = P.omega;\n    const double mu = P.mu;\n    const double s = P.s;\n    const double radius = P.r;\n    const double width = P.w;\n\n    // GSL's Taus generator:\n    gsl_rng *rng = gsl_rng_alloc(gsl_rng_taus2);\n    // Initialize the GSL generator with /dev/urandom:\n    const unsigned int seed = devurandom_get_uint();\n    gsl_rng_set(rng, seed); // Seed with time\n    printf(\"  <seed>%u</seed>\\n\", seed);\n    // Used to name the output file:\n    char *buffer = (char*)malloc(100);\n    // Nme of the file:\n    sprintf(buffer, \"%s%u.xml\", P.ofilename, seed);\n    // Open the output file:\n    FILE *restrict out = fopen(buffer, \"w\");\n    // Store the total num. of species/1000 generations:\n    int *restrict total_species = (int*)malloc(k_gen * sizeof(int));\n    // Number of speciation events/1000 generations:\n    int *restrict speciation_events = (int*)malloc(k_gen * sizeof(int));\n    // Number of extinctions/1000 generations:\n    int *restrict extinction_events = (int*)malloc(k_gen * sizeof(int));\n    // Number of speciation events/vertex:\n    int *restrict speciation_per_c = (int*)malloc(communities * sizeof(int));\n    // Number of local extinction events/vertex:\n    int *restrict extinction_per_c = (int*)malloc(communities * sizeof(int));\n    // Store the lifespan of the extinct species:\n    ivector lifespan;\n    ivector_init0(&lifespan);\n    // Store the population size at speciation event:\n    ivector pop_size;\n    ivector_init0(&pop_size);\n    // (x, y) coordinates for the spatial graph:\n    double *restrict x = (double*)malloc(communities * sizeof(double));\n    double *restrict y = (double*)malloc(communities * sizeof(double));\n    for (int i = 0; i < communities; ++i)\n    {\n        speciation_per_c[i] = 0;\n        extinction_per_c[i] = 0;\n    }\n    // Initialize an empty list of species:\n    species_list *restrict list = species_list_init();\n    // Initialize the metacommunity and fill them with the initial species evenly:\n    for (int i = 0; i < init_species; ++i)\n    {\n        // Intialize the species and add it to the list:\n        species_list_add(list, species_init(communities, 0, 3));\n    }\n    // To iterate the list;\n    slnode *it = list->head;\n    // Fill the communities:\n    while (it != NULL)\n    {\n        for (int i = 0; i < communities; ++i)\n        {\n            it->sp->n[i] = init_pop_size;\n            it->sp->genotypes[0][i] = init_pop_size;\n        }\n        it = it->next;\n    }\n\n    // To iterate the list;\n    const int remainder = j_per_c - (init_species * init_pop_size);\n    for (int i = 0; i < communities; ++i)\n    {\n        it = list->head;\n        for (int j = 0; j < remainder; ++j, it = it->next)\n        {\n            ++(it->sp->n[i]);\n            ++(it->sp->genotypes[0][i]);\n        }\n    }\n\n    // Test (will be removed for v2.0):\n    int sum = 0;\n    it = list->head;\n    while (it != NULL)\n    {\n        sum += species_total(it->sp);\n        it = it->next;\n    }\n    assert(sum == j_per_c * communities);\n\n    // Create the metacommunity;\n    graph g;\n    switch(shape[0])\n    {\n    case 's':\n        shape = \"star\";\n        graph_get_star(&g, communities);\n        break;\n    case 'c':\n        if (shape[1] == 'o')\n        {\n            shape = \"complete\";\n            graph_get_complete(&g, communities);\n            break;\n        }\n        else\n        {\n            shape = \"circle\";\n            graph_get_circle(&g, communities);\n            break;\n        }\n    case 'r':\n        if (shape[1] == 'e')\n        {\n            shape = \"rectangle\";\n            graph_get_rec_crgg(&g, communities, width, radius, x, y, rng);\n            break;\n        }\n        else\n        {\n            shape = \"random\";\n            graph_get_crgg(&g, communities, radius, x, y, rng);\n            break;\n        }\n    default:\n        shape = \"random\";\n        graph_get_crgg(&g, communities, radius, x, y, rng);\n    }\n    // Setup the cumulative jagged array for migration:\n    double **cumul = setup_cumulative_list(&g, omega);\n\n    fprintf(out, \"<?xml version=\\\"1.0\\\"?>\\n\");\n    fprintf(out, \"<simulation>\\n\");\n    fprintf(out, \"  <model>\");\n    if (P.m == MODEL_BDM_NEUTRAL)\n    {\n        fprintf(out, \"Neutral BDM speciation</model>\\n\");\n    }\n    else if (P.m == MODEL_BDM_SELECTION)\n    {\n        fprintf(out, \"BDM speciation with selection</model>\\n\");\n    }\n    fprintf(out, \"  <seed>%u</seed>\\n\", seed);\n    fprintf(out, \"  <shape_metacom>%s</shape_metacom>\\n\", shape);\n    fprintf(out, \"  <metacom_size>%d</metacom_size>\\n\", j_per_c * communities);\n    fprintf(out, \"  <k_gen>%d</k_gen>\\n\", k_gen);\n    fprintf(out, \"  <num_comm>%d</num_comm>\\n\", communities);\n    fprintf(out, \"  <individuals_per_comm>%d</individuals_per_comm>\\n\", j_per_c);\n    fprintf(out, \"  <initial_num_species>%d</initial_num_species>\\n\", init_species);\n    fprintf(out, \"  <mutation_rate>%.2e</mutation_rate>\\n\", mu);\n    fprintf(out, \"  <omega>%.2e</omega>\\n\", omega);\n    if (P.m == MODEL_BDM_SELECTION)\n    {\n        fprintf(out, \"  <selection>%.2e</selection>\\n\", s);\n    }\n    if (shape[0] == 'r')\n    {\n        fprintf(out, \"  <radius>%.4f</radius>\\n\", radius);\n    }\n    if (shape[0] == 'r' && shape[1] == 'e')\n    {\n        fprintf(out, \"  <width>%.4f</width>\\n\", width);\n    }\n    // To select the species and genotypes to pick and replace:\n    slnode *s0 = list->head; // species0\n    slnode *s1 = list->head; // species1\n    int g0 = 0;\n    int g1 = 0;\n    int v1 = 0; // Vertex of the individual 1\n\n    /////////////////////////////////////////////\n    // Groups of 1 000 generations             //\n    /////////////////////////////////////////////\n    for (int k = 0; k < k_gen; ++k)\n    {\n        extinction_events[k] = 0;\n        speciation_events[k] = 0;\n\n        /////////////////////////////////////////////\n        // 1 000 generations                       //\n        /////////////////////////////////////////////\n        for (int gen = 0; gen < 1000; ++gen)\n        {\n            const int current_date = (k * 1000) + gen;\n            /////////////////////////////////////////////\n            // A single generation                     //\n            /////////////////////////////////////////////\n            for (int t = 0; t < j_per_c; ++t)\n            {\n                /////////////////////////////////////////////\n                // A single time step (for each community) //\n                /////////////////////////////////////////////\n                for (int c = 0; c < communities; ++c)\n                {\n                    // Select the species and genotype of the individual to be replaced\n                    int position = (int)(gsl_rng_uniform(rng) * j_per_c);\n                    s0 = list->head;\n                    int index = s0->sp->n[c];\n                    while (index <= position)\n                    {\n                        s0 = s0->next;\n                        index += s0->sp->n[c];\n                    }\n                    position = (int)(gsl_rng_uniform(rng) * s0->sp->n[c]);\n                    if (position < s0->sp->genotypes[0][c])\n                    {\n                        g0 = 0;\n                    }\n                    else if (position < (s0->sp->genotypes[0][c] + s0->sp->genotypes[1][c]))\n                    {\n                        g0 = 1;\n                    }\n                    else\n                    {\n                        g0 = 2;\n                    }\n                    // Choose the vertex for the individual\n                    const double r_v1 = gsl_rng_uniform(rng);\n                    v1 = 0;\n                    while (r_v1 > cumul[c][v1])\n                    {\n                        ++v1;\n                    }\n                    v1 = g.adj_list[c][v1];\n                    // species of the new individual\n                    position = (int)(gsl_rng_uniform(rng) * j_per_c);\n                    s1 = list->head;\n                    index = s1->sp->n[v1];\n                    while (index <= position)\n                    {\n                        s1 = s1->next;\n                        index += s1->sp->n[v1];\n                    }\n                    if (v1 == c) // local remplacement\n                    {\n                        const double r = gsl_rng_uniform(rng);\n                        const int aa = s1->sp->genotypes[0][v1];\n                        const int Ab = s1->sp->genotypes[1][v1];\n                        const int AB = s1->sp->genotypes[2][v1];\n\n                        // The total fitness of the population 'W':\n                        const double w = aa + Ab * (1.0 + s) + AB * (1.0 + s) * (1.0 + s);\n\n                        if (r < aa / w)\n                        {\n                            g1 = gsl_rng_uniform(rng) < mu ? 1 : 0;\n                        }\n                        else\n                        {\n                            if (AB == 0 || r < (aa + Ab * (1.0 + s)) / w)\n                            {\n                                g1 = gsl_rng_uniform(rng) < mu ? 2 : 1;\n                            }\n                            else\n                            {\n                                g1 = 2;\n                            }\n                        }\n                    }\n                    else\n                    { // Migration event\n                        g1 = 0;\n                    }\n                    // Apply the changes\n                    s0->sp->n[c]--;\n                    s0->sp->genotypes[g0][c]--;\n                    s1->sp->n[c]++;\n                    s1->sp->genotypes[g1][c]++;\n\n                    ////////////////////////////////////////////\n                    // Check for local extinction             //\n                    ////////////////////////////////////////////\n                    if (s0->sp->n[c] == 0)\n                    {\n                        extinction_per_c[c]++;\n                    }\n                    ////////////////////////////////////////////\n                    // Check for speciation                   //\n                    ////////////////////////////////////////////\n                    else if (s0->sp->genotypes[2][c] > 0 && s0->sp->genotypes[0][c] == 0 && s0->sp->genotypes[1][c] == 0)\n                    {\n                        species_list_add(list, species_init(communities, current_date, 3)); // Add the new species\n\n                        const int pop = s0->sp->n[c];\n                        list->tail->sp->n[c] = pop;\n                        list->tail->sp->genotypes[0][c] = pop;\n                        s0->sp->n[c] = 0;\n                        s0->sp->genotypes[2][c] = 0;\n\n                        // To keep info on patterns of speciation...\n                        ivector_add(&pop_size, pop);\n                        ++speciation_events[k];\n                        ++speciation_per_c[c];\n                    }\n\n                } // End 'c'\n\n            } // End 't'\n\n            // Remove extinct species from the list and store the number of extinctions.\n            extinction_events[k] += species_list_rmv_extinct2(list, &lifespan, current_date);\n\n        } // End 'g'\n\n        total_species[k] = list->size;\n\n    } // End 'k'\n\n    //////////////////////////////////////////////////\n    // PRINT THE FINAL RESULTS                      //\n    //////////////////////////////////////////////////\n    fprintf(out, \"  <global>\\n\");\n    fprintf(out, \"    <proper_edges>%d</proper_edges>\\n\", graph_edges(&g));\n    fprintf(out, \"    <links_per_c>%.4f</links_per_c>\\n\", (double)graph_edges(&g) / communities);\n\n    fprintf(out, \"    <avr_lifespan>%.4f</avr_lifespan>\\n\", imean(lifespan.array, lifespan.size));\n    fprintf(out, \"    <median_lifespan>%.4f</median_lifespan>\\n\", imedian(lifespan.array, lifespan.size));\n\n    fprintf(out, \"    <avr_pop_size_speciation>%.4f</avr_pop_size_speciation>\\n\", imean(pop_size.array, pop_size.size));\n    fprintf(out, \"    <median_pop_size_speciation>%.4f</median_pop_size_speciation>\\n\", imedian(pop_size.array, pop_size.size));\n\n    fprintf(out, \"    <speciation_per_k_gen>\");\n    int i = 0;\n    for (; i < k_gen - 1; ++i)\n    {\n        fprintf(out, \"%d \", speciation_events[i]);\n    }\n    fprintf(out, \"%d</speciation_per_k_gen>\\n\", speciation_events[i]);\n\n    fprintf(out, \"    <extinctions_per_k_gen>\");\n    for (i = 0; i < k_gen - 1; ++i)\n    {\n        fprintf(out, \"%d \", extinction_events[i]);\n    }\n    fprintf(out, \"%d</extinctions_per_k_gen>\\n\", extinction_events[i]);\n\n    fprintf(out, \"    <extant_species_per_k_gen>\");\n    for (i = 0; i < k_gen - 1; ++i)\n    {\n        fprintf(out, \"%d \", total_species[i]);\n    }\n    fprintf(out, \"%d</extant_species_per_k_gen>\\n\", total_species[i]);\n\n    // Print global distribution\n    fprintf(out, \"    <species_distribution>\");\n    ivector species_distribution;\n    ivector_init1(&species_distribution, 128);\n    it = list->head;\n    while (it != NULL)\n    {\n        ivector_add(&species_distribution, species_total(it->sp));\n        it = it->next;\n    }\n    ivector_sort_asc(&species_distribution);\n    ivector_print(&species_distribution, out);\n    fprintf(out, \"</species_distribution>\\n\");\n\n    double *octaves;\n    int oct_num = biodiversity_octaves(species_distribution.array, species_distribution.size, &octaves);\n    fprintf(out, \"    <octaves>\");\n    for (i = 0; i < oct_num; ++i)\n    {\n        fprintf(out, \"%.2f \", octaves[i]);\n    }\n    fprintf(out, \"%.2f</octaves>\\n\", octaves[i]);\n    fprintf(out, \"  </global>\\n\");\n\n    // Print info on all vertices\n    double *restrict ric_per_c = (double*)malloc(communities * sizeof(double));\n    for (int c = 0; c < communities; ++c)\n    {\n        fprintf(out, \"  <vertex>\\n\");\n        fprintf(out, \"    <id>%d</id>\\n\", c);\n        if (shape[0] == 'r')\n        {\n            fprintf(out, \"    <xcoor>%.4f</xcoor>\\n\", x[c]);\n            fprintf(out, \"    <ycoor>%.4f</ycoor>\\n\", y[c]);\n        }\n        fprintf(out, \"    <degree>%d</degree>\\n\", g.num_e[c] + 1);\n        fprintf(out, \"    <speciation_events>%d</speciation_events>\\n\", speciation_per_c[c]);\n        fprintf(out, \"    <extinction_events>%d</extinction_events>\\n\", extinction_per_c[c]);\n\n        int vertex_richess = 0;\n        ivector_rmvall(&species_distribution);\n        it = list->head;\n        while (it != NULL)\n        {\n            ivector_add(&species_distribution, it->sp->n[c]);\n            it = it->next;\n        }\n        // Sort the species distribution and remove the 0s\n        ivector_sort_asc(&species_distribution);\n        ivector_trim_small(&species_distribution, 1);\n\n        ric_per_c[c] = (double)species_distribution.size;\n        fprintf(out, \"    <species_richess>%d</species_richess>\\n\", species_distribution.size);\n        fprintf(out, \"    <species_distribution>\");\n        ivector_print(&species_distribution, out);\n        fprintf(out, \"</species_distribution>\\n\");\n\n        // Print octaves\n        free(octaves);\n        oct_num = biodiversity_octaves(species_distribution.array, species_distribution.size, &octaves);\n        fprintf(out, \"    <octaves>\");\n        for (i = 0; i < oct_num - 1; ++i)\n        {\n            fprintf(out, \"%.2f \", octaves[i]);\n        }\n        fprintf(out, \"%.2f</octaves>\\n\", octaves[i]);\n        fprintf(out, \"  </vertex>\\n\");\n    }\n\n    fprintf(out, \"</simulation>\\n\");\n\n    // GraphML output:\n    sprintf(buffer, \"%s%u.graphml\", P.ofilename, seed);\n    FILE *outgml = fopen(buffer, \"w\");\n    graph_graphml(&g, outgml, seed);\n    \n    // Print to SVG files.\n    sprintf(buffer, \"%s%u.svg\", P.ofilename, seed);\n    FILE *outsvg = fopen(buffer, \"w\");\n    graph_svg(&g, x, y, 400.0, 20.0, outsvg);\n    \n    sprintf(buffer, \"%s%u-speciation.svg\", P.ofilename, seed);\n    FILE *outsvgspe = fopen(buffer, \"w\");\n    double *spe_per_c = (double*)malloc(communities * sizeof(double));\n    for (int c = 0; c < communities; ++c)\n    {\n        spe_per_c[c] = (double)speciation_per_c[c];\n    }\n    scale_0_1(spe_per_c, communities);\n    graph_svg_abun(&g, x, y, 400.0, 20.0, spe_per_c, 2, outsvgspe);\n    \n    sprintf(buffer, \"%s%u-richness.svg\", P.ofilename, seed);\n    FILE *outsvgric = fopen(buffer, \"w\");\n    scale_0_1(ric_per_c, communities);\n    graph_svg_abun(&g, x, y, 400.0, 20.0, ric_per_c, 1, outsvgric);\n\n    //////////////////////////////////////////////////\n    // EPILOGUE...                                  //\n    //////////////////////////////////////////////////\n    // Close files;\n    fclose(out);\n    fclose(outgml);\n    fclose(outsvg);\n    fclose(outsvgspe);\n    fclose(outsvgric);\n    // Free arrays;\n    free(x);\n    free(y);\n    free(ric_per_c);\n    free(spe_per_c);\n    free(buffer);\n    free(total_species);\n    free(octaves);\n    free(speciation_per_c);\n    free(extinction_per_c);\n    free(speciation_events);\n    free(extinction_events);\n    // Free structs;\n    species_list_free(list);\n    ivector_free(&species_distribution);\n    ivector_free(&lifespan);\n    ivector_free(&pop_size);\n    graph_free(&g);\n    gsl_rng_free(rng);\n\n    return NULL;\n}\n\ndouble **setup_cumulative_list(const graph *g, double omega)\n{\n    const int num_v = g->num_v;\n    double **cumul = (double**)malloc(num_v * sizeof(double*));\n    for (int i = 0; i < num_v; ++i) \n    {\n        cumul[i] = (double*)malloc(g->num_e[i] * sizeof(double));\n    }\n    for (int i = 0; i < num_v; ++i)\n    {\n        for (int j = 0; j < g->num_e[i]; ++j)\n        {\n            cumul[i][j] = g->w_list[i][j];\n        }\n    }\n    for (int i = 0; i < num_v; ++i)\n    {\n        for (int j = 0; j < g->num_e[i]; ++j)\n        {\n            if (i != g->adj_list[i][j])\n            {\n                cumul[i][j] = omega;\n            }\n            else\n            {\n                cumul[i][j] = 1.0;\n            }\n        }\n    }\n    for (int i = 0; i < num_v; ++i)\n    {\n        double sum = 0.0;\n        const int num_e = g->num_e[i];\n        for (int j = 0; j < num_e; ++j)\n        {\n            sum += cumul[i][j];\n        }\n        for (int j = 0; j < num_e; ++j)\n        {\n            cumul[i][j] /= sum;\n        }\n    }\n    for (int i = 0; i < num_v; ++i)\n    {\n        const int num_e = g->num_e[i];\n        for (int j = 1; j < num_e - 1; ++j)\n        {\n            cumul[i][j] += cumul[i][j - 1];\n        }\n        cumul[i][num_e - 1] = 1.0;\n    }\n    /*\n    graph_print(g, stdout);\n    for (int i = 0; i < num_v; ++i)\n    {\n        const int num_e = g->num_e[i];\n        for (int j = 0; j < num_e; ++j)\n        {\n            printf(\"%.4f   \", cumul[i][j]);\n        }\n        printf(\"\\n\");\n    }\n    */\n    return cumul;\n}\n", "meta": {"hexsha": "a172244958e240675fddc28f1c062fabcf327eec", "size": 27926, "ext": "c", "lang": "C", "max_stars_repo_path": "src/main.c", "max_stars_repo_name": "PhDP/Origin", "max_stars_repo_head_hexsha": "79d02f0d850a9b078e58d5f5af6ff1d2143cf712", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/main.c", "max_issues_repo_name": "PhDP/Origin", "max_issues_repo_head_hexsha": "79d02f0d850a9b078e58d5f5af6ff1d2143cf712", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/main.c", "max_forks_repo_name": "PhDP/Origin", "max_forks_repo_head_hexsha": "79d02f0d850a9b078e58d5f5af6ff1d2143cf712", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.9871134021, "max_line_length": 139, "alphanum_fraction": 0.4811286973, "num_tokens": 7243, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.43014736319616964, "lm_q2_score": 0.03567855113407215, "lm_q1q2_score": 0.015347034692980844}}
{"text": "//! @file\n//! Various functions used during experiences (dgemmsy)\n//!\n//! @author\n//!    Copyright (C) 2009-2011 BigDFT group \n//!    This file is distributed under the terms of the\n//!    GNU General Public License, see ~/COPYING file\n//!    or http://www.gnu.org/copyleft/gpl.txt .\n//!    For the list of contributors, see ~/AUTHORS \n//! Eric Bainville, Mar 2010\n\n\n#include <stdlib.h>\n#include <string.h>\n#include <stdio.h>\n#include <malloc.h>\n#include <math.h>\n#include <unistd.h>\n#include <xmmintrin.h>\n\n// Set to 1 to use BLAS axpy call to accumulate partial results.\n#ifndef USE_AXPY\n#define USE_AXPY 1\n/*#define ACML_BLAS 1*/\n#endif\n\n#if USE_AXPY\n#if defined(MKL_BLAS) || defined(WIN32)\n#include <mkl_cblas.h>\n#else\n#if defined(ACML_BLAS)\n#include <acml.h>\n#define cblas_daxpy daxpy\n#else\n#include <cblas.h>\n#endif\n#endif\n#endif\n\n#include \"utils.h\"\n\n// System-specific functions\n\n#include <unistd.h>\nvoid * allocPages(size_t sz)\n{\n  size_t page_size = sysconf(_SC_PAGESIZE);\n  size_t extra = sz % page_size;\n  if (extra != 0) sz = (sz - extra) + page_size; // round to next page\n  void * address = 0;\n  int status = posix_memalign(&address,page_size,sz);\n  if (status != 0) return 0; // Failed\n  return address;\n}\nvoid freePages(void * address)\n{\n  free(address);\n}\ndouble * allocDoubles(int n)\n{\n  void * address = 0;\n  int status = posix_memalign(&address,16,n*sizeof(double));\n  if (status != 0) return 0; // Failed\n  return address;\n}\nfloat * allocFloats(int n)\n{\n  void * address = 0;\n  int status = posix_memalign(&address,16,n*sizeof(float));\n  if (status != 0) return 0; // Failed\n  return address;\n}\nvoid freeDoubles(double * x)\n{\n  free(x);\n}\nvoid freeFloats(float * x)\n{\n  free(x);\n}\n\n// Reference implementations\n\nvoid gemm_block_2x2_ref(const double * a,const double * b,long long int n,double * y,long long int ldy)\n{\n  int k;\n  for (k=0;k<n;k+=2)\n  {\n    y[0] += a[2*k] * b[4*k];\n    y[0] += a[2*k+1] * b[4*k+1];\n    y[1] += a[2*k] * b[4*k+2];\n    y[1] += a[2*k+1] * b[4*k+3];\n    y[ldy] += a[2*k+2] * b[4*k];\n    y[ldy] += a[2*k+3] * b[4*k+1];\n    y[ldy+1] += a[2*k+2] * b[4*k+2];\n    y[ldy+1] += a[2*k+3] * b[4*k+3];\n  }\n}\n\nvoid gemm_block_2x4_ref(const double * a,const double * b,long long int n,double * y,long long int ldy)\n{\n  int k;\n  double * work;\n  for (k=0;k<n;k+=2)\n  {\n    work = y;\n    work[0] += a[2*k]   * b[4*k];\n    work[0] += a[2*k+1] * b[4*k+1];\n    work += ldy;\n    work[0] += a[2*k]   * b[4*k+2];\n    work[0] += a[2*k+1] * b[4*k+3];\n    work += ldy;\n    work[0] += a[2*k]   * b[4*k+4];\n    work[0] += a[2*k+1] * b[4*k+5];\n    work += ldy;\n    work[0] += a[2*k]   * b[4*k+6];\n    work[0] += a[2*k+1] * b[4*k+7];\n\n    work = y + 1;\n    work[0] += a[2*k+2] * b[4*k];\n    work[0] += a[2*k+3] * b[4*k+1];\n    work += ldy;\n    work[0] += a[2*k+2] * b[4*k+2];\n    work[0] += a[2*k+3] * b[4*k+3];\n    work += ldy;\n    work[0] += a[2*k+2] * b[4*k+4];\n    work[0] += a[2*k+3] * b[4*k+5];\n    work += ldy;\n    work[0] += a[2*k+2] * b[4*k+6];\n    work[0] += a[2*k+3] * b[4*k+7];\n  }\n}\n\nint dgemmsy_base(dgemmsyBaseArgs * args)\n{\n  int status = 0; // return value\n  int row,col;\n  size_t slice_size,ywork_size;\n  int p2; // P rounded to next multiple of 4\n  double *a_slice,*b_slice,*y_work;\n  ComputeData cdata;\n  TransposeData tdata;\n  int slice_n,n,p;\n  const double *a,*b;\n  double *y;\n  int lda,ldb,ldy;\n  int transa,transb;\n  BlockPattern_2x4_Proc pattern;\n  void * pattern_arg;\n  double alpha;\n\n  if (args == 0) return -2;\n\n  pattern = args->params.pattern;\n  pattern_arg = args->params.pattern_arg;\n  slice_n = args->params.slice_n;\n\n  transa = args->transa;\n  transb = args->transb;\n  n = args->n;\n  p = args->p;\n  a = args->a;\n  lda = args->lda;\n  b = args->b;\n  ldb = args->ldb;\n  y = args->y;\n  ldy = args->ldy;\n  alpha = args->alpha;\n\n  // Check dimensions\n  if (slice_n < 8) return -1;\n  if ( n <= 0 || p <= 0 ) return -1;\n  p2 = (p+3) & 0x7FFFFFFC;\n\n  // printf(\"N=%d P=%d LDA=%d LDB=%d LDY=%d  P2=%d\\n\",n,p,lda,ldb,ldy,p2);\n\n  // Check other arguments\n  if (a == 0 || b == 0 || y == 0 || pattern == 0) return -5;\n\n  // Allocate memory\n  slice_size = slice_n * p2 * sizeof(double); // Slice size in bytes\n  ywork_size = p2 * p2 * sizeof(double); // Result size in bytes\n  a_slice = (double *)allocPages(slice_size);\n  b_slice = (double *)allocPages(slice_size);\n  y_work = (double *)allocPages(ywork_size);\n  if (a_slice == 0 || b_slice == 0 || y_work == 0) { status = -3; goto END; }\n  memset(y_work,0,ywork_size);\n\n  // Loop on all slices and accumulate products\n  initComputeData(&cdata,p2,slice_n,a_slice,b_slice,y_work);\n  for (row=0;row<n;row+=slice_n)\n  {\n    int s = slice_n;\n    if (row+s > n) s = n-row; // Limit size of last slice if needed\n\n    // 2-pack A slice\n    if (transa) tpack_2(s,p,a+lda*row,lda, slice_n,p2,a_slice);\n    else npack_2(s,p,a+row,lda, slice_n,p2,a_slice);\n\n    // 4-pack B slice\n    if (transb) tpack_4(s,p,b+ldb*row,ldb, slice_n,p2,b_slice);\n    else npack_4(s,p,b+row,ldb, slice_n,p2,b_slice);\n\n    pattern(pattern_arg,p2,Compute_visitor,&cdata);\n  }\n  cleanupComputeData(&cdata);\n\n  // Complete result by symmetry\n  initTransposeData(&tdata,p2,y_work);\n  pattern(pattern_arg,p2,Transpose_visitor,&tdata);\n  cleanupTransposeData(&tdata);\n\n  // Combine and store (untransposed) result. If we are multithreading,\n  // we must protect the update with a mutex, since all threads\n  // will update the same Y.\n  if (args->yMutex != 0)\n    {\n      int locked = pthread_mutex_lock(args->yMutex);\n      if (locked != 0) status = -4;\n    }\n  for (col=0;col<p;col++)\n    {\n      double * yy = y+ldy*col;\n      double * yy_work = y_work+p2*col;\n#if USE_AXPY\n      cblas_daxpy(p,alpha,yy_work,1,yy,1);\n#else\n      if (alpha == 1)\n\t{\n\t  for (row=0;row<p;row++) yy[row] += yy_work[row];\n\t}\n      else\n\t{\n\t  for (row=0;row<p;row++) yy[row] += alpha * yy_work[row];\n\t}\n#endif\n    }\n  if (args->yMutex != 0)\n    {\n      int unlocked = pthread_mutex_unlock(args->yMutex);\n      if (unlocked != 0) status = -4;\n    }\n\nEND:\n  // Cleanup\n  freePages(y_work);\n  freePages(a_slice);\n  freePages(b_slice);\n  return status;\n}\n\nvoid npack_2(int n,int p,const double * a,int lda,int s,int q,double * slice)\n{\n  int row,col,icol;\n  double * x = 0;\n  int oddn = 0;\n  if (n&1) { n--; oddn=1; }\n  for (col=0;col<q;col++)\n    {\n      icol = col&1;\n      x = slice + s*(col-icol) + (icol<<1);\n      row = 0;\n      if (col < p)\n\t{\n\t  for ( ;row<n;row+=2)\n\t    {\n\t      x[2*row] = a[row];\n\t      x[2*row+1] = a[row+1];\n\t    }\n\t  if (oddn) { x[2*row] = a[row]; x[2*row+1] = 0; row+=2; }\n\t}\n      for ( ;row<s;row+=2)\n\t{\n\t  x[2*row] = 0;\n\t  x[2*row+1] = 0;\n\t}\n      a += lda;\n    }\n}\n\nvoid npack_4(int n,int p,const double * a,int lda,int s,int q,double * slice)\n{\n  int row,col,icol;\n  double * x = 0;\n  int oddn = 0;\n  if (n&1) { n--; oddn=1; }\n  for (col=0;col<q;col++)\n    {\n      icol = col&3;\n      x = slice + s*(col-icol) + (icol<<1);\n      row = 0;\n      if (col < p)\n\t{\n\t  for ( ;row<n;row+=2)\n\t    {\n\t      x[4*row] = a[row];\n\t      x[4*row+1] = a[row+1];\n\t    }\n\t  if (oddn) { x[4*row] = a[row]; x[4*row+1] = 0; row+=2; }\n\t}\n      for ( ;row<s;row+=2)\n\t{\n\t  x[4*row] = 0;\n\t  x[4*row+1] = 0;\n\t}\n      a += lda;\n    }\n}\n\nvoid tpack_2(int n,int p,const double * a,int lda,int s,int q,double * slice)\n{\n  int row,col,icol;\n  double * x = 0;\n  const double * aa;\n  int da = lda<<1;\n  int oddn = 0;\n  if (n&1) { n--; oddn=1; }\n  for (col=0;col<q;col++)\n    {\n      icol = col&1;\n      x = slice + s*(col-icol) + (icol<<1);\n      row = 0;\n      if (col < p)\n\t{\n\t  aa = a;\n\t  for ( ;row<n;row+=2)\n\t    {\n\t      x[2*row] = aa[0];\n\t      x[2*row+1] = aa[lda];\n\t      aa += da;\n\t    }\n\t  if (oddn) { x[2*row] = aa[0]; x[2*row+1] = 0; row += 2; }\n\t}\n      for ( ;row<s;row+=2)\n\t{\n\t  x[2*row] = 0;\n\t  x[2*row+1] = 0;\n\t}\n      a++;\n    }\n}\n\nvoid tpack_4(int n,int p,const double * a,int lda,int s,int q,double * slice)\n{\n  int row,col,icol;\n  double * x = 0;\n  const double * aa;\n  int da = lda<<1;\n  int oddn = 0;\n  if (n&1) { n--; oddn=1; }\n  for (col=0;col<q;col++)\n    {\n      icol = col&3;\n      x = slice + s*(col-icol) + (icol<<1);\n      row = 0;\n      if (col < p)\n\t{\n\t  aa = a;\n\t  for ( ;row<n;row+=2)\n\t    {\n\t      x[4*row] = aa[0];\n\t      x[4*row+1] = aa[lda];\n\t      aa += da;\n\t    }\n\t  if (oddn) { x[4*row] = aa[0]; x[4*row+1] = 0; row += 2; }\n\t}\n      for ( ;row<s;row+=2)\n\t{\n\t  x[4*row] = 0;\n\t  x[4*row+1] = 0;\n\t}\n      a++;\n    }\n}\n", "meta": {"hexsha": "30235543f5c6a1420571fc18f90beb35ef062def", "size": 8393, "ext": "c", "lang": "C", "max_stars_repo_path": "external_libs/isf/wrappers/dgemmsy/dgemmsy_utils.c", "max_stars_repo_name": "gimunu/octopus-metric", "max_stars_repo_head_hexsha": "baabccd5402922a2f62f5cf6030d15e7ea76dc9b", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2016-11-17T09:03:11.000Z", "max_stars_repo_stars_event_max_datetime": "2019-10-17T06:31:08.000Z", "max_issues_repo_path": "external_libs/isf/wrappers/dgemmsy/dgemmsy_utils.c", "max_issues_repo_name": "gimunu/octopus-metric", "max_issues_repo_head_hexsha": "baabccd5402922a2f62f5cf6030d15e7ea76dc9b", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-15T19:35:34.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-07T15:32:18.000Z", "max_forks_repo_path": "external_libs/isf/wrappers/dgemmsy/dgemmsy_utils.c", "max_forks_repo_name": "gimunu/octopus-metric", "max_forks_repo_head_hexsha": "baabccd5402922a2f62f5cf6030d15e7ea76dc9b", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 5.0, "max_forks_repo_forks_event_min_datetime": "2016-11-22T20:30:46.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-29T23:24:51.000Z", "avg_line_length": 22.3813333333, "max_line_length": 103, "alphanum_fraction": 0.5483140712, "num_tokens": 3221, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4148988457967688, "lm_q2_score": 0.0367694622493283, "lm_q1q2_score": 0.015255607447814172}}
{"text": "///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n//\n//\n// \t\t\t     //////////////////////////////////////////////////////////\n//  \t\t\t     //\t\t\t\t\t\t\t     //\n// \t\t\t     //   \t        hybridMANTIS v1.0\t\t     //\n// \t\t\t     //                fastDETECT2 - C code                  //\n//\t\t\t     //\t\t   (optical photons transport)\t\t     //\n//  \t\t\t     //\t\t\t\t\t\t\t     //\n//                           //               used for Load Balancing                //\n//\t\t\t     //\t\t\t\t\t\t\t     //\n//\t\t\t     //////////////////////////////////////////////////////////\n//\n// \n//\n//\n// ****Disclaimer****\n//  This software and documentation (the \"Software\") were developed at the Food and Drug Administration (FDA) by employees of the Federal Government in\n//  the course of their official duties. Pursuant to Title 17, Section 105 of the United States Code, this work is not subject to copyright protection\n//  and is in the public domain. Permission is hereby granted, free of charge, to any person obtaining a copy of the Software, to deal in the Software\n//  without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, or sell copies of the\n//  Software or derivatives, and to permit persons to whom the Software is furnished to do so. FDA assumes no responsibility whatsoever for use by other\n//  parties of the Software, its source code, documentation or compiled executables, and makes no guarantees, expressed or implied, about its quality,\n//  reliability, or any other characteristic. Further, use of this code in no way implies endorsement by the FDA or confers any advantage in regulatory\n//  decisions. Although this software can be redistributed and/or modified freely, we ask that any derivative works bear some notice that they are\n//  derived from it, and any modified versions bear some notice that they have been modified. \n//\n//\tDetailed comments are available in \"hybridMANTIS_cuda_ver1_0.cu\" and \"hybridMANTIS_c_ver1_0.c\" files.\n//\n//\tAssociated publication: Sharma Diksha, Badal Andreu and Badano Aldo, \"hybridMANTIS: a CPU-GPU Monte Carlo method for modeling indirect x-ray detectors with\n//\t\t\t\tcolumnar scintillators\". Physics in Medicine and Biology, 57(8), pp. 2357–2372 (2012)\n//\n//\n//\tFile:   \thybridMANTIS_c_ver1_0_LB.c \t\t\t\n//\tAuthor: \tDiksha Sharma (US Food and Drug Administration)\n//\tEmail: \t\tdiksha.sharma@fda.hhs.gov\t\t\t\n//\tLast updated:  \tApr 13, 2012\n// \n///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n\n/////////////////////////////////////////\n//\n//      Header libraries\n//\n/////////////////////////////////////////\n\n#include <gsl/gsl_rng.h>\n#include <gsl/gsl_randist.h>\n\n/////////////////////////////////////////\n//\n//      Global variables\n//\n/////////////////////////////////////////\n\n#define max_photon_per_EDE 900000\t// maximum number of optical photons that can be generated per energy deposition event (EDE)\n\n#ifndef USING_CUDA\n\t#define mybufsizeT 2304000\t// CPU buffer size: # of events sent to the CPU\n#endif\n\n/////////////////////////////////////////\n//\n//      Include kernel program\n//\n/////////////////////////////////////////\n#include \"kernel_cuda_c_ver1_0_LB.cu\"\n\n\n////////////////////////////////////////////////////////////////////////////\n//\t\t\t\tMAIN PROGRAM\t\t\t          //\n////////////////////////////////////////////////////////////////////////////\n\n#ifndef USING_CUDA\n\n///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n//\n// cpuoptlb():   Performs optical transport for finding optimal load using load balancing in the CPU \n//\t  \t Input arguments: cptime, cpubufsize\n//\n//\t\t cptime: \ttime taken by GPU to call this routine\n//\t\t cpubufsize:  \tCPU buffer size defined by user in PENELOPE tally code. Only to be used for load balancing. This is different from 'mybufsize'.\n//\n///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n\n\tvoid cpuoptlb_(double *cptime, int *cpubufsize)\n\t{    \n\n\t\tfloat dcos[3]={0}; \t\t// directional cosines\n\t\tfloat normal[3]={0}; \t\t// normal to surface in case of TIR\n\t\tfloat pos[3] = {0}; \t\t// new position\n\t\tfloat old_pos[3] = {0};  \t// source coordinates\n\t\n\t\t// command line arguments\n\t\tfloat xdetector, ydetector, radius, height, n_C, n_IC, top_absfrac, bulk_abscoeff, beta, d_min, lbound_x, lbound_y, ubound_x, ubound_y, d_max, yield, sensorRefl;\n\t\tint pixelsize, num_primary, min_optphotons, max_optphotons, num_bins;\n\n\t\tint nbytes = (*cpubufsize)*sizeof(struct start_info);\n\t\tstruct start_info *structa;\n\t\tstructa = (struct start_info*) malloc(nbytes);\n\t\tif( structa == NULL )\n\t\t\tprintf(\"\\n Struct start_info array CANNOT BE ALLOCATED - %d !!\", (*cpubufsize));\n\n\t\t// get cpu time\n\t\tclock_t start, end;\n\t\tdouble num_sec;\n\n\t\t// get current time stamp to initialize seed input for RNG\n\t\ttime_t seconds;\n\t\tseconds = time (NULL);\n\t\tstruct timeval tv;\n\t\tgettimeofday(&tv,NULL);\n\n\t\tfloat rr=0.0f, theta=0.0f;\n\t\tfloat r=0.0f;\t\t// random number\n\t\tfloat norm=0.0f;\n\t\tint jj=0;\n\n\t\t// initialize random number generator (RANECU)\n\t\tint seed_input = 271828182 ; // ranecu seed input\n\t\tint seed[2];\n\n\t\t// gsl variables\n\t\tconst gsl_rng_type * Tgsl;\n\t\tgsl_rng * rgsl;\n\t\tdouble mu_gsl;\t\n\t\tint my_index=0;\n\t\tint result_algo = 0;\n\t\tunsigned long long int *num_rebound;\n\n\t\t// output image variables\n\t\tint xdim = 0;\n\t\tint ydim = 0;\n\t\tint indexi=0, indexj=0;\n\n\t      \t// create a generator chosen by the environment variable GSL_RNG_TYPE\n\t       \tgsl_rng_env_setup();\t     \n\t       \tTgsl = gsl_rng_default;\n\t       \trgsl = gsl_rng_alloc (Tgsl);\n\n \t\t// copy to local variables from PENELOPE buffers\n\t\txdetector = inputargs_.detx;\t\t// x dimension of detector (in um). x in (0,xdetector)\n\t\tydetector = inputargs_.dety;\t\t// y dimension of detector (in um). y in (0,ydetector)\n\t\theight = inputargs_.detheight;\t\t// height of column and thickness of detector (in um). z in range (-H/2, H/2)\n\t\tradius = inputargs_.detradius;\t\t// radius of column (in um).\n\t\tn_C = inputargs_.detnC;\t\t\t// refractive index of columns\n\t\tn_IC = inputargs_.detnIC;\t\t// refractive index of intercolumnar material\n\t\ttop_absfrac = inputargs_.dettop;\t// column's top surface absorption fraction (0.0, 0.5, 0.98)\n\t\tbulk_abscoeff = inputargs_.detbulk;\t// column's bulk absorption coefficient (in um^-1) (0.001, 0.1 cm^-1) \n\t\tbeta = inputargs_.detbeta;\t\t// roughness coefficient of column walls\n\t\td_min = inputargs_.detdmin;\t\t// minimum distance a photon can travel when transmitted from a column\n\t\td_max = inputargs_.detdmax;\n\t\tlbound_x = inputargs_.detlboundx;\t// x lower bound of region of interest of output image (in um)\n\t\tlbound_y = inputargs_.detlboundy;\t// y lower bound (in um)\n\t\tubound_x = inputargs_.detuboundx;\t// x upper bound (in um) \n\t\tubound_y = inputargs_.detuboundy;\t// y upper bound (in um)\n\t\tyield = inputargs_.detyield;\t\t// yield (/eV)\n\t\tpixelsize = inputargs_.detpixel;\t// 1 pixel = pixelsize microns (in um)\n\t\tsensorRefl = inputargs_.detsensorRefl;\t// Non-Ideal sensor reflectivity (%)\n\t\tnum_primary = inputargs_.mynumhist;\t// total number of primaries to be simulated\n\t\tmin_optphotons = inputargs_.minphotons;\t// minimum number of optical photons detected to be included in PHS\n\t\tmax_optphotons = inputargs_.maxphotons;\t// maximum number of optical photons detected to be included in PHS\n\t\tnum_bins = inputargs_.mynumbins;\t// number of bins for genrating PHS\n\t\t\n\t\t// dimensions of PRF image\n\t\txdim = ceil((ubound_x - lbound_x)/pixelsize);\n\t\tydim = ceil((ubound_y - lbound_y)/pixelsize);\n\t\tunsigned long long int myimage[xdim][ydim];\n\t\t\n\t\t// memory for storing histogram of # photons detected/primary\n\t\tint *h_num_detected_prim = 0;\t\t\n\t\th_num_detected_prim = (int*)malloc(sizeof(int)*num_primary);\n\t\t\t\n\t\tfor(indexj=0; indexj < num_primary; indexj++)\n\t\t  h_num_detected_prim[indexj] = 0;\n\t\t  \t \n\t\t// start the clock\n\t\tstart = clock();\n\n\tfor(my_index = 0; my_index < (*cpubufsize); my_index++)\t\t// iterate over x-rays\n\t{\n\n\t\t// reset the global counters\n\t\tnum_generatedT = 0;\n\t\tnum_detectT=0;\n\t\tnum_abs_topT=0;\t\n\t\tnum_abs_bulkT=0;\t\n\t\tnum_lostT=0;\n\t\tnum_outofcolT=0;\n\t\tnum_theta1T=0;\n\t\tphoton_distanceT=0.0f;\n\n\t\t// copying fortran buffer into *structa\n\n\t\t// units in the penelope output file are in cm. Convert to microns.\n\t\tstructa[my_index].str_x = optical_.xbufopt[my_index] * 10000.0f;\t// x-coordinate of interaction event.\n\t\tstructa[my_index].str_y = optical_.ybufopt[my_index] * 10000.0f;\t// y-coordinate\n\t\tstructa[my_index].str_z = optical_.zbufopt[my_index] * 10000.0f;\t// z-coordinate\n\t\tstructa[my_index].str_E = optical_.debufopt[my_index];\t\t\t// energy deposited\n\t\tstructa[my_index].str_histnum = optical_.nbufopt[my_index];\t\t// x-ray history number\n\n\t\t// sample # optical photons based on light yield and energy deposited for this interaction event (using Poisson distribution)\n\t\tmu_gsl = (double)structa[my_index].str_E * yield;\n\t\tstructa[my_index].str_N = gsl_ran_poisson(rgsl,mu_gsl);\n\n\t\tif(structa[my_index].str_N > max_photon_per_EDE)\n\t\t{\n\t\t\tprintf(\"\\n\\n CPU str_n exceeds max photons. program is exiting - %d !! \\n\\n\",structa[my_index].str_N);\n\t\t\texit(0);\n\t\t}\n\n\t\tnum_rebound = (unsigned long long int*) malloc(structa[my_index].str_N*sizeof(unsigned long long int));\n\t\tif(num_rebound == NULL)\n\t\t\tprintf(\"\\n Error allocating num_rebound memory !\\n\");\n\n\n\t\t// initialize the RANECU generator in a position far away from the previous history:\n\t\tseed_input = (int)(seconds/3600+tv.tv_usec);\t\t\t// seed input=seconds passed since 1970+current time in micro secs\n\t\tinit_PRNG(my_index, 50000, seed_input, seed);      \t\t// intialize RNG\n\n\t\tfor(jj=0; jj<structa[my_index].str_N; jj++)\n\t\t\tnum_rebound[jj] = 0;\n\n\t\t// reset the vectors\n\t\tdcos[0]=0.0f; dcos[1]=0.0f; dcos[2]=0.0f;\n\t\tnormal[0]=0.0f; normal[1]=0.0f; normal[2]=0.0f;\n\n\t\t// set starting location of photon\n\t\tpos[0] = structa[my_index].str_x; pos[1] = structa[my_index].str_y; pos[2] = structa[my_index].str_z;\t\n\t\told_pos[0] = structa[my_index].str_x; old_pos[1] = structa[my_index].str_y; old_pos[2] = structa[my_index].str_z;\n\n\t\t// initializing the direction cosines for the first particle in each core\n\t\tr = (ranecu(seed) * 2.0f) - 1.0f; // random number between (-1,1)\n\t\t \t\n\t\twhile(fabs(r) <= 0.01f)\t\n\t\t {\n\t\t   \tr = (ranecu(seed) * 2.0f) - 1.0f;  \t\n\t\t }\n\n\t\tdcos[2] = r;\t\t// random number between (-1,1)\n\t\trr = sqrt(1.0f-r*r);\n\t\ttheta=ranecu(seed)*twopipen;\n\t\tdcos[0]=rr*cos(theta);\n\t\tdcos[1]=rr*sin(theta);\n\n\t\tnorm = sqrt(dcos[0]*dcos[0] + dcos[1]*dcos[1] + dcos[2]*dcos[2]);\n\n\t\tif ((norm < (1.0f - epsilon)) || (norm > (1.0f + epsilon)))\t// normalize\n\t\t {\n\t\t\tdcos[0] = dcos[0]/norm;\n\t\t\tdcos[1] = dcos[1]/norm;\n\t\t\tdcos[2] = dcos[2]/norm;\n\t\t }\n\n\t\tlocal_counterT=0;\n\t\twhile(local_counterT < structa[my_index].str_N)\n\t\t { \n\t\t\t\n\t\t\tabsorbedT = 0;\n\t\t\tdetectT = 0;\n\t\t\tbulk_absT = 0;\n\n\t\t\t// set starting location of photon\n\t\t\tpos[0] = structa[my_index].str_x; pos[1] = structa[my_index].str_y; pos[2] = structa[my_index].str_z;\t\n\t\t\told_pos[0] = structa[my_index].str_x; old_pos[1] = structa[my_index].str_y; old_pos[2] = structa[my_index].str_z;\n\t\t\tnum_generatedT++;\n\t\t\tresult_algo = 0;\n\n\t\t\twhile(result_algo == 0)\n\t\t\t {\n\t\t\t  \tresult_algo = algoT(normal, old_pos, pos, dcos, num_rebound, seed, structa[my_index], &myimage[0][0], xdetector, ydetector, radius, height, n_C, n_IC, top_absfrac, bulk_abscoeff, beta, d_min, pixelsize, lbound_x, lbound_y, ubound_x, ubound_y, sensorRefl, d_max, ydim, h_num_detected_prim);      \n\t\t\t }\n\n\t\t }\t\n\n\t\t// release resources\n\t\tfree(num_rebound);\n\n\t}\t// my_index loop ends\n\n\n\t// end the clock\t\t\n\tend = clock();\n\n\tnum_sec = (double)((end - start)/CLOCKS_PER_SEC);\n        *cptime = num_sec;\n        \n\t// release resources\n\tfree(structa);\n\tfree(h_num_detected_prim);\n\n\t\treturn;\n\t}\t// C main() ends\n\t\n#endif\n", "meta": {"hexsha": "be9f33e7d7296786f8b658f9515a8c78dcfc04d9", "size": 12094, "ext": "c", "lang": "C", "max_stars_repo_path": "main/hybridMANTIS_c_ver1_0_LB.c", "max_stars_repo_name": "diamfda/hybridmantis", "max_stars_repo_head_hexsha": "8e2d374baaad27b3eae62fab34bea7675eb1ee4d", "max_stars_repo_licenses": ["BSD-Source-Code"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "main/hybridMANTIS_c_ver1_0_LB.c", "max_issues_repo_name": "diamfda/hybridmantis", "max_issues_repo_head_hexsha": "8e2d374baaad27b3eae62fab34bea7675eb1ee4d", "max_issues_repo_licenses": ["BSD-Source-Code"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "main/hybridMANTIS_c_ver1_0_LB.c", "max_forks_repo_name": "diamfda/hybridmantis", "max_forks_repo_head_hexsha": "8e2d374baaad27b3eae62fab34bea7675eb1ee4d", "max_forks_repo_licenses": ["BSD-Source-Code"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.8581081081, "max_line_length": 301, "alphanum_fraction": 0.6134446833, "num_tokens": 3414, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.39981164073979497, "lm_q2_score": 0.03789242499987083, "lm_q1q2_score": 0.015149832610807983}}
{"text": "# ifndef LANGIL_H\n# define LANGIL_H\n\n///////////////////////////////////////////////////////\n//////   GILLESPIE CLASS\n//////\n//////\t\t\t\t\t\tR. Perez-Carrasco\n//////                               Created: 16 Nov '13\n///////////////////////////////////////////////////////\n/* Class for simulating master equation through langil algorythm. It defines three classes:\n\t\t- langil: In charge of the integration\n\t\t- species: contains a name a number and methods to change number\n\t\t- reaction: contains a name, a stoiciometry associated and a pointer to a propensity computing function\t\t\n*/\n\n#include <gsl/gsl_rng.h>\n#include <gsl/gsl_randist.h>\n#include <string>\n#include <fstream>\n#include <iostream>\n#include <unordered_map>\n#include <vector>\n#include <math.h>\n#include <time.h>\n#include <unistd.h>\n#include <iomanip>\n//#include <omp.h>\n\n#include \"species.h\"\n#include \"cell_cycle.h\"\n\n#define VERBOSE 1\n#define NON_VERBOSE 0\n\n#define TIMESTEPMULT 3\n#define TIMESTEP 0\n#define ALL 1\n#define NOWRITE 2\n#define LASTPOINT 4\n\n#define GILLESPIE 0\n#define MACROSCOPIC 2\n#define CLEEULER 1\n#define CLEMILSTEIN 3\t\t\n\n#define ADIABATIC true\n#define NONADIABATIC false\n\n#define GEOMETRIC true\n#define NONGEOMETRIC false\n\n#define DETERMINISTIC_TIME true\n#define STOCHASTIC_TIME false\n\n#define EXPONENTIAL_REACTION 0\n#define GEOMETRIC_REACTION 1\n#define DETERMINISTIC_REACTION 2\n#define ADIABATIC_REACTION 3\n\n\nusing namespace std;\n\n\nstruct StructDivisionState{\n\tdouble time;\n\tdouble species0before;\n\tdouble species1before;\n\tdouble species0after;\n\tdouble species1after;\n};\n\n\nclass reaction; // defined after langil\nclass species; // defined after reaction\nclass expressionzone; // defined in a separate file\n\nclass langil{\n\t\n\tfriend class expressionzone;\n\n//\tfriend class reaction; // reaction have access to the state of the system \n\n\tpublic:\n\n\t\tlangil(string outputfilename, double vol=100, int seed=-1);\n\t\tvoid SetState(string aname, float anumber); //Set Initial conditions\n\t\tdouble GetState(string a); // get the state of the selected species\n\t\tvoid SetTime(double time); //Set current time\n\t\tvoid AddSpecies(string aname, float anum); // Add a new molecular species\n\t\tvoid AddSpeciesTimeTracking(string aname, float anum, double lifetime); //  Add a molecular species with a timer\n\t\tvoid AddCellCycleSpecies(); // add a cell cycle to the system\n\t\tvoid addCellPhase(double duration, int type_phase); // add a cell phase to the cell cycle\n\t\tvoid PrintSummarySpecies();\n\t\tstring StateString();\n\t\tvoid Add_Reaction(string name,vector<int> stoich,double (*prop_f)(v_species&),int typeofrec = EXPONENTIAL_REACTION); // Add a reaction to the system overloaded to create directly\n\t\tvoid UpdateTime(); // Update times for the deterministic events \n\t\tvoid SetRunType(int rt,double dt=0);\n\t\tdouble GillespieStep(double timelimit = -1); // Advance one step in the Gillespie algorithm. Returns time of the step. Timelimit does not react if the reaction would take more than timelimit\n\t\tdouble LangevinEulerStep(double timelimit = -1); // Make an Euler-Maruyama integration step\n\t\tdouble LangevinMilsteinStep(double timelimit = -1); // Make an SDE integration step with the Milstein algorithm (not tested)\n\t\tdouble MacroStep(double timlimit = -1); // Make an Euler (deterministic) step\n\t\tdouble MacroAdiabaticStep(double dtt); //  Make an Euler step if the Adiabaitc species\t\t\n\t\tdouble Run(double time, bool verbose=true); // React until reach time time\n\t\tdouble RunTimes(int N,double time, bool verbose=true); // Run Run() N times\n\t\tdouble RunTransition(bool (*prop_f)(v_species&), bool (*prop_g)(v_species&), int loops, double maxT); // Run transition between two points, if loops=1 it also records the transition trajectory\n\t\tvoid WriteState(); // Write state in file \n\t\tvoid WriteTempState(); // Write state in file \n\t\tvoid WritePrevrecState(); // Write previous recorded state in file \n\t\tvoid SetWriteState(int flag, double tl=0);// Switch betweem different states:\n\t\tdouble (langil::*MakeStep)(double); // pointer to the actual integration chosen\n\t\t\t// TIMESTEP: write the state every tl time lapse\n\t\t\t// ALL: write after each reaction takes place\n\t\t\t// NOWRITE: don't write anything in output file\n\t\tdouble SetLangevinTimeStep(double dx); // set dt to a characteristic time that will increase with the size of the system\n\t\tvoid Add_TimeAction(double (*actionfunc)(double));\n\t\tvoid RunTimeAction();\n\t\tvoid setPhaseDuration(int phase, double duration, int type_phase);\n\t\tvoid Set_AdiabaticReaction(string aname);\n\t\tvoid Set_GeometricReaction(string aname);\n\t\tvoid Set_Boundary_Behaviour(void (*b_b)(v_species&, v_species&)); // Boundary behaviour\n\t\tvoid Set_StoreDivisionTimes();// activate the storage of division times in DivisionTimes vector\n\t\tvoid (*Boundary_Behaviour)(v_species&, v_species&); // boundary behaviour function\n\t\tvector<StructDivisionState> Get_HistoryDivision();\n\t\tvoid Reset_HistoryDivision();\n\t\tvoid SetDivisionHistory(int b,int a);\n\n\n\tprotected:\n\n\t\tv_species x; //value of each species. shared_ptr is used since the vector can contain species and also childrens of that class (i.e. different classes)\n\t\tvector<reaction> r;//vector with all the reactions\n \t\tdouble time; // current time of simulation\n\t\tgsl_rng * rng; // allocator for the rng generator\n\t\tvector<double> rnd; // rnd numbers\n\t\tvector<double> xtemp; // temporal vector for integrations\n\t\tv_species xtemp0,xtemp1; // temporal vector for integrations\n\t\tdouble pro,pro0; // auxiliar variables for the program\n\t\tint sto;  // auxiliar value for stoichiometry\n\t\tdouble totalprop,cumprop, detprop; // sum of the propensities\n\t\tdouble nexttau; // time of the next step\n\t\tvector<reaction>::iterator nextreaction; // reaction selected to react\n\t\tvector<int>* nextstoichiometry;\n\t\tdouble Omega; // volume of the system to change between concentrations and absolute numbers\n\t\tdouble signal; // variable that can modulate an external signal its time course\n\t\t\t\t\t\t// may be changed through time actions with Add_TimeAction\n\t\tint celldivided; // flag to track possible celldivision\n\t\tint geostoichiometry; // dummy variable to set random geometric stoichiometries\n\t\n\t\tbool record; // Set record of the trajectory\n\t\tofstream trajfile; // File for output traj\n\t\tstring outputfilename; // File for output name\n\t\tint fwrite; // flag for write state when integrating\n\t\tdouble timelapse; // dt for recording if TIMESTEP\n\t\tdouble nextrectime; // t for recording if TIMESTEP\n\t\tdouble totaltime; // total integration time for the trajectory\n\t\tdouble dt; // timestep used in integrations for macroscopic and langevin (if negative, it is used by Langevin as a prediction for dx)\n\t\t\n\t\tint cellcyclespeciesidx;  // index of the species vector that tracks cell cycle phases\n \t\tcell_cycle cell; // cell_cycle object to manage cell cycle events\n\n \t\tbool fStoreDivisionTimes; // flag to store Division Times\n \t\tvector<StructDivisionState> DivisionHistoryVector; // Division history vector. Each component is a vector \n \t\tStructDivisionState divisionstate;\n\t\tvector<double(*)(double)> actionfuncvec; // vector to time action functions\n\n};\n\n\n\n\n////////////////////////////////////////////////////////////////////////////\n///////////////////////////////////////////////////////////////////////////////\nclass reaction{//Class containing the info of each reaction. Each reaction added \n// through the method Add_Reaction(reaction) will be stored as an element in a vector\n// by langil class. The pointer x, points out to the state of the langil system and\n// is managed automatically by langil when a reaction is added to a langil instance\n// It has also the property \"adiabatic\" meaning that it is a fast variable and can always be simulated\n// from its deterministic behaviour\n\n\tfriend class langil;\n\n\tpublic:\n\t\t\n\t\t\n\treaction(string aname,vector<int> asto,double (*aprop_f)(v_species&)=NULL,int reacttype= EXPONENTIAL_REACTION, \n\t\t    vector<reaction>* x0=NULL){\n\t\t\tname=aname;\n\t\t\tstoichiometry=asto;\n\t\t\tprop_f=aprop_f;\n\t\t\treactiontype=reacttype;\n\t\t}\n\t\tdouble GetPropensity(){\n\t\t\treturn prop_f(*x);\n\t\t}\n\t\tdouble GetPropensity(v_species& x0){\n\t\t\treturn prop_f(x0);\n\t\t}\n\t\tstring GetName(){\n\t\t\treturn name;\n\t\t}\n\t\tvoid SetPropensity(double (*p_f)(v_species&)){\n\t\t\tprop_f=p_f;\n\t\t}\n\t\tvoid SetState(v_species& x0){\n\t\t\tx=&x0;\n\t\t}\n\t\tvector<int>* GetStoichiometry(){\n\t\t\treturn &stoichiometry;\n\t\t}\n\t\tbool IsAdiabatic(){\n\t\t\treturn (reactiontype == ADIABATIC_REACTION);\n\t\t}\n\t\tbool IsNotAdiabatic(){\n\t\t\treturn (reactiontype != ADIABATIC_REACTION);\n\t\t}\n\t\tbool IsGeometric(){\n\t\t\treturn (reactiontype == GEOMETRIC_REACTION);\n\t\t}\n\t\tbool IsNotGeometric(){\n\t\t\treturn (reactiontype != GEOMETRIC_REACTION);\n\t\t}\n\t\tbool IsNotDetermTime(){\n\t\t\treturn (reactiontype != (DETERMINISTIC_REACTION));\n\t\t}\n\t\tbool IsDetermTime(){\n\t\t\treturn (reactiontype == (DETERMINISTIC_REACTION));\n\t\t}\n\t\tvoid SetAdiabatic(){\n\t\t\treactiontype = ADIABATIC_REACTION;\n\t\t}\n\t\tvoid SetGeometric(){\n\t\t\treactiontype = GEOMETRIC_REACTION;\n\t\t}\n\t\tvoid SetDeterministicTime(){\n\t\t\treactiontype = DETERMINISTIC_REACTION;\n\t\t}\t\n\n\tprotected:\n\n\t\tstring name; // name of the reactio\n\t\tvector<int> stoichiometry; // stoichiometry\n\t\tdouble (*prop_f)(v_species&); // propensity function\n\t\tv_species* x;  //value of each species. shared_ptr is used since the vector can contain species and also childrens of that class (i.e. different classes)\n\t\tint reactiontype; // can be any of the macros EXPONENTIAL_REACTION, DETERMINISITIC_REACTION, etc.\n\n // of the system\n\n\n};\n\n\n\n#endif\n", "meta": {"hexsha": "b5eecb5545d8e2a6d5cb4e95081883b2985c997e", "size": 9428, "ext": "h", "lang": "C", "max_stars_repo_path": "langil.h", "max_stars_repo_name": "2piruben/langil", "max_stars_repo_head_hexsha": "e2e41d8d00f7de9a1ba1c014d4bac8b364dbd856", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "langil.h", "max_issues_repo_name": "2piruben/langil", "max_issues_repo_head_hexsha": "e2e41d8d00f7de9a1ba1c014d4bac8b364dbd856", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "langil.h", "max_forks_repo_name": "2piruben/langil", "max_forks_repo_head_hexsha": "e2e41d8d00f7de9a1ba1c014d4bac8b364dbd856", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.1181102362, "max_line_length": 194, "alphanum_fraction": 0.7259227832, "num_tokens": 2323, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.49218813572079556, "lm_q2_score": 0.030214588268123326, "lm_q1q2_score": 0.01487126187125904}}
{"text": "/*\n * Copyright 2012-2016 M. Andersen and L. Vandenberghe.\n * Copyright 2010-2011 L. Vandenberghe.\n * Copyright 2004-2009 J. Dahl and L. Vandenberghe.\n *\n * This file is part of CVXOPT.\n *\n * CVXOPT is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or\n * (at your option) any later version.\n *\n * CVXOPT is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program.  If not, see <http://www.gnu.org/licenses/>.\n */\n\n#include \"cvxopt.h\"\n\n#include <complex.h>\n\n#include \"misc.h\"\n\n#include <gsl/gsl_rng.h>\n#include <gsl/gsl_randist.h>\n\n#include <time.h>\n\nPyDoc_STRVAR(gsl__doc__,\"Random Module.\");\n\nstatic unsigned long seed = 0;\nstatic const gsl_rng_type *rng_type;\nstatic gsl_rng *rng;\n\nstatic char doc_getseed[] =\n  \"Returns the seed value for the random number generator.\\n\\n\"\n  \"getseed()\";\n\nstatic PyObject * getseed(PyObject *self)\n{\n  return Py_BuildValue(\"l\",seed);\n}\n\nstatic char doc_setseed[] =\n  \"Sets the seed value for the random number generator.\\n\\n\"\n  \"setseed(value = 0)\\n\\n\"\n  \"ARGUMENTS\\n\"\n  \"value     integer seed. If the value is 0, then the system clock\\n\"\n  \"          measured in seconds is used instead\";\n\nstatic PyObject * setseed(PyObject *self, PyObject *args)\n{\n  unsigned long seed_ = 0;\n  time_t seconds;\n\n  if (!PyArg_ParseTuple(args, \"|l\", &seed_))\n    return NULL;\n\n  if (!seed_) {\n    time(&seconds);\n    seed = (unsigned long)seconds;\n  }\n  else seed = seed_;\n\n  return Py_BuildValue(\"\");\n}\n\n\nstatic char doc_normal[] =\n  \"Randomly generates a matrix with normally distributed entries.\\n\\n\"\n  \"normal(nrows, ncols=1, mean=0, std=1)\\n\\n\"\n  \"PURPOSE\\n\"\n  \"Returns a matrix with typecode 'd' and size nrows by ncols, with\\n\"\n  \"its entries randomly generated from a normal distribution with mean\\n\"\n  \"m and standard deviation std.\\n\\n\"\n  \"ARGUMENTS\\n\"\n  \"nrows     number of rows\\n\\n\"\n  \"ncols     number of columns\\n\\n\"\n  \"mean      approximate mean of the distribution\\n\\n\"\n  \"std       standard deviation of the distribution\";\nstatic PyObject *\nnormal(PyObject *self, PyObject *args, PyObject *kwrds)\n{\n  matrix *obj;\n  int i, nrows, ncols = 1;\n  double m = 0, s = 1;\n  char *kwlist[] = {\"nrows\", \"ncols\", \"mean\", \"std\",  NULL};\n\n  if (!PyArg_ParseTupleAndKeywords(args, kwrds, \"i|idd\", kwlist,\n\t  &nrows, &ncols, &m, &s)) return NULL;\n\n  if (s < 0.0) PY_ERR(PyExc_ValueError, \"std must be non-negative\");\n\n  if ((nrows<0) || (ncols<0)) {\n    PyErr_SetString(PyExc_TypeError, \"dimensions must be non-negative\");\n    return NULL;\n  }\n\n  if (!(obj = Matrix_New(nrows, ncols, DOUBLE)))\n    return PyErr_NoMemory();\n\n  gsl_rng_env_setup();\n  rng_type = gsl_rng_default;\n  rng = gsl_rng_alloc (rng_type);\n  gsl_rng_set(rng, seed);\n\n  for (i = 0; i < nrows*ncols; i++)\n    MAT_BUFD(obj)[i] = gsl_ran_gaussian (rng, s) + m;\n\n  seed = gsl_rng_get (rng);\n  gsl_rng_free(rng);\n\n  return (PyObject *)obj;\n}\n\nstatic char doc_uniform[] =\n  \"Randomly generates a matrix with uniformly distributed entries.\\n\\n\"\n  \"uniform(nrows, ncols=1, a=0, b=1)\\n\\n\"\n  \"PURPOSE\\n\"\n  \"Returns a matrix with typecode 'd' and size nrows by ncols, with\\n\"\n  \"its entries randomly generated from a uniform distribution on the\\n\"\n  \"interval (a,b).\\n\\n\"\n  \"ARGUMENTS\\n\"\n  \"nrows     number of rows\\n\\n\"\n  \"ncols     number of columns\\n\\n\"\n  \"a         lower bound\\n\\n\"\n  \"b         upper bound\";\n\nstatic PyObject *\nuniform(PyObject *self, PyObject *args, PyObject *kwrds)\n{\n  matrix *obj;\n  int i, nrows, ncols = 1;\n  double a = 0, b = 1;\n\n  char *kwlist[] = {\"nrows\", \"ncols\", \"a\", \"b\", NULL};\n\n  if (!PyArg_ParseTupleAndKeywords(args, kwrds, \"i|idd\", kwlist,\n\t  &nrows, &ncols, &a, &b)) return NULL;\n\n  if (a>b) PY_ERR(PyExc_ValueError, \"a must be less than b\");\n\n  if ((nrows<0) || (ncols<0))\n    PY_ERR_TYPE(\"dimensions must be non-negative\");\n\n  if (!(obj = (matrix *)Matrix_New(nrows, ncols, DOUBLE)))\n    return PyErr_NoMemory();\n\n  gsl_rng_env_setup();\n  rng_type = gsl_rng_default;\n  rng = gsl_rng_alloc (rng_type);\n  gsl_rng_set(rng, seed);\n\n  for (i= 0; i < nrows*ncols; i++)\n    MAT_BUFD(obj)[i] = gsl_ran_flat (rng, a, b);\n\n  seed = gsl_rng_get (rng);\n  gsl_rng_free(rng);\n\n  return (PyObject *)obj;\n}\n\nstatic PyMethodDef gsl_functions[] = {\n{\"getseed\", (PyCFunction)getseed, METH_VARARGS|METH_KEYWORDS, doc_getseed},\n{\"setseed\", (PyCFunction)setseed, METH_VARARGS|METH_KEYWORDS, doc_setseed},\n{\"normal\", (PyCFunction)normal, METH_VARARGS|METH_KEYWORDS, doc_normal},\n{\"uniform\", (PyCFunction)uniform, METH_VARARGS|METH_KEYWORDS, doc_uniform},\n{NULL}  /* Sentinel */\n};\n\n#if PY_MAJOR_VERSION >= 3\n\nstatic PyModuleDef gsl_module = {\n    PyModuleDef_HEAD_INIT,\n    \"gsl\",\n    gsl__doc__,\n    -1,\n    gsl_functions,\n    NULL, NULL, NULL, NULL\n};\n\nPyMODINIT_FUNC PyInit_gsl(void)\n{\n  PyObject *m;\n  if (!(m = PyModule_Create(&gsl_module))) return NULL;\n  if (import_cvxopt() < 0) return NULL;\n  return m;\n}\n\n#else\n\nPyMODINIT_FUNC initgsl(void)\n{\n  PyObject *m;\n  m = Py_InitModule3(\"cvxopt.gsl\", gsl_functions, gsl__doc__);\n  if (import_cvxopt() < 0) return;\n}\n\n#endif\n", "meta": {"hexsha": "d44f7ea6ef3ab62c3736b41a7c5f1b9d2e3dd82b", "size": 5391, "ext": "c", "lang": "C", "max_stars_repo_path": "src/cpp/qpsolver/cvxopt/src/C/gsl.c", "max_stars_repo_name": "Hap-Hugh/quicksel", "max_stars_repo_head_hexsha": "10eee90b759638d5c54ba19994ae8e36e90e12b8", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 15.0, "max_stars_repo_stars_event_min_datetime": "2020-07-07T16:32:53.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-16T14:23:23.000Z", "max_issues_repo_path": "src/cpp/qpsolver/cvxopt/src/C/gsl.c", "max_issues_repo_name": "Hap-Hugh/quicksel", "max_issues_repo_head_hexsha": "10eee90b759638d5c54ba19994ae8e36e90e12b8", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2020-09-02T15:25:39.000Z", "max_issues_repo_issues_event_max_datetime": "2020-09-24T08:37:18.000Z", "max_forks_repo_path": "src/cpp/qpsolver/cvxopt/src/C/gsl.c", "max_forks_repo_name": "Hap-Hugh/quicksel", "max_forks_repo_head_hexsha": "10eee90b759638d5c54ba19994ae8e36e90e12b8", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 6.0, "max_forks_repo_forks_event_min_datetime": "2020-08-14T22:02:07.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-31T07:08:29.000Z", "avg_line_length": 26.4264705882, "max_line_length": 75, "alphanum_fraction": 0.6781673159, "num_tokens": 1591, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3073580168652638, "lm_q2_score": 0.048136771799400395, "lm_q1q2_score": 0.014795222718559462}}
{"text": "/**\n * Licensed to the Apache Software Foundation (ASF) under one\n * or more contributor license agreements.  See the NOTICE file\n * distributed with this work for additional information\n * regarding copyright ownership.  The ASF licenses this file\n * to you under the Apache License, Version 2.0 (the\n * \"License\"); you may not use this file except in compliance\n * with the License.  You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n#ifndef SINGA_CORE_TENSOR_TENSOR_MATH_CPP_H_\n#define SINGA_CORE_TENSOR_TENSOR_MATH_CPP_H_\n\n#include \"./tensor_math.h\"\n//#include \"./stacktrace.h\"\n#include <math.h>\n\n#include <algorithm>\n#include <cfloat>\n#include <iostream>\n#include <iterator>\n#include <sstream>\n\n#include \"singa/core/common.h\"\n#include \"singa/core/tensor.h\"\n\n#ifdef USE_CBLAS\n#include <cblas.h>\n#endif\n\nnamespace singa {\n\n// ===================== Helper Functions =============================\n\n// generate a traversal_info vector based on the tensor's shape for the\n// traverse_next function to work\nvector<int> generate_traversal_info(const Tensor &x) {\n  vector<int> traversal_info = {};\n  for (size_t n = 0; n < (x.shape().size() + 2); ++n) {\n    traversal_info.push_back(0);\n  }\n  return traversal_info;\n};\n\n// generate shape multipliers\n// for e.g. tensor of shape (3,3), stride (1,3) will have shape multipliers of\n// (3,1)\n// for e.g. tensor of shape (3,3), stride (3,1) will also have shape multipliers\n// of (3,1)\n// this means that the 3rd, 6th, and 9th index of the array will always be the\n// starting element of their respective rows\n// so we need to need use the inner stride when jumping from 1st->2nd element,\n// and outer stride when jumping from 2nd->3rd\nvector<int> generate_shape_multipliers(const Tensor &x) {\n  Shape y_shape = x.shape();\n  if (y_shape.size() == 0) {\n    return {1};\n  }\n  vector<int> shape_multipliers = {1};\n  int cumulative_product = 1;\n\n  for (size_t n = 0; n < (y_shape.size() - 1); ++n) {\n    cumulative_product = cumulative_product * y_shape[y_shape.size() - 1 - n];\n    shape_multipliers.insert(shape_multipliers.begin(), cumulative_product);\n  }\n  return shape_multipliers;\n};\n\n// ******************************************************************************************\n// CPP traversal operations (works on const declarations without modifying\n// tensor variables)\n// ******************************************************************************************\n\n// this function checks whether the next index falls on a special multiplier of\n// the outer shape\n// so the algorithm knows when to jump over/back to a starting element of the\n// outer shape\n// for e.g. in [[1,4,7], [2,5,8], [3,6,9]], elements 1,2,3 are the starting\n// elements of their respective rows\n// this additional check only has 1 loop for 2d matrix\n// but runtime performance might degrade to O(nlog(n)) for higher dimensional\n// tensors\nint determine_order(vector<int> &shape_multipliers, int counter) {\n  for (size_t n = 0; n < (shape_multipliers.size() - 1); ++n) {\n    if ((counter % shape_multipliers[n]) == 0) {\n      return ((shape_multipliers.size()) - 1 - n);\n    }\n  }\n  return 0;\n};\n\n// this function updates the base indexes with the current index after every\n// single traversal step,\n// can be generalized beyond 2d cases\nvoid update_base_index(const Tensor &x, vector<int> &traversal_info) {\n  for (int n = 0; n < (traversal_info[x.shape().size() + 1] + 1); ++n) {\n    traversal_info[n] = traversal_info[x.shape().size()];\n  }\n};\n\n// function to traverse a const strided tensor object\n// it requires an additional vector, traversal_info {0,0,0,0 ...}, comprising\n// (x.shape().size()+2) elements of 0\n// for e.g. 2d matrix:\n// index 0 and 1 store the base row and column index respectively\n// index 2 stores the current index of the traversal\n// index 3 stores the order of the traversal for e.g. if the order is 0,\n// it means the next element can be navigated to using the innermost stride\nvoid traverse_next(const Tensor &x, vector<int> &shape_multipliers,\n                   vector<int> &traversal_info, int counter) {\n  update_base_index(x, traversal_info);\n  traversal_info[x.shape().size() + 1] =\n      determine_order(shape_multipliers, counter);\n  traversal_info[x.shape().size()] =\n      traversal_info[traversal_info[x.shape().size() + 1]] +\n      x.stride()[x.stride().size() - traversal_info[x.shape().size() + 1] - 1];\n};\n\ninline int next_offset(int offset, const vector<size_t> &shape,\n                       const vector<int> &stride, vector<int> *index) {\n  for (int k = shape.size() - 1; k >= 0; k--) {\n    if (index->at(k) + 1 < int(shape.at(k))) {\n      offset += stride.at(k);\n      index->at(k) += 1;\n      break;\n    }\n    index->at(k) = 0;\n    offset -= stride.at(k) * (shape.at(k) - 1);\n  }\n  return offset;\n}\n\ntemplate <typename DType>\nvoid traverse_unary(const Tensor &in, Tensor *out,\n                    std::function<DType(DType)> func) {\n  DType *outPtr = static_cast<DType *>(out->block()->mutable_data());\n  const DType *inPtr = static_cast<const DType *>(in.block()->data());\n  /*\n  vector<int> traversal_info = generate_traversal_info(in);\n  vector<int> shape_multipliers = generate_shape_multipliers(in);\n\n  for (size_t i = 0; i < in.Size(); i++) {\n    outPtr[i] = func(inPtr[traversal_info[in.shape().size()]]);\n    traverse_next(in, shape_multipliers, traversal_info, i + 1);\n  }\n  */\n  CHECK(in.shape() == out->shape());\n  if (in.stride() == out->stride()) {\n    for (size_t i = 0; i < in.Size(); i++) outPtr[i] = func(inPtr[i]);\n  } else {\n    // LOG(INFO) << \"not equal stride\";\n    size_t in_offset = 0, out_offset = 0;\n    vector<int> in_idx(in.nDim(), 0), out_idx(out->nDim(), 0);\n    for (size_t i = 0; i < Product(in.shape()); i++) {\n      outPtr[out_offset] = func(inPtr[in_offset]);\n      out_offset =\n          next_offset(out_offset, out->shape(), out->stride(), &out_idx);\n      in_offset = next_offset(in_offset, in.shape(), in.stride(), &in_idx);\n    }\n  }\n}\n\ntemplate <typename DType>\nvoid traverse_binary(const Tensor &in1, const Tensor &in2, Tensor *out,\n                     std::function<DType(DType, DType)> func) {\n  DType *outPtr = static_cast<DType *>(out->block()->mutable_data());\n  const DType *in1Ptr = static_cast<const DType *>(in1.block()->data());\n  const DType *in2Ptr = static_cast<const DType *>(in2.block()->data());\n  /*\n  vector<int> traversal_info_in1 = generate_traversal_info(in1);\n  vector<int> traversal_info_in2 = generate_traversal_info(in2);\n  vector<int> shape_multipliers_in1 = generate_shape_multipliers(in1);\n  vector<int> shape_multipliers_in2 = generate_shape_multipliers(in2);\n\n  for (size_t i = 0; i < in1.Size(); i++) {\n    outPtr[i] = func(in1Ptr[traversal_info_in1[in1.shape().size()]],\n                     in2Ptr[traversal_info_in2[in2.shape().size()]]);\n    traverse_next(in1, shape_multipliers_in1, traversal_info_in1, i + 1);\n    traverse_next(in2, shape_multipliers_in2, traversal_info_in2, i + 1);\n  }\n  */\n  auto prod = Product(in1.shape());\n  CHECK(in1.shape() == out->shape());\n  CHECK(in2.shape() == out->shape());\n  if ((in1.stride() == out->stride()) && (in2.stride() == in1.stride())) {\n    for (size_t i = 0; i < prod; i++) outPtr[i] = func(in1Ptr[i], in2Ptr[i]);\n  } else {\n    /*\n    LOG(INFO) << \"not equal stride\";\n    std::ostringstream s1, s2, s3, s4, s5, s6;\n    std::copy(in1.stride().begin(), in1.stride().end(),\n    std::ostream_iterator<int>(s1, \", \"));\n    std::copy(in2.stride().begin(), in2.stride().end(),\n    std::ostream_iterator<int>(s2, \", \"));\n    std::copy(out->stride().begin(), out->stride().end(),\n    std::ostream_iterator<int>(s3, \", \"));\n\n    std::copy(in1.shape().begin(), in1.shape().end(),\n    std::ostream_iterator<int>(s4, \", \"));\n    std::copy(in2.shape().begin(), in2.shape().end(),\n    std::ostream_iterator<int>(s5, \", \"));\n    std::copy(out->shape().begin(), out->shape().end(),\n    std::ostream_iterator<int>(s6, \", \"));\n\n    LOG(INFO) << s1.str() << \": \" << s4.str();\n    LOG(INFO) << s2.str() << \": \" << s5.str();\n    LOG(INFO) << s3.str() << \": \" << s6.str();\n    LOG(INFO) << Backtrace();\n    */\n\n    size_t in1_offset = 0, in2_offset = 0, out_offset = 0;\n    vector<int> in1_idx(in1.nDim(), 0), in2_idx(in2.nDim(), 0),\n        out_idx(out->nDim(), 0);\n    for (size_t i = 0; i < prod; i++) {\n      outPtr[out_offset] = func(in1Ptr[in1_offset], in2Ptr[in2_offset]);\n      out_offset =\n          next_offset(out_offset, out->shape(), out->stride(), &out_idx);\n      in1_offset = next_offset(in1_offset, in1.shape(), in1.stride(), &in1_idx);\n      in2_offset = next_offset(in2_offset, in2.shape(), in2.stride(), &in2_idx);\n      // LOG(INFO) <<  in1_offset << \", \" << in2_offset << \", \" << out_offset;\n    }\n  }\n}\n\n// ******************************************************************************************\n// traversal operations end\n// ******************************************************************************************\n\n// ===================== CUDA Functions =============================\n\ntemplate <>\nvoid Abs<float, lang::Cpp>(const Tensor &in, Tensor *out, Context *ctx) {\n  traverse_unary<float>(in, out, [](float x) { return fabs(x); });\n}\n\ntemplate <>\nvoid Erf<float, lang::Cpp>(const Tensor &in, Tensor *out, Context *ctx) {\n  traverse_unary<float>(in, out, [](float x) { return erff(x); });\n}\n\ntemplate <>\nvoid CastCopy<float, half_float::half, lang::Cpp>(const Tensor *src,\n                                                  Tensor *dst, Context *ctx) {\n  half_float::half *dst_array =\n      static_cast<half_float::half *>(dst->block()->mutable_data());\n  const float *src_array = static_cast<const float *>(src->block()->data());\n  for (int i = 0; i < dst->Size(); ++i)\n    dst_array[i] = static_cast<half_float::half>(src_array[i]);\n}\n\ntemplate <>\nvoid CastCopy<half_float::half, float, lang::Cpp>(const Tensor *src,\n                                                  Tensor *dst, Context *ctx) {\n  float *dst_array = static_cast<float *>(dst->block()->mutable_data());\n  const half_float::half *src_array =\n      static_cast<const half_float::half *>(src->block()->data());\n  for (int i = 0; i < dst->Size(); ++i)\n    dst_array[i] = static_cast<float>(src_array[i]);\n}\n\ntemplate <>\nvoid CastCopy<float, int, lang::Cpp>(const Tensor *src, Tensor *dst,\n                                     Context *ctx) {\n  int *dst_array = static_cast<int *>(dst->block()->mutable_data());\n  const float *src_array = static_cast<const float *>(src->block()->data());\n  for (int i = 0; i < dst->Size(); ++i) dst_array[i] = (int)src_array[i];\n}\n\ntemplate <>\nvoid CastCopy<int, float, lang::Cpp>(const Tensor *src, Tensor *dst,\n                                     Context *ctx) {\n  float *dst_array = static_cast<float *>(dst->block()->mutable_data());\n  const int *src_array = static_cast<const int *>(src->block()->data());\n  for (int i = 0; i < dst->Size(); ++i) dst_array[i] = (float)src_array[i];\n}\n\ntemplate <>\nvoid Ceil<float, lang::Cpp>(const Tensor &in, Tensor *out, Context *ctx) {\n  traverse_unary<float>(in, out, [](float x) { return std::ceil(x); });\n}\n\ntemplate <>\nvoid Floor<float, lang::Cpp>(const Tensor &in, Tensor *out, Context *ctx) {\n  traverse_unary<float>(in, out, [](float x) { return std::floor(x); });\n}\n\ntemplate <>\nvoid Round<float, lang::Cpp>(const Tensor &in, Tensor *out, Context *ctx) {\n  traverse_unary<float>(in, out, [](float x) { return std::round(x); });\n}\n\ntemplate <>\nvoid RoundE<float, lang::Cpp>(const Tensor &in, Tensor *out, Context *ctx) {\n  traverse_unary<float>(in, out, [](float x) {\n    float doub = x * 2;\n    if (ceilf(doub) == doub) {\n      return std::round(x / 2) * 2;\n    } else {\n      return std::round(x);\n    }\n  });\n}\n\n#ifdef USE_DNNL\ntemplate <>\nvoid SoftMax<float, lang::Cpp>(const Tensor &in, Tensor *out, Context *ctx) {\n  auto md = dnnl::memory::desc({static_cast<long long>(in.shape()[0]),\n                                static_cast<long long>(in.shape()[1])},\n                               dnnl::memory::data_type::f32,\n                               dnnl::memory::format_tag::ab);\n  auto in_mem = dnnl::memory(md, ctx->dnnl_engine, in.block()->mutable_data());\n  auto out_mem =\n      dnnl::memory(md, ctx->dnnl_engine, out->block()->mutable_data());\n\n  auto softmax_desc =\n      dnnl::softmax_forward::desc(dnnl::prop_kind::forward_scoring, md, 1);\n  auto softmax_prim_desc =\n      dnnl::softmax_forward::primitive_desc(softmax_desc, ctx->dnnl_engine);\n  auto softmax = dnnl::softmax_forward(softmax_prim_desc);\n  softmax.execute(ctx->dnnl_stream,\n                  {{DNNL_ARG_SRC, in_mem}, {DNNL_ARG_DST, out_mem}});\n  ctx->dnnl_stream.wait();\n}\n\ntemplate <>\nvoid SoftMaxBackward<float, lang::Cpp>(const Tensor &in, Tensor *out,\n                                       const Tensor &fdout, Context *ctx) {\n  auto md = dnnl::memory::desc({static_cast<long long>(in.shape()[0]),\n                                static_cast<long long>(in.shape()[1])},\n                               dnnl::memory::data_type::f32,\n                               dnnl::memory::format_tag::ab);\n  auto in_mem = dnnl::memory(md, ctx->dnnl_engine, in.block()->mutable_data());\n  auto fdout_mem =\n      dnnl::memory(md, ctx->dnnl_engine, fdout.block()->mutable_data());\n  auto out_mem =\n      dnnl::memory(md, ctx->dnnl_engine, out->block()->mutable_data());\n\n  auto softmax_desc =\n      dnnl::softmax_forward::desc(dnnl::prop_kind::forward_scoring, md, 1);\n  auto softmax_prim_desc =\n      dnnl::softmax_forward::primitive_desc(softmax_desc, ctx->dnnl_engine);\n\n  auto softmaxbwd_desc = dnnl::softmax_backward::desc(md, md, 1);\n  auto softmaxbwd_prim_desc = dnnl::softmax_backward::primitive_desc(\n      softmaxbwd_desc, ctx->dnnl_engine, softmax_prim_desc);\n  auto softmaxbwd = dnnl::softmax_backward(softmaxbwd_prim_desc);\n  softmaxbwd.execute(ctx->dnnl_stream, {{DNNL_ARG_DIFF_SRC, out_mem},\n                                        {DNNL_ARG_DIFF_DST, in_mem},\n                                        {DNNL_ARG_DST, fdout_mem}});\n  ctx->dnnl_stream.wait();\n}\n#else\n// native Softmax without DNNL\ntemplate <>\nvoid SoftMax<float, lang::Cpp>(const Tensor &in, Tensor *out, Context *ctx) {\n  CHECK_LE(in.nDim(), 2u)\n      << \"Axis is required for SoftMax on multi dimemsional tensor\";\n  out->CopyData(in);\n  size_t nrow = 1, ncol = in.Size(), size = ncol;\n  if (in.nDim() == 2u) {\n    nrow = in.shape(0);\n    ncol = size / nrow;\n    out->Reshape(Shape{nrow, ncol});\n  }\n  Tensor tmp = RowMax(*out);\n  SubColumn(tmp, out);\n  Exp(*out, out);\n\n  SumColumns(*out, &tmp);\n  DivColumn(tmp, out);\n  out->Reshape(in.shape());\n}\n#endif  // USE_DNNL\n\ntemplate <>\nvoid Add<float, lang::Cpp>(const Tensor &in, const float x, Tensor *out,\n                           Context *ctx) {\n  auto add_lambda = [&x](float a) { return (a + x); };\n  traverse_unary<float>(in, out, add_lambda);\n}\n\ntemplate <>\nvoid Add<float, lang::Cpp>(const Tensor &in1, const Tensor &in2, Tensor *out,\n                           Context *ctx) {\n  // CHECK_EQ(ctx->stream, nullptr);\n  auto add_lambda_binary = [](float a, float b) { return (a + b); };\n  traverse_binary<float>(in1, in2, out, add_lambda_binary);\n}\n\ntemplate <>\nvoid Clamp<float, lang::Cpp>(const float low, const float high,\n                             const Tensor &in, Tensor *out, Context *ctx) {\n  auto clamp_lambda = [&low, &high](float a) {\n    if (a < low) {\n      return low;\n    } else if (a > high) {\n      return high;\n    } else {\n      return a;\n    }\n  };\n  traverse_unary<float>(in, out, clamp_lambda);\n}\n\ntemplate <>\nvoid Div<float, lang::Cpp>(const float x, const Tensor &in, Tensor *out,\n                           Context *ctx) {\n  auto const_div = [&x](float a) {\n    CHECK_NE(a, 0.f);\n    return x / a;\n  };\n  traverse_unary<float>(in, out, const_div);\n}\n\ntemplate <>\nvoid Div<float, lang::Cpp>(const Tensor &in1, const Tensor &in2, Tensor *out,\n                           Context *ctx) {\n  auto binary_div = [](float a, float b) {\n    CHECK_NE(b, 0.f);\n    return a / b;\n  };\n  traverse_binary<float>(in1, in2, out, binary_div);\n}\n\ntemplate <>\nvoid EltwiseMult<float, lang::Cpp>(const Tensor &in, const float x, Tensor *out,\n                                   Context *ctx) {\n  auto eltwisemult_lambda = [&x](float a) { return (a * x); };\n  traverse_unary<float>(in, out, eltwisemult_lambda);\n}\n\ntemplate <>\nvoid EltwiseMult<float, lang::Cpp>(const Tensor &in1, const Tensor &in2,\n                                   Tensor *out, Context *ctx) {\n  auto eltwisemult_lambda_binary = [](float a, float b) { return (a * b); };\n  traverse_binary<float>(in1, in2, out, eltwisemult_lambda_binary);\n}\n\ntemplate <>\nvoid ReLUBackward<float, lang::Cpp>(const Tensor &in1, const Tensor &in2,\n                                    Tensor *out, Context *ctx) {\n  auto relubackward_lambda = [](float a, float b) { return (b > 0) ? a : 0.f; };\n  traverse_binary<float>(in1, in2, out, relubackward_lambda);\n}\n\ntemplate <>\nvoid Exp<float, lang::Cpp>(const Tensor &in, Tensor *out, Context *ctx) {\n  traverse_unary<float>(in, out, [](float x) { return exp(x); });\n}\n\ntemplate <>\nvoid GE<float, lang::Cpp>(const Tensor &in, const float x, Tensor *out,\n                          Context *ctx) {\n  auto ge_lambda = [&x](float a) { return (a >= x) ? 1.f : 0.f; };\n  traverse_unary<float>(in, out, ge_lambda);\n}\n\ntemplate <>\nvoid GE<float, lang::Cpp>(const Tensor &in1, const Tensor &in2, Tensor *out,\n                          Context *ctx) {\n  auto ge_lambda_binary = [](float a, float b) { return (a >= b) ? 1.f : 0.f; };\n  traverse_binary<float>(in1, in2, out, ge_lambda_binary);\n}\n\ntemplate <>\nvoid GE<int, lang::Cpp>(const Tensor &in1, const Tensor &in2, Tensor *out,\n                        Context *ctx) {\n  auto ge_lambda_binary = [](int a, int b) { return (a >= b) ? 1.f : 0.f; };\n  traverse_binary<int>(in1, in2, out, ge_lambda_binary);\n}\n\ntemplate <>\nvoid GT<float, lang::Cpp>(const Tensor &in, const float x, Tensor *out,\n                          Context *ctx) {\n  auto gt_lambda = [&x](float a) { return (a > x) ? 1.f : 0.f; };\n  traverse_unary<float>(in, out, gt_lambda);\n}\n\ntemplate <>\nvoid GT<float, lang::Cpp>(const Tensor &in1, const Tensor &in2, Tensor *out,\n                          Context *ctx) {\n  auto gt_lambda_binary = [](float a, float b) { return (a > b) ? 1.f : 0.f; };\n  traverse_binary<float>(in1, in2, out, gt_lambda_binary);\n}\n\ntemplate <>\nvoid GT<int, lang::Cpp>(const Tensor &in1, const Tensor &in2, Tensor *out,\n                        Context *ctx) {\n  auto gt_lambda_binary = [](int a, int b) { return (a > b) ? 1.f : 0.f; };\n  traverse_binary<int>(in1, in2, out, gt_lambda_binary);\n}\n\ntemplate <>\nvoid LE<float, lang::Cpp>(const Tensor &in, const float x, Tensor *out,\n                          Context *ctx) {\n  auto le_lambda = [&x](float a) { return (a <= x) ? 1.f : 0.f; };\n  traverse_unary<float>(in, out, le_lambda);\n}\n\ntemplate <>\nvoid LE<float, lang::Cpp>(const Tensor &in1, const Tensor &in2, Tensor *out,\n                          Context *ctx) {\n  auto le_lambda_binary = [](float a, float b) { return (a <= b) ? 1.f : 0.f; };\n  traverse_binary<float>(in1, in2, out, le_lambda_binary);\n}\n\ntemplate <>\nvoid LE<int, lang::Cpp>(const Tensor &in1, const Tensor &in2, Tensor *out,\n                        Context *ctx) {\n  auto le_lambda_binary = [](int a, int b) { return (a <= b) ? 1.f : 0.f; };\n  traverse_binary<int>(in1, in2, out, le_lambda_binary);\n}\n\ntemplate <>\nvoid Log<float, lang::Cpp>(const Tensor &in, Tensor *out, Context *ctx) {\n  auto ulog = [](float a) {\n    CHECK_GT(a, 0.f);\n    return log(a);\n  };\n  traverse_unary<float>(in, out, ulog);\n}\n\ntemplate <>\nvoid LT<float, lang::Cpp>(const Tensor &in, const float x, Tensor *out,\n                          Context *ctx) {\n  auto lt_lambda = [&x](float a) { return (a < x) ? 1.f : 0.f; };\n  traverse_unary<float>(in, out, lt_lambda);\n}\n\ntemplate <>\nvoid LT<float, lang::Cpp>(const Tensor &in1, const Tensor &in2, Tensor *out,\n                          Context *ctx) {\n  auto lt_lambda_binary = [](float a, float b) { return (a < b) ? 1.f : 0.f; };\n  traverse_binary<float>(in1, in2, out, lt_lambda_binary);\n}\n\ntemplate <>\nvoid LT<int, lang::Cpp>(const Tensor &in1, const Tensor &in2, Tensor *out,\n                        Context *ctx) {\n  auto lt_lambda_binary = [](int a, int b) { return (a < b) ? 1.f : 0.f; };\n  traverse_binary<int>(in1, in2, out, lt_lambda_binary);\n}\n\ntemplate <>\nvoid EQ<float, lang::Cpp>(const Tensor &in, const float x, Tensor *out,\n                          Context *ctx) {\n  auto eq_lambda = [&x](float a) { return (a == x) ? 1.f : 0.f; };\n  traverse_unary<float>(in, out, eq_lambda);\n}\n\ntemplate <>\nvoid EQ<float, lang::Cpp>(const Tensor &in1, const Tensor &in2, Tensor *out,\n                          Context *ctx) {\n  auto eq_lambda_binary = [](float a, float b) { return (a == b) ? 1.f : 0.f; };\n  traverse_binary<float>(in1, in2, out, eq_lambda_binary);\n}\n\ntemplate <>\nvoid EQ<int, lang::Cpp>(const Tensor &in1, const Tensor &in2, Tensor *out,\n                        Context *ctx) {\n  auto eq_lambda_binary = [](int a, int b) { return (a == b) ? 1.f : 0.f; };\n  traverse_binary<int>(in1, in2, out, eq_lambda_binary);\n}\n\ntemplate <>\nvoid Pow<float, lang::Cpp>(const Tensor &in, const float x, Tensor *out,\n                           Context *ctx) {\n  traverse_unary<float>(in, out, [x](float y) { return pow(y, x); });\n}\n\ntemplate <>\nvoid Pow<float, lang::Cpp>(const Tensor &in1, const Tensor &in2, Tensor *out,\n                           Context *ctx) {\n  auto pow_lambda_binary = [](float a, float b) { return pow(a, b); };\n  traverse_binary<float>(in1, in2, out, pow_lambda_binary);\n}\n\ntemplate <>\nvoid ReLU<float, lang::Cpp>(const Tensor &in, Tensor *out, Context *ctx) {\n  auto relu_lambda = [](float a) { return (a >= 0.f) ? a : 0.f; };\n  traverse_unary<float>(in, out, relu_lambda);\n}\n\ntemplate <>\nvoid Set<float, lang::Cpp>(const float x, Tensor *out, Context *ctx) {\n  float *outPtr = static_cast<float *>(out->block()->mutable_data());\n  for (size_t i = 0; i < out->Size(); i++) outPtr[i] = x;\n}\n\ntemplate <>\nvoid Set<int, lang::Cpp>(const int x, Tensor *out, Context *ctx) {\n  int *outPtr = static_cast<int *>(out->block()->mutable_data());\n  for (size_t i = 0; i < out->Size(); i++) outPtr[i] = x;\n}\n\ntemplate <>\nvoid Set<half_float::half, lang::Cpp>(const half_float::half x, Tensor *out,\n                                      Context *ctx) {\n  half_float::half *outPtr =\n      static_cast<half_float::half *>(out->block()->mutable_data());\n  for (size_t i = 0; i < out->Size(); i++) outPtr[i] = x;\n}\n\ntemplate <>\nvoid Sigmoid<float, lang::Cpp>(const Tensor &in, Tensor *out, Context *ctx) {\n  auto sigmoid_lambda = [](float a) { return 1.f / (1.f + exp(-a)); };\n  traverse_unary<float>(in, out, sigmoid_lambda);\n}\n\ntemplate <>\nvoid Sign<float, lang::Cpp>(const Tensor &in, Tensor *out, Context *ctx) {\n  auto sign_lambda = [](float a) { return (a > 0) - (a < 0); };\n  traverse_unary<float>(in, out, sign_lambda);\n}\n\ntemplate <>\nvoid SoftPlus<float, lang::Cpp>(const Tensor &in, Tensor *out, Context *ctx) {\n  auto softplus_lambda = [](float a) { return log(1.f + exp(a)); };\n  traverse_unary<float>(in, out, softplus_lambda);\n}\n\ntemplate <>\nvoid SoftSign<float, lang::Cpp>(const Tensor &in, Tensor *out, Context *ctx) {\n  auto softsign_lambda = [](float a) { return a / (1.f + fabs(a)); };\n  traverse_unary<float>(in, out, softsign_lambda);\n}\n\ntemplate <>\nvoid Sqrt<float, lang::Cpp>(const Tensor &in, Tensor *out, Context *ctx) {\n  auto usqrt = [](float a) {\n    CHECK_GE(a, 0.f);\n    return sqrt(a);\n  };\n  traverse_unary<float>(in, out, usqrt);\n}\n\ntemplate <>\nvoid Sub<float, lang::Cpp>(const Tensor &in1, const Tensor &in2, Tensor *out,\n                           Context *ctx) {\n  // CHECK_EQ(ctx->stream, nullptr);\n  auto sub_lambda_binary = [](float a, float b) { return (a - b); };\n  traverse_binary<float>(in1, in2, out, sub_lambda_binary);\n}\n\n// sum all elements of input into out\n// TODO(wangwei) optimize using omp\ntemplate <>\nvoid Sum<float, lang::Cpp>(const Tensor &in, float *out, Context *ctx) {\n  float s = 0.f;\n  const float *inPtr = static_cast<const float *>(in.block()->data());\n  for (size_t i = 0; i < in.Size(); i++) {\n    s += inPtr[i];\n  }\n  *out = s;\n}\n\n#define GenUnaryTensorCppFn(fn, cppfn)                                     \\\n  template <>                                                              \\\n  void fn<float, lang::Cpp>(const Tensor &in, Tensor *out, Context *ctx) { \\\n    auto fn_lambda = [](float a) { return cppfn(a); };                     \\\n    traverse_unary<float>(in, out, fn_lambda);                             \\\n  }\n\nGenUnaryTensorCppFn(Cos, cos);\nGenUnaryTensorCppFn(Cosh, cosh);\nGenUnaryTensorCppFn(Acos, acos);\nGenUnaryTensorCppFn(Acosh, acosh);\nGenUnaryTensorCppFn(Sin, sin);\nGenUnaryTensorCppFn(Sinh, sinh);\nGenUnaryTensorCppFn(Asin, asin);\nGenUnaryTensorCppFn(Asinh, asinh);\nGenUnaryTensorCppFn(Tan, tan);\nGenUnaryTensorCppFn(Tanh, tanh);\nGenUnaryTensorCppFn(Atan, atan);\nGenUnaryTensorCppFn(Atanh, atanh);\n\ntemplate <>\nvoid Transform<float, lang::Cpp>(const Tensor &in, Tensor *out, Context *ctx) {\n  auto identity = [](float a) { return a; };\n  traverse_unary<float>(in, out, identity);\n}\n\ntemplate <>\nvoid Transform<int, lang::Cpp>(const Tensor &in, Tensor *out, Context *ctx) {\n  auto identity = [](int a) { return a; };\n  traverse_unary<int>(in, out, identity);\n}\n\ntemplate <>\nvoid Transform<half_float::half, lang::Cpp>(const Tensor &in, Tensor *out,\n                                            Context *ctx) {\n  auto identity = [](half_float::half a) { return a; };\n  traverse_unary<half_float::half>(in, out, identity);\n}\n\ntemplate <>\nvoid Bernoulli<float, lang::Cpp>(const float p, Tensor *out, Context *ctx) {\n  std::bernoulli_distribution distribution(p);\n  float *outPtr = static_cast<float *>(out->block()->mutable_data());\n  for (size_t i = 0; i < out->Size(); i++) {\n    outPtr[i] = distribution(ctx->random_generator) ? 1.0f : 0.0f;\n  }\n}\n\ntemplate <>\nvoid Gaussian<float, lang::Cpp>(const float mean, const float std, Tensor *out,\n                                Context *ctx) {\n  std::normal_distribution<float> distribution(mean, std);\n  float *outPtr = static_cast<float *>(out->block()->mutable_data());\n  for (size_t i = 0; i < out->Size(); i++) {\n    outPtr[i] = static_cast<float>(distribution(ctx->random_generator));\n  }\n}\n\ntemplate <>\nvoid Gaussian<half_float::half, lang::Cpp>(const half_float::half mean,\n                                           const half_float::half std,\n                                           Tensor *out, Context *ctx) {\n  Tensor tmp(out->shape(), out->device(), kFloat32);\n  Gaussian<float, lang::Cpp>(static_cast<float>(mean), static_cast<float>(std),\n                             &tmp, ctx);\n  CastCopy<float, half_float::half, lang::Cpp>(&tmp, out, ctx);\n}\n\ntemplate <>\nvoid Uniform<float, lang::Cpp>(const float low, const float high, Tensor *out,\n                               Context *ctx) {\n  std::uniform_real_distribution<float> distribution(low, high);\n  float *outPtr = static_cast<float *>(out->block()->mutable_data());\n  for (size_t i = 0; i < out->Size(); i++) {\n    outPtr[i] = static_cast<float>(distribution(ctx->random_generator));\n  }\n}\n\n// ====================Blas operations======================================\n\n// warning, this function has block M overwritting to block M itself\ntemplate <>\nvoid DGMM<float, lang::Cpp>(const bool side_right, const Tensor &M,\n                            const Tensor &v, Tensor *out, Context *ctx) {\n  const float *MPtr = static_cast<const float *>(M.block()->data());\n  const float *vPtr = static_cast<const float *>(v.block()->data());\n  float *outPtr = static_cast<float *>(out->block()->mutable_data());\n  const size_t nrow = M.shape(0);\n  const size_t ncol = M.shape(1);\n\n  if (side_right) {\n    for (size_t r = 0; r < nrow; r++) {\n      size_t in_offset = M.stride()[0] * r, out_offset = out->stride()[0] * r;\n      for (size_t c = 0; c < ncol; c++) {\n        outPtr[out_offset] = MPtr[in_offset] * vPtr[c];\n        in_offset += M.stride()[1];\n        out_offset += out->stride()[1];\n      }\n    }\n  } else {\n    for (size_t r = 0; r < nrow; r++) {\n      size_t in_offset = M.stride()[0] * r, out_offset = out->stride()[0] * r;\n      for (size_t c = 0; c < ncol; c++) {\n        outPtr[out_offset] = MPtr[in_offset] * vPtr[r];\n        in_offset += M.stride()[1];\n        out_offset += out->stride()[1];\n      }\n    }\n  }\n}\n\n#ifdef USE_CBLAS\ntemplate <>\nvoid Amax<float, lang::Cpp>(const Tensor &in, size_t *out, Context *ctx) {\n  const float *inPtr = static_cast<const float *>(in.block()->data());\n  *out = cblas_isamax(in.Size(), inPtr, 1);  // not using strided traversal\n}\n\ntemplate <>\nvoid Asum<float, lang::Cpp>(const Tensor &in, float *out, Context *ctx) {\n  const float *inPtr = static_cast<const float *>(in.block()->data());\n  *out = cblas_sasum(in.Size(), inPtr, 1);  // not using strided traversal\n}\n\n// template <>\n// void Axpy<float, lang::Cpp>(const float alpha,\n//                             const Tensor& in, Tensor *out, Context *ctx) {\n//   //check input tensor for strides first\n//   if (in.stride() == out->stride()) {\n//     const float *inPtr = static_cast<const float *>(in.block()->data());\n//     float *outPtr = static_cast<float *>(out->block()->mutable_data());\n//     cblas_saxpy(in.Size(), alpha, inPtr, 1, outPtr, 1);\n//   } else {\n//     //LOG(FATAL) << \"Axpy, input and output strides do not match.\" ;\n//     EltwiseMult<float, lang::Cpp>(in, alpha, out, ctx);\n//   }\n// }\n\ntemplate <>\nvoid Axpy<float, lang::Cpp>(const float alpha, const Tensor &in, Tensor *out,\n                            Context *ctx) {\n  // check input tensor for strides first\n  const float *inPtr = static_cast<const float *>(in.block()->data());\n  float *outPtr = static_cast<float *>(out->block()->mutable_data());\n\n  if (in.stride() == out->stride()) {\n    cblas_saxpy(in.Size(), alpha, inPtr, 1, outPtr, 1);\n  } else {\n    // LOG(FATAL) << \"Axpy, input and output strides do not match.\" ;\n    Tensor t(in.shape(), in.device(), in.data_type());\n    EltwiseMult<float, lang::Cpp>(in, alpha, &t, ctx);\n    float *tPtr = static_cast<float *>(t.block()->mutable_data());\n    cblas_saxpy(in.Size(), 1, tPtr, 1, outPtr, 1);\n  }\n}\n\n// template <>\n// void Axpy<float, lang::Cpp>(const float alpha,\n//                            const Tensor& in, Tensor *out, Context *ctx) {\n//  //check input tensor for strides first\n//  if (in.stride() == out->stride()) {\n//    const float *inPtr = static_cast<const float *>(in.block()->data());\n//    float *outPtr = static_cast<float *>(out->block()->mutable_data());\n//    cblas_saxpy(in.Size(), alpha, inPtr, 1, outPtr, 1);\n//  } else if(out->transpose()) {\n//    LOG(FATAL) << \"output is already transposed.\" ;\n//  } else {\n//    LOG(FATAL) << \"Axpy, input and output strides do not match.\" ;\n//  }\n// }\n\ntemplate <>\nvoid Dot<float, lang::Cpp>(const Tensor &in1, const Tensor &in2, float *out,\n                           Context *ctx) {\n  // check input tensor for strides first\n  if (!(in1.transpose()) && !(in2.transpose())) {\n    const float *in1Ptr = static_cast<const float *>(in1.block()->data());\n    const float *in2Ptr = static_cast<const float *>(in2.block()->data());\n    *out = cblas_sdot(in1.Size(), in1Ptr, 1, in2Ptr, 1);\n  } else {\n    LOG(FATAL) << \"Dot, one of the input is tranposed. Not implemented yet.\";\n  }\n}\ntemplate <>\nvoid Dot<float, lang::Cpp>(const Tensor &in1, const Tensor &in2, Tensor *out,\n                           Context *ctx) {\n  // check input tensor for strides first\n  if (!(in1.transpose()) && !(in2.transpose())) {\n    const float *in1Ptr = static_cast<const float *>(in1.block()->data());\n    const float *in2Ptr = static_cast<const float *>(in2.block()->data());\n    float *outPtr = static_cast<float *>(out->block()->mutable_data());\n    *outPtr = cblas_sdot(in1.Size(), in1Ptr, 1, in2Ptr, 1);\n  } else {\n    LOG(FATAL) << \"Dot, one of the input is tranposed. Not implemented yet.\";\n  }\n}\n\ntemplate <>\nvoid Scale<float, lang::Cpp>(const float x, Tensor *out, Context *ctx) {\n  float *outPtr = static_cast<float *>(out->block()->mutable_data());\n  cblas_sscal(out->Size(), x, outPtr, 1);  // not using strided traversal\n}\n\ntemplate <>\nvoid Nrm2<float, lang::Cpp>(const Tensor &in, float *out, Context *ctx) {\n  const float *inPtr = static_cast<const float *>(in.block()->data());\n  *out = cblas_snrm2(in.Size(), inPtr, 1);  // not using strided traversal\n}\n\ntemplate <>\nvoid GEMV<float, lang::Cpp>(const float alpha, const Tensor &A, const Tensor &v,\n                            const float beta, Tensor *out, Context *ctx) {\n  const float *APtr = static_cast<const float *>(A.block()->data());\n  const float *vPtr = static_cast<const float *>(v.block()->data());\n  float *outPtr = static_cast<float *>(out->block()->mutable_data());\n  const size_t m = A.shape()[0];\n  const size_t n = A.shape()[1];\n  if (A.transpose()) {\n    cblas_sgemv(CblasRowMajor, CblasTrans, n, m, alpha, APtr, m, vPtr, 1, beta,\n                outPtr, 1);\n  } else {\n    cblas_sgemv(CblasRowMajor, CblasNoTrans, m, n, alpha, APtr, n, vPtr, 1,\n                beta, outPtr, 1);\n  }\n}\n\ntemplate <>\nvoid GEMM<float, lang::Cpp>(const float alpha, const Tensor &A, const Tensor &B,\n                            const float beta, Tensor *C, Context *ctx) {\n  auto transA = A.transpose();\n  auto transa = transA ? CblasTrans : CblasNoTrans;\n  auto transB = B.transpose();\n  auto transb = transB ? CblasTrans : CblasNoTrans;\n  const size_t nrowA = A.shape()[0];\n  const size_t ncolA = A.shape()[1];\n  const size_t ncolB = B.shape()[1];\n  auto lda = transA ? nrowA : ncolA;\n  auto ldb = transB ? ncolA : ncolB;\n  auto ldc = ncolB;\n  const float *APtr = static_cast<const float *>(A.block()->data());\n  const float *BPtr = static_cast<const float *>(B.block()->data());\n  float *CPtr = static_cast<float *>(C->block()->mutable_data());\n  cblas_sgemm(CblasRowMajor, transa, transb, nrowA, ncolB, ncolA, alpha, APtr,\n              lda, BPtr, ldb, beta, CPtr, ldc);\n}\n\n/*\n * implement matmul for 3d 4d tensor\n *   simulate cblas_sgemm_batch();\n *   which is only available in intel cblas\n */\ntemplate <>\nvoid GEMMBatched<float, lang::Cpp>(const float alpha, const Tensor &A,\n                                   const Tensor &B, const float beta, Tensor *C,\n                                   Context *ctx) {\n  const float *APtr = static_cast<const float *>(A.block()->data());\n  const float *BPtr = static_cast<const float *>(B.block()->data());\n  float *CPtr = static_cast<float *>(C->block()->mutable_data());\n\n  auto transA = A.transpose();\n  auto transa = transA ? CblasTrans : CblasNoTrans;\n  auto transB = B.transpose();\n  auto transb = transB ? CblasTrans : CblasNoTrans;\n\n  const size_t ncolB = B.shape().end()[-1];\n  const size_t nrowA = A.shape().end()[-2];\n  const size_t ncolA = A.shape().end()[-1];\n\n  auto lda = transA ? nrowA : ncolA;\n  auto ldb = transB ? ncolA : ncolB;\n  auto ldc = ncolB;\n  const int group_count = 1;\n\n  size_t group_size = A.shape()[0];                // 3d\n  if (A.nDim() == 4u) group_size *= A.shape()[1];  // 4d\n\n  auto matrix_stride_A = A.shape().end()[-1] * A.shape().end()[-2];\n  auto matrix_stride_B = B.shape().end()[-1] * B.shape().end()[-2];\n  auto matrix_stride_C = C->shape().end()[-1] * C->shape().end()[-2];\n  auto offset_A = 0;\n  auto offset_B = 0;\n  auto offset_C = 0;\n\n  for (int i = 0; i < group_size; i++) {\n    cblas_sgemm(CblasRowMajor, transa, transb, nrowA, ncolB, ncolA, alpha,\n                APtr + offset_A, lda, BPtr + offset_B, ldb, beta,\n                CPtr + offset_C, ldc);\n    offset_A += matrix_stride_A;\n    offset_B += matrix_stride_B;\n    offset_C += matrix_stride_C;\n  }\n}\n\n#else\n\ntemplate <>\nvoid Amax<float, lang::Cpp>(const Tensor &in, size_t *out, Context *ctx) {\n  size_t maxPos = 0;\n  float maxVal = 0;\n  const float *inPtr = static_cast<const float *>(in.block()->data());\n  for (size_t i = 0; i < in.Size(); i++) {  // not using strided traversal\n    if (i == 0) {\n      maxVal = inPtr[i];\n    } else if (inPtr[i] > maxVal) {\n      maxVal = inPtr[i];\n      maxPos = i;\n    }\n  }\n  *out = maxPos;\n}\n\ntemplate <>\nvoid Amin<float, lang::Cpp>(const Tensor &in, size_t *out, Context *ctx) {\n  size_t minPos = 0;\n  float minVal = 0;\n  const float *inPtr = static_cast<const float *>(in.block()->data());\n  for (size_t i = 0; i < in.Size(); i++) {  // not using strided traversal\n    if (i == 0) {\n      minVal = inPtr[i];\n    } else if (inPtr[i] > minVal) {\n      minVal = inPtr[i];\n      minPos = i;\n    }\n  }\n  *out = minPos;\n}\n\ntemplate <>\nvoid Asum<float, lang::Cpp>(const Tensor &in, float *out, Context *ctx) {\n  float sum = 0;\n  const float *inPtr = static_cast<const float *>(in.block()->data());\n  for (size_t i = 0; i < in.Size(); i++) {\n    sum += fabs(inPtr[i]);  // not using strided traversal\n  }\n}\n\ntemplate <>\nvoid Axpy<float, lang::Cpp>(const float alpha, const Tensor &in, Tensor *out,\n                            Context *ctx) {\n  float *outPtr = static_cast<float *>(out->block()->mutable_data());\n  const float *inPtr = static_cast<const float *>(in.block()->data());\n  vector<int> traversal_info = generate_traversal_info(in);\n  vector<int> shape_multipliers = generate_shape_multipliers(in);\n\n  for (size_t i = 0; i < in.Size(); i++) {\n    outPtr[i] += alpha * inPtr[traversal_info[in.shape().size()]];\n    traverse_next(in, shape_multipliers, traversal_info, i + 1);\n  }\n}\n\ntemplate <>\nvoid Scale<float, lang::Cpp>(const float x, Tensor *out, Context *ctx) {\n  float *outPtr = static_cast<float *>(out->block()->mutable_data());\n  for (size_t i = 0; i < out->Size(); i++) {\n    outPtr[i] *= x;  // not using strided traversal\n  }\n}\n\ntemplate <>\nvoid Dot<float, lang::Cpp>(const Tensor &in1, const Tensor &in2, float *out,\n                           Context *ctx) {\n  float sum = 0;\n  // const float *in1Ptr = static_cast<const float *>(in1.data());\n  // const float *in2Ptr = static_cast<const float *>(in2.data());\n  // for (size_t i = 0; i < in.Size(); i++) {\n  //   sum += in1Ptr[i] * in2Ptr[i];\n  // }\n  float *outPtr = static_cast<float *>(out->block()->mutable_data());\n  const float *in1Ptr = static_cast<const float *>(in1.block()->data());\n  const float *in2Ptr = static_cast<const float *>(in2.block()->data());\n  vector<int> traversal_info_in1 = generate_traversal_info(in1);\n  vector<int> traversal_info_in2 = generate_traversal_info(in2);\n  vector<int> shape_multipliers_in1 = generate_shape_multipliers(in1);\n  vector<int> shape_multipliers_in2 = generate_shape_multipliers(in2);\n\n  for (size_t i = 0; i < in1.Size(); i++) {\n    sum += in1Ptr[traversal_info_in1[in1.shape().size()]] *\n           in2Ptr[traversal_info_in2[in2.shape().size()]];\n    traverse_next(in1, shape_multipliers_in1, traversal_info_in1, i + 1);\n    traverse_next(in2, shape_multipliers_in2, traversal_info_in2, i + 1);\n  }\n}\n\ntemplate <>\nvoid GEMV<float, lang::Cpp>(const float alpha, const Tensor &A, const Tensor &v,\n                            const float beta, Tensor *out, Context *ctx) {\n  float *outPtr = static_cast<float *>(out->block()->mutable_data());\n  const float *APtr = static_cast<const float *>(A.block()->data());\n  const float *vPtr = static_cast<const float *>(v.block()->data());\n  bool trans = A.transpose();\n  const size_t m = A.shape(0);\n  const size_t n = A.shape(1);\n  for (size_t r = 0; r < m; r++) {\n    float sum = 0;\n    for (size_t c = 0; c < n; c++) {\n      size_t idx = trans ? c * m + r : r * n + c;\n      sum += APtr[idx] * vPtr[c];\n    }\n    outPtr[r] = alpha * sum + beta * outPtr[r];\n  }\n}\n\n#endif  // USE_CBLAS\ntemplate <>\nvoid ComputeCrossEntropy<float, lang::Cpp>(bool int_target,\n                                           const size_t batchsize,\n                                           const size_t dim, const Tensor &p,\n                                           const Tensor &t, Tensor *loss,\n                                           Context *ctx) {\n  const float *pPtr = static_cast<const float *>(p.block()->data());\n  const int *tPtr = static_cast<const int *>(t.block()->data());\n  float *lossPtr = static_cast<float *>(loss->block()->mutable_data());\n  if (int_target) {\n    for (size_t i = 0; i < batchsize; i++) {\n      int truth_idx = tPtr[i];\n      CHECK_GE(truth_idx, 0);\n      float prob_of_truth = pPtr[i * dim + truth_idx];\n      lossPtr[i] = -std::log((std::max)(prob_of_truth, FLT_MIN));\n    }\n  } else {\n    for (size_t i = 0; i < batchsize; i++) {\n      float sum = 0.f;\n      for (size_t j = 0; j < dim; j++) {\n        sum += tPtr[i * dim + j];\n      }\n      float loss_value = 0.f;\n      for (size_t j = 0, offset = i * dim; j < dim; j++, offset++) {\n        loss_value -=\n            tPtr[offset] / sum * std::log((std::max)(pPtr[offset], FLT_MIN));\n      }\n      lossPtr[i] = loss_value;\n    }\n  }\n}\n\ntemplate <>\nvoid SoftmaxCrossEntropyBwd<float, lang::Cpp>(bool int_target,\n                                              const size_t batchsize,\n                                              const size_t dim, const Tensor &p,\n                                              const Tensor &t, Tensor *grad,\n                                              Context *ctx) {\n  CHECK_EQ(p.block(), grad->block())\n      << \"Use the same pointer to optimize performance\";\n  // const float* pPtr = static_cast<const float*>(p->data());\n  const int *tPtr = static_cast<const int *>(t.block()->data());\n  float *gradPtr = static_cast<float *>(grad->block()->mutable_data());\n\n  if (int_target) {\n    for (size_t i = 0; i < batchsize; i++) {\n      int truth_idx = static_cast<int>(tPtr[i]);\n      CHECK_GE(truth_idx, 0);\n      gradPtr[i * dim + truth_idx] -= 1.0;\n    }\n  } else {\n    for (size_t i = 0; i < batchsize; i++) {\n      float sum = 0.f;\n      for (size_t j = 0; j < dim; j++) {\n        sum += tPtr[i * dim + j];\n      }\n      for (size_t j = 0, offset = i * dim; j < dim; j++, offset++) {\n        gradPtr[offset] -= tPtr[offset] / sum;\n      }\n    }\n  }\n}\n\ntemplate <>\nvoid RowMax<float, lang::Cpp>(const Tensor &in, Tensor *out, Context *ctx) {\n  const float *inPtr = static_cast<const float *>(in.block()->data());\n  float *outPtr = static_cast<float *>(out->block()->mutable_data());\n  const size_t nrow = in.shape()[0];\n  const size_t ncol = in.shape()[1];\n  vector<int> traversal_info = generate_traversal_info(in);\n  vector<int> shape_multipliers = generate_shape_multipliers(in);\n\n  for (size_t r = 0; r < nrow; r++) {\n    int counter_offset = (r * ncol);\n    float maxval = 0;\n    for (size_t c = 0; c < ncol; c++) {\n      maxval = (std::max)(maxval, inPtr[traversal_info[in.shape().size()]]);\n      traverse_next(in, shape_multipliers, traversal_info,\n                    counter_offset + c + 1);\n    }\n    outPtr[r] = maxval;\n  }\n}\n\n// =========Matrix operations ================================================\n/*\ntemplate <>\nvoid SoftMax<float, lang::Cpp>(const Tensor &in, Tensor *out, Context* ctx) {\n  CHECK_LE(in.nDim(), 2u) << \"Axis is required for SoftMax on multi dimemsional\ntensor\";\n  out->CopyData(in);\n  size_t nrow = 1, ncol = in.Size(), size = ncol;\n  if (in.nDim() == 2u) {\n    nrow = in.shape(0);\n    ncol = size / nrow;\n    out->Reshape(Shape{nrow, ncol});\n  }\n  Tensor tmp = RowMax(*out);\n  SubColumn(tmp, out);\n  Exp(*out, out);\n\n  SumColumns(*out, &tmp);\n  DivColumn(tmp, out);\n  out->Reshape(in.shape());\n}\n\ntemplate <>\nvoid AddCol<float, lang::Cpp>(const size_t nrow, const size_t ncol,\n                              const Tensor& A, const Tensor& v, Tensor* out,\n                              Context *ctx) {\n  float *outPtr = static_cast<float *>(out->mutable_data());\n  const float *APtr = static_cast<const float *>(A.data());\n  const float *vPtr = static_cast<const float *>(v.data());\n  for (size_t r = 0; r < nrow; r++) {\n    size_t offset = r * ncol;\n    for (size_t c = 0; c < ncol; c++) {\n      outPtr[offset + c] = APtr[offset + c] + vPtr[r];\n    }\n  }\n}\n\ntemplate <>\nvoid AddRow<float, lang::Cpp>(const size_t nrow, const size_t ncol,\n                              const Tensor& A, const Tensor& v, Tensor* out,\n                              Context *ctx) {\n  float *outPtr = static_cast<float *>(out->mutable_data());\n  const float *APtr = static_cast<const float *>(A.data());\n  const float *vPtr = static_cast<const float *>(v.data());\n  for (size_t r = 0; r < nrow; r++) {\n    size_t offset = r * ncol;\n    for (size_t c = 0; c < ncol; c++) {\n      outPtr[offset + c] = APtr[offset + c] + vPtr[c];\n    }\n  }\n}\ntemplate <>\nvoid Outer<float, lang::Cpp>(const size_t m, const size_t n, const Tensor& in1,\n                             const Tensor& in2, Tensor* out, Context *ctx) {\n  float *outPtr = static_cast<float *>(out->mutable_data());\n  const float *in1Ptr = static_cast<const float *>(in1.data());\n  const float *in2Ptr = static_cast<const float *>(in2.data());\n  for (size_t r = 0; r < m; r++) {\n    size_t offset = r * n;\n    for (size_t c = 0; c < n; c++) {\n      outPtr[offset + c] = in1Ptr[r] * in2Ptr[c];\n    }\n  }\n}\ntemplate <>\nvoid Softmax<float, lang::Cpp>(const size_t nrow, const size_t ncol,\n                               const Tensor& in, Tensor* out, Context *ctx) {\n  float *outPtr = static_cast<float *>(out->mutable_data());\n  const float *inPtr = static_cast<const float *>(in.data());\n  float *bPtr = new float[ncol];\n  for (size_t r = 0; r < nrow; r++) {\n    size_t offset = r * ncol;\n    float denom = 0.f;\n    for (size_t c = 0; c < ncol; c++) {\n      bPtr[c] = exp(inPtr[offset + c]);\n      denom += bPtr[c];\n    }\n    for (size_t c = 0; c < ncol; c++) {\n      size_t idx = offset + c;\n      outPtr[idx] = bPtr[c] / denom;\n    }\n  }\n  delete bPtr;\n}\n\ntemplate <>\nvoid SumColumns<float, lang::Cpp>(const size_t nrow, const size_t ncol,\n                                  const Tensor& in, Tensor* out, Context *ctx) {\n  float *outPtr = static_cast<float *>(out->mutable_data());\n  const float *inPtr = static_cast<const float *>(in.data());\n  for (size_t c = 0; c < ncol; c++) {\n    outPtr[c] = 0.f;\n  }\n  for (size_t r = 0; r < nrow; r++) {\n    size_t offset = r * ncol;\n    for (size_t c = 0; c < ncol; c++) {\n      outPtr[c] += inPtr[offset + c];\n    }\n  }\n}\n\ntemplate <>\nvoid SumRows<float, lang::Cpp>(const size_t nrow, const size_t ncol,\n                               const Tensor& in, Tensor* out, Context *ctx) {\n  float *outPtr = static_cast<float *>(out->mutable_data());\n  const float *inPtr = static_cast<const float *>(in.data());\n  for (size_t r = 0; r < nrow; r++) {\n    size_t offset = r * ncol;\n    outPtr[r] = 0.f;\n    for (size_t c = 0; c < ncol; c++) {\n      outPtr[r] += inPtr[offset + c];\n    }\n  }\n}\n*/\n}  // namespace singa\n\n#endif  // SINGA_CORE_TENSOR_TENSOR_MATH_CPP_H_\n", "meta": {"hexsha": "2c06f632416580a3c0f3264a2a4192ae048d1526", "size": 47051, "ext": "h", "lang": "C", "max_stars_repo_path": "src/core/tensor/tensor_math_cpp.h", "max_stars_repo_name": "fukien/incubator-singa", "max_stars_repo_head_hexsha": "a1622a9a036d68c39f8999123d60b68b17c58672", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-05-25T08:50:51.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-25T08:50:51.000Z", "max_issues_repo_path": "src/core/tensor/tensor_math_cpp.h", "max_issues_repo_name": "fukien/incubator-singa", "max_issues_repo_head_hexsha": "a1622a9a036d68c39f8999123d60b68b17c58672", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/core/tensor/tensor_math_cpp.h", "max_forks_repo_name": "fukien/incubator-singa", "max_forks_repo_head_hexsha": "a1622a9a036d68c39f8999123d60b68b17c58672", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.0772261623, "max_line_length": 93, "alphanum_fraction": 0.5951626958, "num_tokens": 13271, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.29746993014852224, "lm_q2_score": 0.04958901824356765, "lm_q1q2_score": 0.014751241793047863}}
{"text": "/***************************************************************************\r\n * data_cf.h is part of Math Graphic Library\r\n * Copyright (C) 2007-2016 Alexey Balakin <mathgl.abalakin@gmail.ru>       *\r\n *                                                                         *\r\n *   This program is free software; you can redistribute it and/or modify  *\r\n *   it under the terms of the GNU Library General Public License as       *\r\n *   published by the Free Software Foundation; either version 3 of the    *\r\n *   License, or (at your option) any later version.                       *\r\n *                                                                         *\r\n *   This program is distributed in the hope that it will be useful,       *\r\n *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *\r\n *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *\r\n *   GNU General Public License for more details.                          *\r\n *                                                                         *\r\n *   You should have received a copy of the GNU Library General Public     *\r\n *   License along with this program; if not, write to the                 *\r\n *   Free Software Foundation, Inc.,                                       *\r\n *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *\r\n ***************************************************************************/\r\n#ifndef _MGL_DATA_CF_H_\r\n#define _MGL_DATA_CF_H_\r\n//-----------------------------------------------------------------------------\r\n#include \"mgl2/abstract.h\"\r\n//-----------------------------------------------------------------------------\r\n#if MGL_HAVE_GSL\r\n#include <gsl/gsl_vector.h>\r\n#include <gsl/gsl_matrix.h>\r\n#else\r\n#ifdef __cplusplus\r\nstruct gsl_vector;\r\nstruct gsl_matrix;\r\n#else\r\ntypedef void gsl_vector;\r\ntypedef void gsl_matrix;\r\n#endif\r\n#endif\r\n//-----------------------------------------------------------------------------\r\n#ifdef __cplusplus\r\nextern \"C\" {\r\n#endif\r\n/// Get integer power of x\r\ndouble MGL_EXPORT_CONST mgl_ipow(double x,int n);\r\ndouble MGL_EXPORT_PURE mgl_ipow_(mreal *x,int *n);\r\n/// Get number of seconds since 1970 for given string\r\ndouble MGL_EXPORT mgl_get_time(const char *time, const char *fmt);\r\ndouble MGL_EXPORT mgl_get_time_(const char *time, const char *fmt,int,int);\r\n\r\n/// Create HMDT object\r\nHMDT MGL_EXPORT mgl_create_data();\r\nuintptr_t MGL_EXPORT mgl_create_data_();\r\n/// Create HMDT object with specified sizes\r\nHMDT MGL_EXPORT mgl_create_data_size(long nx, long ny, long nz);\r\nuintptr_t MGL_EXPORT mgl_create_data_size_(int *nx, int *ny, int *nz);\r\n/// Create HMDT object with data from file\r\nHMDT MGL_EXPORT mgl_create_data_file(const char *fname);\r\nuintptr_t MGL_EXPORT mgl_create_data_file_(const char *fname, int len);\r\n/// Delete HMDT object\r\nvoid MGL_EXPORT mgl_delete_data(HMDT dat);\r\nvoid MGL_EXPORT mgl_delete_data_(uintptr_t *dat);\r\n\r\n/// Rearange data dimensions\r\nvoid MGL_EXPORT mgl_data_rearrange(HMDT dat, long mx,long my,long mz);\r\nvoid MGL_EXPORT mgl_data_rearrange_(uintptr_t *dat, int *mx, int *my, int *mz);\r\n/// Link external data array (don't delete it at exit)\r\nvoid MGL_EXPORT mgl_data_link(HMDT dat, mreal *A,long mx,long my,long mz);\r\nvoid MGL_EXPORT mgl_data_link_(uintptr_t *d, mreal *A, int *nx,int *ny,int *nz);\r\n/// Allocate memory and copy the data from the (float *) array\r\nvoid MGL_EXPORT mgl_data_set_float(HMDT dat, const float *A,long mx,long my,long mz);\r\nvoid MGL_EXPORT mgl_data_set_float_(uintptr_t *dat, const float *A,int *NX,int *NY,int *NZ);\r\nvoid MGL_EXPORT mgl_data_set_float1_(uintptr_t *d, const float *A,int *N1);\r\n/// Allocate memory and copy the data from the (double *) array\r\nvoid MGL_EXPORT mgl_data_set_double(HMDT dat, const double *A,long mx,long my,long mz);\r\nvoid MGL_EXPORT mgl_data_set_double_(uintptr_t *dat, const double *A,int *NX,int *NY,int *NZ);\r\nvoid MGL_EXPORT mgl_data_set_double1_(uintptr_t *d, const double *A,int *N1);\r\n/// Allocate memory and copy the data from the (float **) array\r\nvoid MGL_EXPORT mgl_data_set_float2(HMDT d, float const * const *A,long N1,long N2);\r\nvoid MGL_EXPORT mgl_data_set_float2_(uintptr_t *d, const float *A,int *N1,int *N2);\r\n/// Allocate memory and copy the data from the (double **) array\r\nvoid MGL_EXPORT mgl_data_set_double2(HMDT d, double const * const *A,long N1,long N2);\r\nvoid MGL_EXPORT mgl_data_set_double2_(uintptr_t *d, const double *A,int *N1,int *N2);\r\n/// Allocate memory and copy the data from the (float ***) array\r\nvoid MGL_EXPORT mgl_data_set_float3(HMDT d, float const * const * const *A,long N1,long N2,long N3);\r\nvoid MGL_EXPORT mgl_data_set_float3_(uintptr_t *d, const float *A,int *N1,int *N2,int *N3);\r\n/// Allocate memory and copy the data from the (double ***) array\r\nvoid MGL_EXPORT mgl_data_set_double3(HMDT d, double const * const * const *A,long N1,long N2,long N3);\r\nvoid MGL_EXPORT mgl_data_set_double3_(uintptr_t *d, const double *A,int *N1,int *N2,int *N3);\r\n/// Import data from abstract type\r\nvoid MGL_EXPORT mgl_data_set(HMDT dat, HCDT a);\r\nvoid MGL_EXPORT mgl_data_set_(uintptr_t *dat, uintptr_t *a);\r\n/// Allocate memory and copy the data from the gsl_vector\r\nvoid MGL_EXPORT mgl_data_set_vector(HMDT dat, gsl_vector *v);\r\n/// Allocate memory and copy the data from the gsl_matrix\r\nvoid MGL_EXPORT mgl_data_set_matrix(HMDT dat, gsl_matrix *m);\r\n/// Set value of data element [i,j,k]\r\nvoid MGL_EXPORT mgl_data_set_value(HMDT dat, mreal v, long i, long j, long k);\r\nvoid MGL_EXPORT mgl_data_set_value_(uintptr_t *d, mreal *v, int *i, int *j, int *k);\r\n/// Get value of data element [i,j,k]\r\nmreal MGL_EXPORT mgl_data_get_value(HCDT dat, long i, long j, long k);\r\nmreal MGL_EXPORT mgl_data_get_value_(uintptr_t *d, int *i, int *j, int *k);\r\n/// Allocate memory and scanf the data from the string\r\nvoid MGL_EXPORT mgl_data_set_values(HMDT dat, const char *val, long nx, long ny, long nz);\r\nvoid MGL_EXPORT mgl_data_set_values_(uintptr_t *d, const char *val, int *nx, int *ny, int *nz, int l);\r\n\r\n/// Read data array from HDF file (parse HDF4 and HDF5 files)\r\nint MGL_EXPORT mgl_data_read_hdf(HMDT d,const char *fname,const char *data);\r\nint MGL_EXPORT mgl_data_read_hdf_(uintptr_t *d, const char *fname, const char *data,int l,int n);\r\n/// Read data from tab-separated text file with auto determining size\r\nint MGL_EXPORT mgl_data_read(HMDT dat, const char *fname);\r\nint MGL_EXPORT mgl_data_read_(uintptr_t *d, const char *fname,int l);\r\n/// Read data from text file with size specified at beginning of the file\r\nint MGL_EXPORT mgl_data_read_mat(HMDT dat, const char *fname, long dim);\r\nint MGL_EXPORT mgl_data_read_mat_(uintptr_t *dat, const char *fname, int *dim, int);\r\n/// Read data from text file with specifeid size\r\nint MGL_EXPORT mgl_data_read_dim(HMDT dat, const char *fname,long mx,long my,long mz);\r\nint MGL_EXPORT mgl_data_read_dim_(uintptr_t *dat, const char *fname,int *mx,int *my,int *mz,int);\r\n/// Read data from tab-separated text files with auto determining size which filenames are result of sprintf(fname,templ,t) where t=from:step:to\r\nint MGL_EXPORT mgl_data_read_range(HMDT d, const char *templ, double n1, double n2, double step, int as_slice);\r\nint MGL_EXPORT mgl_data_read_range_(uintptr_t *d, const char *fname, mreal *n1, mreal *n2, mreal *step, int *as_slice,int l);\r\n/// Read data from tab-separated text files with auto determining size which filenames are satisfied to template (like \"t_*.dat\")\r\nint MGL_EXPORT mgl_data_read_all(HMDT dat, const char *templ, int as_slice);\r\nint MGL_EXPORT mgl_data_read_all_(uintptr_t *d, const char *fname, int *as_slice,int l);\r\n/// Import data array from PNG file according color scheme\r\nvoid MGL_EXPORT mgl_data_import(HMDT dat, const char *fname, const char *scheme,mreal v1,mreal v2);\r\nvoid MGL_EXPORT mgl_data_import_(uintptr_t *dat, const char *fname, const char *scheme,mreal *v1,mreal *v2,int,int);\r\n/// Scan textual file for template and fill data array\r\nint MGL_EXPORT mgl_data_scan_file(HMDT dat,const char *fname, const char *templ);\r\nint MGL_EXPORT mgl_data_scan_file_(uintptr_t *dat,const char *fname, const char *templ,int,int);\r\n/// Read data array from Tektronix WFM file\r\n/** Parse Tektronix TDS5000/B, TDS6000/B/C, TDS/CSA7000/B, MSO70000/C, DSA70000/B/C DPO70000/B/C DPO7000/ MSO/DPO5000. */\r\nint MGL_EXPORT mgl_data_read_wfm(HMDT d,const char *fname, long num, long step, long start);\r\nint MGL_EXPORT mgl_data_read_wfm_(uintptr_t *d, const char *fname, long *num, long *step, long *start,int l);\r\n/// Read data array from Matlab MAT file (parse versions 4 and 5)\r\nint MGL_EXPORT mgl_data_read_matlab(HMDT d,const char *fname,const char *data);\r\nint MGL_EXPORT mgl_data_read_matlab_(uintptr_t *d, const char *fname, const char *data,int l,int n);\r\n\r\n/// Create or recreate the array with specified size and fill it by zero\r\nvoid MGL_EXPORT mgl_data_create(HMDT dat, long nx,long ny,long nz);\r\nvoid MGL_EXPORT mgl_data_create_(uintptr_t *dat, int *nx,int *ny,int *nz);\r\n/// Transpose dimensions of the data (generalization of Transpose)\r\nvoid MGL_EXPORT mgl_data_transpose(HMDT dat, const char *dim);\r\nvoid MGL_EXPORT mgl_data_transpose_(uintptr_t *dat, const char *dim,int);\r\n/// Normalize the data to range [v1,v2]\r\nvoid MGL_EXPORT mgl_data_norm(HMDT dat, mreal v1,mreal v2,int sym,long dim);\r\nvoid MGL_EXPORT mgl_data_norm_(uintptr_t *dat, mreal *v1,mreal *v2,int *sym,int *dim);\r\n/// Normalize the data to range [v1,v2] slice by slice\r\nvoid MGL_EXPORT mgl_data_norm_slice(HMDT dat, mreal v1,mreal v2,char dir,long keep_en,long sym);\r\nvoid MGL_EXPORT mgl_data_norm_slice_(uintptr_t *dat, mreal *v1,mreal *v2,char *dir,int *keep_en,int *sym,int l);\r\n/// Limit the data to be inside [-v,v], keeping the original sign\r\nvoid MGL_EXPORT mgl_data_limit(HMDT dat, mreal v);\r\nvoid MGL_EXPORT mgl_data_limit_(uintptr_t *dat, mreal *v);\r\n/// Project the periodical data to range [v1,v2] (like mod() function). Separate branches by NAN if sep=true.\r\nvoid MGL_EXPORT mgl_data_coil(HMDT dat, mreal v1, mreal v2, int sep);\r\nvoid MGL_EXPORT mgl_data_coil_(uintptr_t *dat, mreal *v1, mreal *v2, int *sep);\r\n\r\n/// Get sub-array of the data with given fixed indexes\r\nHMDT MGL_EXPORT mgl_data_subdata(HCDT dat, long xx,long yy,long zz);\r\nuintptr_t MGL_EXPORT mgl_data_subdata_(uintptr_t *dat, int *xx,int *yy,int *zz);\r\n/// Get sub-array of the data with given fixed indexes (like indirect access)\r\nHMDT MGL_EXPORT mgl_data_subdata_ext(HCDT dat, HCDT xx, HCDT yy, HCDT zz);\r\nuintptr_t MGL_EXPORT mgl_data_subdata_ext_(uintptr_t *dat, uintptr_t *xx,uintptr_t *yy,uintptr_t *zz);\r\n/// Get column (or slice) of the data filled by formulas of named columns\r\nHMDT MGL_EXPORT mgl_data_column(HCDT dat, const char *eq);\r\nuintptr_t MGL_EXPORT mgl_data_column_(uintptr_t *dat, const char *eq,int l);\r\n/// Get data from sections ids, separated by value val along specified direction.\r\n/** If section id is negative then reverse order is used (i.e. -1 give last section). */\r\nHMDT MGL_EXPORT mgl_data_section(HCDT dat, HCDT ids, char dir, mreal val);\r\nuintptr_t MGL_EXPORT mgl_data_section_(uintptr_t *d, uintptr_t *ids, const char *dir, mreal *val,int);\r\n/// Get data from section id, separated by value val along specified direction.\r\n/** If section id is negative then reverse order is used (i.e. -1 give last section). */\r\nHMDT MGL_EXPORT mgl_data_section_val(HCDT dat, long id, char dir, mreal val);\r\nuintptr_t MGL_EXPORT mgl_data_section_val_(uintptr_t *d, int *id, const char *dir, mreal *val,int);\r\n/// Get contour lines for dat[i,j]=val. NAN values separate the the curves\r\nHMDT mgl_data_conts(mreal val, HCDT dat);\r\n\r\n/// Equidistantly fill the data to range [x1,x2] in direction dir\r\nvoid MGL_EXPORT mgl_data_fill(HMDT dat, mreal x1,mreal x2,char dir);\r\nvoid MGL_EXPORT mgl_data_fill_(uintptr_t *dat, mreal *x1,mreal *x2,const char *dir,int);\r\n/// Modify the data by specified formula assuming x,y,z in range [r1,r2]\r\nvoid MGL_EXPORT mgl_data_fill_eq(HMGL gr, HMDT dat, const char *eq, HCDT vdat, HCDT wdat,const char *opt);\r\nvoid MGL_EXPORT mgl_data_fill_eq_(uintptr_t *gr, uintptr_t *dat, const char *eq, uintptr_t *vdat, uintptr_t *wdat,const char *opt, int, int);\r\n/// Fill dat by interpolated values of vdat parametrically depended on xdat for x in range [x1,x2] using global spline\r\nvoid MGL_EXPORT mgl_data_refill_gs(HMDT dat, HCDT xdat, HCDT vdat, mreal x1, mreal x2, long sl);\r\nvoid MGL_EXPORT mgl_data_refill_gs_(uintptr_t *dat, uintptr_t *xdat, uintptr_t *vdat, mreal *x1, mreal *x2, long *sl);\r\n/// Fill dat by interpolated values of vdat parametrically depended on xdat for x in range [x1,x2]\r\nvoid MGL_EXPORT mgl_data_refill_x(HMDT dat, HCDT xdat, HCDT vdat, mreal x1, mreal x2, long sl);\r\nvoid MGL_EXPORT mgl_data_refill_x_(uintptr_t *dat, uintptr_t *xdat, uintptr_t *vdat, mreal *x1, mreal *x2, long *sl);\r\n/// Fill dat by interpolated values of vdat parametrically depended on xdat,ydat for x,y in range [x1,x2]*[y1,y2]\r\nvoid MGL_EXPORT mgl_data_refill_xy(HMDT dat, HCDT xdat, HCDT ydat, HCDT vdat, mreal x1, mreal x2, mreal y1, mreal y2, long sl);\r\nvoid MGL_EXPORT mgl_data_refill_xy_(uintptr_t *dat, uintptr_t *xdat, uintptr_t *ydat, uintptr_t *vdat, mreal *x1, mreal *x2, mreal *y1, mreal *y2, long *sl);\r\n/// Fill dat by interpolated values of vdat parametrically depended on xdat,ydat,zdat for x,y,z in range [x1,x2]*[y1,y2]*[z1,z2]\r\nvoid MGL_EXPORT mgl_data_refill_xyz(HMDT dat, HCDT xdat, HCDT ydat, HCDT zdat, HCDT vdat, mreal x1, mreal x2, mreal y1, mreal y2, mreal z1, mreal z2);\r\nvoid MGL_EXPORT mgl_data_refill_xyz_(uintptr_t *dat, uintptr_t *xdat, uintptr_t *ydat, uintptr_t *zdat, uintptr_t *vdat, mreal *x1, mreal *x2, mreal *y1, mreal *y2, mreal *z1, mreal *z2);\r\n/// Fill dat by interpolated values of vdat parametrically depended on xdat,ydat,zdat for x,y,z in axis range\r\nvoid MGL_EXPORT mgl_data_refill_gr(HMGL gr, HMDT dat, HCDT xdat, HCDT ydat, HCDT zdat, HCDT vdat, long sl, const char *opt);\r\nvoid MGL_EXPORT mgl_data_refill_gr_(uintptr_t *gr, uintptr_t *dat, uintptr_t *xdat, uintptr_t *ydat, uintptr_t *zdat, uintptr_t *vdat, long *sl, const char *opt,int);\r\n/// Set the data by triangulated surface values assuming x,y,z in range [r1,r2]\r\nvoid MGL_EXPORT mgl_data_grid(HMGL gr, HMDT d, HCDT xdat, HCDT ydat, HCDT zdat,const char *opt);\r\nvoid MGL_EXPORT mgl_data_grid_(uintptr_t *gr, uintptr_t *dat, uintptr_t *xdat, uintptr_t *ydat, uintptr_t *zdat, const char *opt,int);\r\n/// Set the data by triangulated surface values assuming x,y,z in range [x1,x2]*[y1,y2]\r\nvoid MGL_EXPORT mgl_data_grid_xy(HMDT d, HCDT xdat, HCDT ydat, HCDT zdat, mreal x1, mreal x2, mreal y1, mreal y2);\r\nvoid MGL_EXPORT mgl_data_grid_xy_(uintptr_t *dat, uintptr_t *xdat, uintptr_t *ydat, uintptr_t *zdat, mreal *x1, mreal *x2, mreal *y1, mreal *y2);\r\n/// Put value to data element(s)\r\nvoid MGL_EXPORT mgl_data_put_val(HMDT dat, mreal val, long i, long j, long k);\r\nvoid MGL_EXPORT mgl_data_put_val_(uintptr_t *dat, mreal *val, int *i, int *j, int *k);\r\n/// Put array to data element(s)\r\nvoid MGL_EXPORT mgl_data_put_dat(HMDT dat, HCDT val, long i, long j, long k);\r\nvoid MGL_EXPORT mgl_data_put_dat_(uintptr_t *dat, uintptr_t *val, int *i, int *j, int *k);\r\n/// Modify the data by specified formula\r\nvoid MGL_EXPORT mgl_data_modify(HMDT dat, const char *eq,long dim);\r\nvoid MGL_EXPORT mgl_data_modify_(uintptr_t *dat, const char *eq,int *dim,int);\r\n/// Modify the data by specified formula\r\nvoid MGL_EXPORT mgl_data_modify_vw(HMDT dat, const char *eq,HCDT vdat,HCDT wdat);\r\nvoid MGL_EXPORT mgl_data_modify_vw_(uintptr_t *dat, const char *eq, uintptr_t *vdat, uintptr_t *wdat,int);\r\n/// Reduce size of the data\r\nvoid MGL_EXPORT mgl_data_squeeze(HMDT dat, long rx,long ry,long rz,long smooth);\r\nvoid MGL_EXPORT mgl_data_squeeze_(uintptr_t *dat, int *rx,int *ry,int *rz,int *smooth);\r\n\r\n/// Get array which is n-th pairs {x[i],y[i]} for iterated function system (fractal) generated by A\r\n/** NOTE: A.nx must be >= 7. */\r\nHMDT MGL_EXPORT mgl_data_ifs_2d(HCDT A, long n, long skip);\r\nuintptr_t MGL_EXPORT mgl_data_ifs_2d_(uintptr_t *A, long *n, long *skip);\r\n/// Get array which is n-th points {x[i],y[i],z[i]} for iterated function system (fractal) generated by A\r\n/** NOTE: A.nx must be >= 13. */\r\nHMDT MGL_EXPORT mgl_data_ifs_3d(HCDT A, long n, long skip);\r\nuintptr_t MGL_EXPORT mgl_data_ifs_3d_(uintptr_t *A, long *n, long *skip);\r\n/// Get array which is n-th points {x[i],y[i],z[i]} for iterated function system (fractal) defined in *.ifs file 'fname' and named as 'name'\r\nHMDT MGL_EXPORT mgl_data_ifs_file(const char *fname, const char *name, long n, long skip);\r\nuintptr_t mgl_data_ifs_file_(const char *fname, const char *name, long *n, long *skip,int l,int m);\r\n/// Codes for flame fractal functions\r\nenum {\r\n\tmglFlame2d_linear=0,\tmglFlame2d_sinusoidal,\tmglFlame2d_spherical,\tmglFlame2d_swirl,\t\tmglFlame2d_horseshoe,\r\n\tmglFlame2d_polar,\t\tmglFlame2d_handkerchief,mglFlame2d_heart,\t\tmglFlame2d_disc,\t\tmglFlame2d_spiral,\r\n\tmglFlame2d_hyperbolic,\tmglFlame2d_diamond,\t\tmglFlame2d_ex,\t\t\tmglFlame2d_julia,\t\tmglFlame2d_bent,\r\n\tmglFlame2d_waves,\t\tmglFlame2d_fisheye,\t\tmglFlame2d_popcorn,\t\tmglFlame2d_exponential,\tmglFlame2d_power,\r\n\tmglFlame2d_cosine,\t\tmglFlame2d_rings,\t\tmglFlame2d_fan,\t\t\tmglFlame2d_blob,\t\tmglFlame2d_pdj,\r\n\tmglFlame2d_fan2,\t\tmglFlame2d_rings2,\t\tmglFlame2d_eyefish,\t\tmglFlame2d_bubble,\t\tmglFlame2d_cylinder,\r\n\tmglFlame2d_perspective,\tmglFlame2d_noise,\t\tmglFlame2d_juliaN,\t\tmglFlame2d_juliaScope,\tmglFlame2d_blur,\r\n\tmglFlame2d_gaussian,\tmglFlame2d_radialBlur,\tmglFlame2d_pie,\t\t\tmglFlame2d_ngon,\t\tmglFlame2d_curl,\r\n\tmglFlame2d_rectangles,\tmglFlame2d_arch,\t\tmglFlame2d_tangent,\t\tmglFlame2d_square,\t\tmglFlame2d_blade,\r\n\tmglFlame2d_secant,\t\tmglFlame2d_rays,\t\tmglFlame2d_twintrian,\tmglFlame2d_cross,\t\tmglFlame2d_disc2,\r\n\tmglFlame2d_supershape,\tmglFlame2d_flower,\t\tmglFlame2d_conic,\t\tmglFlame2d_parabola,\tmglFlame2d_bent2,\r\n\tmglFlame2d_bipolar,\t\tmglFlame2d_boarders,\tmglFlame2d_butterfly,\tmglFlame2d_cell,\t\tmglFlame2d_cpow,\r\n\tmglFlame2d_curve,\t\tmglFlame2d_edisc,\t\tmglFlame2d_elliptic,\tmglFlame2d_escher,\t\tmglFlame2d_foci,\r\n\tmglFlame2d_lazySusan,\tmglFlame2d_loonie,\t\tmglFlame2d_preBlur,\t\tmglFlame2d_modulus,\t\tmglFlame2d_oscope,\r\n\tmglFlame2d_polar2,\t\tmglFlame2d_popcorn2,\tmglFlame2d_scry,\t\tmglFlame2d_separation,\tmglFlame2d_split,\r\n\tmglFlame2d_splits,\t\tmglFlame2d_stripes,\t\tmglFlame2d_wedge,\t\tmglFlame2d_wedgeJulia,\tmglFlame2d_wedgeSph,\r\n\tmglFlame2d_whorl,\t\tmglFlame2d_waves2,\t\tmglFlame2d_exp,\t\t\tmglFlame2d_log,\t\t\tmglFlame2d_sin,\r\n\tmglFlame2d_cos,\t\t\tmglFlame2d_tan,\t\t\tmglFlame2d_sec,\t\t\tmglFlame2d_csc,\t\t\tmglFlame2d_cot,\r\n\tmglFlame2d_sinh,\t\tmglFlame2d_cosh,\t\tmglFlame2d_tanh,\t\tmglFlame2d_sech,\t\tmglFlame2d_csch,\r\n\tmglFlame2d_coth,\t\tmglFlame2d_auger,\t\tmglFlame2d_flux,\t\tmglFlame2dLAST\r\n};\r\n/// Get array which is n-th pairs {x[i],y[i]} for Flame fractal generated by A with functions F\r\n/** NOTE: A.nx must be >= 7 and F.nx >= 2 and F.nz=A.ny.\r\n * F[0,i,j] denote function id. F[1,i,j] give function weight. F(2:5,i,j) provide function parameters.\r\n * Resulting point is {xnew,ynew} = sum_i F[1,i,j]*F[0,i,j]{IFS2d(A[j]){x,y}}. */\r\nHMDT MGL_EXPORT mgl_data_flame_2d(HCDT A, HCDT F, long n, long skip);\r\nuintptr_t MGL_EXPORT mgl_data_flame_2d_(uintptr_t *A, uintptr_t *F, long *n, long *skip);\r\n\r\n/// Get curves, separated by NAN, for maximal values of array d as function of x coordinate.\r\n/** Noises below lvl amplitude are ignored.\r\n  * Parameter dy \\in [0,ny] set the \"attraction\" distance of points to curve. */\r\nHMDT MGL_EXPORT mgl_data_detect(HCDT d, mreal lvl, mreal dj, mreal di, mreal min_len);\r\nuintptr_t MGL_EXPORT mgl_data_detect_(uintptr_t *d, mreal *lvl, mreal *dj, mreal *di, mreal *min_len);\r\n\r\n/// Get array as solution of tridiagonal matrix solution a[i]*x[i-1]+b[i]*x[i]+c[i]*x[i+1]=d[i]\r\n/** String \\a how may contain:\r\n * 'x', 'y', 'z' for solving along x-,y-,z-directions, or\r\n * 'h' for solving along hexagonal direction at x-y plain (need nx=ny),\r\n * 'c' for using periodical boundary conditions,\r\n * 'd' for diffraction/diffuse calculation.\r\n * NOTE: It work for flat data model only (i.e. for a[i,j]==a[i+nx*j]) */\r\nHMDT MGL_EXPORT mgl_data_tridmat(HCDT A, HCDT B, HCDT C, HCDT D, const char *how);\r\nuintptr_t MGL_EXPORT mgl_data_tridmat_(uintptr_t *A, uintptr_t *B, uintptr_t *C, uintptr_t *D, const char *how, int);\r\n\r\n/// Returns pointer to data element [i,j,k]\r\nMGL_EXPORT mreal *mgl_data_value(HMDT dat, long i,long j,long k);\r\n/// Returns pointer to internal data array\r\nMGL_EXPORT_PURE mreal *mgl_data_data(HMDT dat);\r\n\r\n/// Gets the x-size of the data.\r\nlong MGL_EXPORT mgl_data_get_nx(HCDT d);\r\nlong MGL_EXPORT mgl_data_get_nx_(uintptr_t *d);\r\n/// Gets the y-size of the data.\r\nlong MGL_EXPORT mgl_data_get_ny(HCDT d);\r\nlong MGL_EXPORT mgl_data_get_ny_(uintptr_t *d);\r\n/// Gets the z-size of the data.\r\nlong MGL_EXPORT mgl_data_get_nz(HCDT d);\r\nlong MGL_EXPORT mgl_data_get_nz_(uintptr_t *d);\r\n\r\n/// Get the data which is direct multiplication (like, d[i,j] = this[i]*a[j] and so on)\r\nHMDT MGL_EXPORT mgl_data_combine(HCDT dat1, HCDT dat2);\r\nuintptr_t MGL_EXPORT mgl_data_combine_(uintptr_t *dat1, uintptr_t *dat2);\r\n/// Extend data dimensions\r\nvoid MGL_EXPORT mgl_data_extend(HMDT dat, long n1, long n2);\r\nvoid MGL_EXPORT mgl_data_extend_(uintptr_t *dat, int *n1, int *n2);\r\n/// Insert data rows/columns/slices\r\nvoid MGL_EXPORT mgl_data_insert(HMDT dat, char dir, long at, long num);\r\nvoid MGL_EXPORT mgl_data_insert_(uintptr_t *dat, const char *dir, int *at, int *num, int);\r\n/// Delete data rows/columns/slices\r\nvoid MGL_EXPORT mgl_data_delete(HMDT dat, char dir, long at, long num);\r\nvoid MGL_EXPORT mgl_data_delete_(uintptr_t *dat, const char *dir, int *at, int *num, int);\r\n/// Joind another data array\r\nvoid MGL_EXPORT mgl_data_join(HMDT dat, HCDT d);\r\nvoid MGL_EXPORT mgl_data_join_(uintptr_t *dat, uintptr_t *d);\r\n\r\n/// Smooth the data on specified direction or directions\r\n/** String \\a dir may contain:\r\n *  ‘x’, ‘y’, ‘z’ for 1st, 2nd or 3d dimension;\r\n *  ‘dN’ for linear averaging over N points;\r\n *  ‘3’ for linear averaging over 3 points;\r\n *  ‘5’ for linear averaging over 5 points.\r\n *  By default quadratic averaging over 5 points is used. */\r\nvoid MGL_EXPORT mgl_data_smooth(HMDT d, const char *dirs, mreal delta);\r\nvoid MGL_EXPORT mgl_data_smooth_(uintptr_t *dat, const char *dirs, mreal *delta,int);\r\n/// Get array which is result of summation in given direction or directions\r\nHMDT MGL_EXPORT mgl_data_sum(HCDT dat, const char *dir);\r\nuintptr_t MGL_EXPORT mgl_data_sum_(uintptr_t *dat, const char *dir,int);\r\n/// Get array which is result of maximal values in given direction or directions\r\nHMDT MGL_EXPORT mgl_data_max_dir(HCDT dat, const char *dir);\r\nuintptr_t MGL_EXPORT mgl_data_max_dir_(uintptr_t *dat, const char *dir,int);\r\n/// Get array which is result of minimal values in given direction or directions\r\nHMDT MGL_EXPORT mgl_data_min_dir(HCDT dat, const char *dir);\r\nuintptr_t MGL_EXPORT mgl_data_min_dir_(uintptr_t *dat, const char *dir,int);\r\n/// Get positions of local maximums and minimums\r\nHMDT MGL_EXPORT mgl_data_minmax(HCDT dat);\r\nuintptr_t MGL_EXPORT mgl_data_minmax_(uintptr_t *dat);\r\n/// Get indexes of a set of connected surfaces for set of values {a_ijk,b_ijk} as dependent on j,k\r\n/** NOTE: not optimized for general case!!! */\r\nHMDT MGL_EXPORT mgl_data_connect(HCDT a, HCDT b);\r\nuintptr_t MGL_EXPORT mgl_data_connect_(uintptr_t *a, uintptr_t *b);\r\n/// Resort data values according found connected surfaces for set of values {a_ijk,b_ijk} as dependent on j,k\r\n/** NOTE: not optimized for general case!!! */\r\nvoid MGL_EXPORT mgl_data_connect_r(HMDT a, HMDT b);\r\nvoid MGL_EXPORT mgl_data_connect_r_(uintptr_t *a, uintptr_t *b);\r\n\r\n/// Cumulative summation the data in given direction or directions\r\nvoid MGL_EXPORT mgl_data_cumsum(HMDT dat, const char *dir);\r\nvoid MGL_EXPORT mgl_data_cumsum_(uintptr_t *dat, const char *dir,int);\r\n/// Integrate (cumulative summation) the data in given direction or directions\r\nvoid MGL_EXPORT mgl_data_integral(HMDT dat, const char *dir);\r\nvoid MGL_EXPORT mgl_data_integral_(uintptr_t *dat, const char *dir,int);\r\n/// Differentiate the data in given direction or directions\r\nvoid MGL_EXPORT mgl_data_diff(HMDT dat, const char *dir);\r\nvoid MGL_EXPORT mgl_data_diff_(uintptr_t *dat, const char *dir,int);\r\n/// Differentiate the parametrically specified data along direction v1 with v2,v3=const (v3 can be NULL)\r\nvoid MGL_EXPORT mgl_data_diff_par(HMDT dat, HCDT v1, HCDT v2, HCDT v3);\r\nvoid MGL_EXPORT mgl_data_diff_par_(uintptr_t *dat, uintptr_t *v1, uintptr_t *v2, uintptr_t *v3);\r\n/// Double-differentiate (like Laplace operator) the data in given direction\r\nvoid MGL_EXPORT mgl_data_diff2(HMDT dat, const char *dir);\r\nvoid MGL_EXPORT mgl_data_diff2_(uintptr_t *dat, const char *dir,int);\r\n/// Swap left and right part of the data in given direction (useful for Fourier spectrum)\r\nvoid MGL_EXPORT mgl_data_swap(HMDT dat, const char *dir);\r\nvoid MGL_EXPORT mgl_data_swap_(uintptr_t *dat, const char *dir,int);\r\n/// Roll data along direction dir by num slices\r\nvoid MGL_EXPORT mgl_data_roll(HMDT dat, char dir, long num);\r\nvoid MGL_EXPORT mgl_data_roll_(uintptr_t *dat, const char *dir, int *num, int);\r\n/// Mirror the data in given direction (useful for Fourier spectrum)\r\nvoid MGL_EXPORT mgl_data_mirror(HMDT dat, const char *dir);\r\nvoid MGL_EXPORT mgl_data_mirror_(uintptr_t *dat, const char *dir,int);\r\n/// Sort rows (or slices) by values of specified column\r\nvoid MGL_EXPORT mgl_data_sort(HMDT dat, long idx, long idy);\r\nvoid MGL_EXPORT mgl_data_sort_(uintptr_t *dat, int *idx, int *idy);\r\n/// Return dilated array of 0 or 1 for data values larger val\r\nvoid MGL_EXPORT mgl_data_dilate(HMDT dat, mreal val, long step);\r\nvoid MGL_EXPORT mgl_data_dilate_(uintptr_t *dat, mreal *val, int *step);\r\n/// Return eroded array of 0 or 1 for data values larger val\r\nvoid MGL_EXPORT mgl_data_erode(HMDT dat, mreal val, long step);\r\nvoid MGL_EXPORT mgl_data_erode_(uintptr_t *dat, mreal *val, int *step);\r\n\r\n/// Apply Hankel transform\r\nvoid MGL_EXPORT mgl_data_hankel(HMDT dat, const char *dir);\r\nvoid MGL_EXPORT mgl_data_hankel_(uintptr_t *dat, const char *dir,int);\r\n/// Apply Sin-Fourier transform\r\nvoid MGL_EXPORT mgl_data_sinfft(HMDT dat, const char *dir);\r\nvoid MGL_EXPORT mgl_data_sinfft_(uintptr_t *dat, const char *dir,int);\r\n/// Apply Cos-Fourier transform\r\nvoid MGL_EXPORT mgl_data_cosfft(HMDT dat, const char *dir);\r\nvoid MGL_EXPORT mgl_data_cosfft_(uintptr_t *dat, const char *dir,int);\r\n/// Fill data by coordinates/momenta samples for Hankel ('h') or Fourier ('f') transform\r\n/** Parameter \\a how may contain:\r\n * ‘x‘,‘y‘,‘z‘ for direction (only one will be used),\r\n * ‘k‘ for momenta samples,\r\n * ‘h‘ for Hankel samples,\r\n * ‘f‘ for Cartesian/Fourier samples (default). */\r\nvoid MGL_EXPORT mgl_data_fill_sample(HMDT dat, const char *how);\r\nvoid MGL_EXPORT mgl_data_fill_sample_(uintptr_t *dat, const char *how,int);\r\n/// Find correlation between 2 data arrays\r\nHMDT MGL_EXPORT mgl_data_correl(HCDT dat1, HCDT dat2, const char *dir);\r\nuintptr_t MGL_EXPORT mgl_data_correl_(uintptr_t *dat1, uintptr_t *dat2, const char *dir,int);\r\n/// Apply wavelet transform\r\n/** Parameter \\a dir may contain:\r\n * ‘x‘,‘y‘,‘z‘ for directions,\r\n * ‘d‘ for daubechies, ‘D‘ for centered daubechies,\r\n * ‘h‘ for haar, ‘H‘ for centered haar,\r\n * ‘b‘ for bspline, ‘B‘ for centered bspline,\r\n * ‘i‘ for applying inverse transform. */\r\nvoid MGL_EXPORT mgl_data_wavelet(HMDT dat, const char *how, int k);\r\nvoid MGL_EXPORT mgl_data_wavelet_(uintptr_t *d, const char *dir, int *k,int);\r\n\r\n/// Allocate and prepare data for Fourier transform by nthr threads\r\nMGL_EXPORT void *mgl_fft_alloc(long n, void **space, long nthr);\r\nMGL_EXPORT void *mgl_fft_alloc_thr(long n);\r\n/// Free data for Fourier transform\r\nvoid MGL_EXPORT mgl_fft_free(void *wt, void **ws, long nthr);\r\nvoid MGL_EXPORT mgl_fft_free_thr(void *wt);\r\n/// Make Fourier transform of data x of size n and step s between points\r\nvoid MGL_EXPORT mgl_fft(double *x, long s, long n, const void *wt, void *ws, int inv);\r\n/// Clear internal data for speeding up FFT and Hankel transforms\r\nvoid MGL_EXPORT mgl_clear_fft();\r\n\r\n/// Interpolate by cubic spline the data to given point x=[0...nx-1], y=[0...ny-1], z=[0...nz-1]\r\nmreal MGL_EXPORT mgl_data_spline(HCDT dat, mreal x,mreal y,mreal z);\r\nmreal MGL_EXPORT mgl_data_spline_(uintptr_t *dat, mreal *x,mreal *y,mreal *z);\r\n/// Interpolate by cubic spline the data and return its derivatives at given point x=[0...nx-1], y=[0...ny-1], z=[0...nz-1]\r\nmreal MGL_EXPORT mgl_data_spline_ext(HCDT dat, mreal x,mreal y,mreal z, mreal *dx,mreal *dy,mreal *dz);\r\nmreal MGL_EXPORT mgl_data_spline_ext_(uintptr_t *dat, mreal *x,mreal *y,mreal *z, mreal *dx,mreal *dy,mreal *dz);\r\n/// Prepare coefficients for global spline interpolation\r\nHMDT MGL_EXPORT mgl_gspline_init(HCDT x, HCDT v);\r\nuintptr_t MGL_EXPORT mgl_gspline_init_(uintptr_t *x, uintptr_t *v);\r\n/// Evaluate global spline (and its derivatives d1, d2 if not NULL) using prepared coefficients \\a coef\r\nmreal MGL_EXPORT mgl_gspline(HCDT coef, mreal dx, mreal *d1, mreal *d2);\r\nmreal MGL_EXPORT mgl_gspline_(uintptr_t *c, mreal *dx, mreal *d1, mreal *d2);\r\n/// Return an approximated x-value (root) when dat(x) = val\r\nmreal MGL_EXPORT mgl_data_solve_1d(HCDT dat, mreal val, int spl, long i0);\r\nmreal MGL_EXPORT mgl_data_solve_1d_(uintptr_t *dat, mreal *val, int *spl, int *i0);\r\n/// Return an approximated value (root) when dat(x) = val\r\nHMDT MGL_EXPORT mgl_data_solve(HCDT dat, mreal val, char dir, HCDT i0, int norm);\r\nuintptr_t MGL_EXPORT mgl_data_solve_(uintptr_t *dat, mreal *val, const char *dir, uintptr_t *i0, int *norm,int);\r\n\r\n/// Get trace of the data array\r\nHMDT MGL_EXPORT mgl_data_trace(HCDT d);\r\nuintptr_t MGL_EXPORT mgl_data_trace_(uintptr_t *d);\r\n/// Resize the data to new sizes\r\nHMDT MGL_EXPORT mgl_data_resize(HCDT dat, long mx,long my,long mz);\r\nuintptr_t MGL_EXPORT mgl_data_resize_(uintptr_t *dat, int *mx,int *my,int *mz);\r\n/// Resize the data to new sizes of box [x1,x2]*[y1,y2]*[z1,z2]\r\nHMDT MGL_EXPORT mgl_data_resize_box(HCDT dat, long mx,long my,long mz,mreal x1,mreal x2,mreal y1,mreal y2,mreal z1,mreal z2);\r\nuintptr_t MGL_EXPORT mgl_data_resize_box_(uintptr_t *dat, int *mx,int *my,int *mz,mreal *x1,mreal *x2,mreal *y1,mreal *y2,mreal *z1,mreal *z2);\r\n/// Create n-th points distribution of this data values in range [v1, v2]\r\nHMDT MGL_EXPORT mgl_data_hist(HCDT dat, long n, mreal v1, mreal v2, long nsub);\r\nuintptr_t MGL_EXPORT mgl_data_hist_(uintptr_t *dat, int *n, mreal *v1, mreal *v2, int *nsub);\r\n/// Create n-th points distribution of this data values in range [v1, v2] with weight w\r\nHMDT MGL_EXPORT mgl_data_hist_w(HCDT dat, HCDT weight, long n, mreal v1, mreal v2, long nsub);\r\nuintptr_t MGL_EXPORT mgl_data_hist_w_(uintptr_t *dat, uintptr_t *weight, int *n, mreal *v1, mreal *v2, int *nsub);\r\n/// Get momentum (1D-array) of data along direction 'dir'. String looks like \"x1\" for median in x-direction, \"x2\" for width in x-dir and so on.\r\nHMDT MGL_EXPORT mgl_data_momentum(HCDT dat, char dir, const char *how);\r\nuintptr_t MGL_EXPORT mgl_data_momentum_(uintptr_t *dat, char *dir, const char *how, int,int);\r\n/// Get pulse properties: pulse maximum and its position, pulse duration near maximum and by half height.\r\nHMDT MGL_EXPORT mgl_data_pulse(HCDT dat, char dir);\r\nuintptr_t MGL_EXPORT mgl_data_pulse_(uintptr_t *dat, char *dir,int);\r\n/// Get array which values is result of interpolation this for coordinates from other arrays\r\nHMDT MGL_EXPORT mgl_data_evaluate(HCDT dat, HCDT idat, HCDT jdat, HCDT kdat, int norm);\r\nuintptr_t MGL_EXPORT mgl_data_evaluate_(uintptr_t *dat, uintptr_t *idat, uintptr_t *jdat, uintptr_t *kdat, int *norm);\r\n/// Set as the data envelop\r\nvoid MGL_EXPORT mgl_data_envelop(HMDT dat, char dir);\r\nvoid MGL_EXPORT mgl_data_envelop_(uintptr_t *dat, const char *dir, int);\r\n/// Remove phase jump\r\nvoid MGL_EXPORT mgl_data_sew(HMDT dat, const char *dirs, mreal da);\r\nvoid MGL_EXPORT mgl_data_sew_(uintptr_t *dat, const char *dirs, mreal *da, int);\r\n/// Crop the data\r\nvoid MGL_EXPORT mgl_data_crop(HMDT dat, long n1, long n2, char dir);\r\nvoid MGL_EXPORT mgl_data_crop_(uintptr_t *dat, int *n1, int *n2, const char *dir,int);\r\n/// Crop the data to be most optimal for FFT (i.e. to closest value of 2^n*3^m*5^l)\r\nvoid MGL_EXPORT mgl_data_crop_opt(HMDT dat, const char *how);\r\nvoid MGL_EXPORT mgl_data_crop_opt_(uintptr_t *dat, const char *how,int);\r\n/// Remove rows with duplicate values in column id\r\nvoid MGL_EXPORT mgl_data_clean(HMDT dat, long id);\r\nvoid MGL_EXPORT mgl_data_clean_(uintptr_t *dat, int *id);\r\n\r\n/// Multiply the data by other one for each element\r\nvoid MGL_EXPORT mgl_data_mul_dat(HMDT dat, HCDT d);\r\nvoid MGL_EXPORT mgl_data_mul_dat_(uintptr_t *dat, uintptr_t *d);\r\n/// Divide the data by other one for each element\r\nvoid MGL_EXPORT mgl_data_div_dat(HMDT dat, HCDT d);\r\nvoid MGL_EXPORT mgl_data_div_dat_(uintptr_t *dat, uintptr_t *d);\r\n/// Add the other data\r\nvoid MGL_EXPORT mgl_data_add_dat(HMDT dat, HCDT d);\r\nvoid MGL_EXPORT mgl_data_add_dat_(uintptr_t *dat, uintptr_t *d);\r\n/// Subtract the other data\r\nvoid MGL_EXPORT mgl_data_sub_dat(HMDT dat, HCDT d);\r\nvoid MGL_EXPORT mgl_data_sub_dat_(uintptr_t *dat, uintptr_t *d);\r\n/// Multiply each element by the number\r\nvoid MGL_EXPORT mgl_data_mul_num(HMDT dat, mreal d);\r\nvoid MGL_EXPORT mgl_data_mul_num_(uintptr_t *dat, mreal *d);\r\n/// Divide each element by the number\r\nvoid MGL_EXPORT mgl_data_div_num(HMDT dat, mreal d);\r\nvoid MGL_EXPORT mgl_data_div_num_(uintptr_t *dat, mreal *d);\r\n/// Add the number\r\nvoid MGL_EXPORT mgl_data_add_num(HMDT dat, mreal d);\r\nvoid MGL_EXPORT mgl_data_add_num_(uintptr_t *dat, mreal *d);\r\n/// Subtract the number\r\nvoid MGL_EXPORT mgl_data_sub_num(HMDT dat, mreal d);\r\nvoid MGL_EXPORT mgl_data_sub_num_(uintptr_t *dat, mreal *d);\r\n\r\n/// Integral data transformation (like Fourier 'f' or 'i', Hankel 'h' or None 'n') for amplitude and phase\r\nHMDT MGL_EXPORT mgl_transform_a(HCDT am, HCDT ph, const char *tr);\r\nuintptr_t MGL_EXPORT mgl_transform_a_(uintptr_t *am, uintptr_t *ph, const char *tr, int);\r\n/// Integral data transformation (like Fourier 'f' or 'i', Hankel 'h' or None 'n') for real and imaginary parts\r\nHMDT MGL_EXPORT mgl_transform(HCDT re, HCDT im, const char *tr);\r\nuintptr_t MGL_EXPORT mgl_transform_(uintptr_t *re, uintptr_t *im, const char *tr, int);\r\n/// Apply Fourier transform for the data and save result into it\r\nvoid MGL_EXPORT mgl_data_fourier(HMDT re, HMDT im, const char *dir);\r\nvoid MGL_EXPORT mgl_data_fourier_(uintptr_t *re, uintptr_t *im, const char *dir, int l);\r\n/// Short time Fourier analysis for real and imaginary parts. Output is amplitude of partial Fourier (result will have size {dn, floor(nx/dn), ny} for dir='x'\r\nHMDT MGL_EXPORT mgl_data_stfa(HCDT re, HCDT im, long dn, char dir);\r\nuintptr_t MGL_EXPORT mgl_data_stfa_(uintptr_t *re, uintptr_t *im, int *dn, char *dir, int);\r\n\r\n/// Do something like Delone triangulation for 3d points\r\nHMDT MGL_EXPORT mgl_triangulation_3d(HCDT x, HCDT y, HCDT z);\r\nuintptr_t MGL_EXPORT mgl_triangulation_3d_(uintptr_t *x, uintptr_t *y, uintptr_t *z);\r\n/// Do Delone triangulation for 2d points\r\nHMDT MGL_EXPORT mgl_triangulation_2d(HCDT x, HCDT y);\r\nuintptr_t MGL_EXPORT mgl_triangulation_2d_(uintptr_t *x, uintptr_t *y);\r\n\r\n/// Find root for nonlinear equation\r\nmreal MGL_EXPORT mgl_find_root(mreal (*func)(mreal val, void *par), mreal ini, void *par);\r\n/// Find root for nonlinear equation defined by textual formula\r\nmreal MGL_EXPORT mgl_find_root_txt(const char *func, mreal ini, char var_id);\r\nmreal MGL_EXPORT mgl_find_root_txt_(const char *func, mreal *ini, const char *var_id,int,int);\r\n/// Find roots for nonlinear equation defined by textual formula\r\nHMDT MGL_EXPORT mgl_data_roots(const char *func, HCDT ini, char var_id);\r\nuintptr_t MGL_EXPORT mgl_data_roots_(const char *func, uintptr_t *ini, const char *var_id,int,int);\r\n/// Find roots for set of nonlinear equations defined by textual formulas\r\nHMDT MGL_EXPORT mgl_find_roots_txt(const char *func, const char *vars, HCDT ini);\r\nuintptr_t MGL_EXPORT mgl_find_roots_txt_(const char *func, const char *vars, uintptr_t *ini,int,int);\r\n/// Find roots for set of nonlinear equations defined by function\r\nint MGL_EXPORT mgl_find_roots(size_t n, void (*func)(const mreal *x, mreal *f, void *par), mreal *x0, void *par);\r\n//-----------------------------------------------------------------------------\r\n#ifdef __cplusplus\r\n}\r\n#endif\r\n#endif\r\n//-----------------------------------------------------------------------------\r\n", "meta": {"hexsha": "d6e098720e2de2e4428a5453e51b3d013d683b1f", "size": 36492, "ext": "h", "lang": "C", "max_stars_repo_path": "openal-mathgl-generate/include/mgl2/data_cf.h", "max_stars_repo_name": "dickensas/kotlin-gradle-templates", "max_stars_repo_head_hexsha": "dc738b9fac053ef62381ecbe88add6f6fe949fe3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 54.0, "max_stars_repo_stars_event_min_datetime": "2019-11-12T03:55:12.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-20T14:28:02.000Z", "max_issues_repo_path": "openal-mathgl-generate/include/mgl2/data_cf.h", "max_issues_repo_name": "dickensas/kotlin-gradle-templates", "max_issues_repo_head_hexsha": "dc738b9fac053ef62381ecbe88add6f6fe949fe3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2020-07-31T10:50:54.000Z", "max_issues_repo_issues_event_max_datetime": "2021-01-08T06:16:28.000Z", "max_forks_repo_path": "openal-mathgl-generate/include/mgl2/data_cf.h", "max_forks_repo_name": "dickensas/kotlin-gradle-templates", "max_forks_repo_head_hexsha": "dc738b9fac053ef62381ecbe88add6f6fe949fe3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 14.0, "max_forks_repo_forks_event_min_datetime": "2019-12-05T12:55:43.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-10T00:47:15.000Z", "avg_line_length": 68.3370786517, "max_line_length": 188, "alphanum_fraction": 0.735805108, "num_tokens": 11141, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.34510528442897664, "lm_q2_score": 0.04272220013649572, "lm_q1q2_score": 0.01474365702953702}}
{"text": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <stdarg.h>\n#include <math.h>\n#include <unistd.h>\n#include <limits.h>\n#include <sys/time.h>\n#include <zlib.h>\n\n#ifdef INTEL_COMPILER\n#include \"mkl.h\"\n#else\n#include <cblas.h>\n#endif\n\n//#define FIBS_UNIT 1000\n#define DEFAULT_NDIGITS 10\n#define SZBUF 1024\n#define SZBYTE 256\n#define N_GENOTYPES 4\n#define NA_GENO_CHAR (N_GENOTYPES-1)\n#define DEFAULT_ROW_SIZE 100000\n#define DEFAULT_SIZE_MATRIX 1000000\n#define DEFAULT_SIZE_HEADER 100000\n#define DEFAULT_DELIMS \" \\t\\r\\n\"\n#define SZ_LONG_BUF 1000000\n#define DEFAULT_TPED_NUM_HEADER_COLS 4\n#define DEFAULT_TFAM_NUM_HEADER_COLS 6\n#define DEFAULT_TPED_SNPID_INDEX 1\n#define DEFAULT_PHENO_NUM_HEADER_COLS 2\n\nstruct HFILE {\n  int gzflag;       // 1 if gz if used\n  int wflag;        // r(0)/w(1) for plain, rb(0)/wb(1) for gz\n  int nheadercols;  // # of header columns (0 if nrows=0)\n  int nvaluecols;   // # of value cols (0 if nrows=0)\n  int nrows;        // # of rows\n  FILE* fp;         // plain file handle\n  gzFile gzfp;      // gzip file handle\n};\n\n// Input routines\nvoid close_file (struct HFILE* fhp);\nstruct HFILE open_file(char* filename, int gzflag, int wflag);\nstruct HFILE open_file_with_suffix(char* prefix, char* suffix, int gzflag, int wflag);\n//void read_matrix_with_col_headers( struct HFILE* fhp, int nheadercols, char* delims, int symmetric, int* p_nmiss, unsigned char** matrix, char*** headers);\nvoid read_matrix_with_col_headers( struct HFILE* fhp, int nheadercols, char* delims, int* p_nmiss, unsigned char** matrix, char*** headers);\nunsigned char* tokenize_tped_line_with_col_headers( struct HFILE* fhp, int nheadercols, char* delims, char* lbuf, unsigned char* values, char** headers, int* p_nvalues, int* p_nmiss );\n\nvoid emmax_error( const char* format, ... );\nvoid print_help(void);\nFILE* readfile(char* filename);\n\nvoid print_help(void) {\n  fprintf(stderr,\"Usage: emmax_kin [tpedf]\\n\");\n  fprintf(stderr,\"Required parameters\\n\");\n  fprintf(stderr,\"\\t[tpedf]     : tped file\\n\");\n  fprintf(stderr,\"Optional parameters\\n\");\n  fprintf(stderr,\"\\t-d [# digits]  : precision of the kinship values (default : 10)\\n\");\n  fprintf(stderr,\"\\t-M [float] : maximum memory in GB (default: 4.0)\\n\");\n  fprintf(stderr,\"\\t-s : compute IBS kinship matrix (default is Balding-Nicholas)\\n\");\n  fprintf(stderr,\"\\t-v : turn on verbose mode\\n\");\n  fprintf(stderr,\"\\t-r : randomly fill missing genotypes (default is imputation by average)\\n\");\n  fprintf(stderr,\"\\t-x : include non-autosomal chromosomes in computing kinship matrices\\n\");\n  fprintf(stderr,\"\\t-S [int] : set random seed\\n\");\n  fprintf(stderr,\"\\t-m [float] : MAF threshold (default is 0)\\n\");\n  fprintf(stderr,\"\\t-c [float] : Call rate threshold (default is 0)\\n\");\n}\n\n//void read_matrix_with_col_headers( struct HFILE* fhp, int nheadercols, char* delims, int symmetric, int* p_nmiss, unsigned char** matrix, char*** headers) {\nvoid read_matrix_with_col_headers( struct HFILE* fhp, int nheadercols, char* delims, int* p_nmiss, unsigned char** matrix, char*** headers) {\n  char* lbuf = (char*) malloc(sizeof(char*) * SZ_LONG_BUF);\n  int szmat = DEFAULT_SIZE_MATRIX;\n  int szheader = DEFAULT_SIZE_HEADER;\n  unsigned char* cmat = (unsigned char*) malloc(sizeof(unsigned char) * szmat );\n  char** cheaders = (char**) malloc(sizeof(char*) * szheader );\n  int nvalues, i, j, nmiss;\n\n  fhp->nheadercols = nheadercols; \n  nmiss = 0;\n\n  while( tokenize_tped_line_with_col_headers(fhp, nheadercols, delims, lbuf, &cmat[fhp->nrows*fhp->nvaluecols], &cheaders[fhp->nrows*fhp->nheadercols], &nvalues, &nmiss) != NULL ) {\n    if ( fhp->nrows == 1 ) {\n      fhp->nvaluecols = nvalues;\n    }\n    else if ( fhp->nvaluecols != nvalues ) {\n      emmax_error(\"The column size %d do not match to %d at line %d\\n\",nvalues,fhp->nvaluecols,fhp->nrows);\n    }\n\n    if ( (fhp->nrows+1)*(fhp->nvaluecols) > szheader ) {\n      szheader *= 2;\n      fprintf(stderr,\"Header size is doubled to %d\\n\",szheader);\n      cheaders = (char**) realloc( cheaders, sizeof(char*) * szheader );\n    }\n\n    if ( (fhp->nrows+1)*(fhp->nvaluecols) > szheader ) {\n      szmat *= 2;\n      fprintf(stderr,\"Matrix size is doubled to %d\\n\",szmat);\n      cmat = (unsigned char*) realloc( cmat, sizeof(unsigned char) * szmat );\n    }\n  }\n  free(lbuf);\n\n  *p_nmiss = nmiss;\n  \n  unsigned char* fmat = (unsigned char*) malloc(sizeof(unsigned char)*fhp->nrows*fhp->nvaluecols);\n  char** fheaders = (char**) malloc(sizeof(char*)*fhp->nrows*fhp->nheadercols);\n  for(i=0; i < fhp->nrows; ++i) {\n    for(j=0; j < fhp->nvaluecols; ++j) {\n      fmat[i+j*fhp->nrows] = cmat[i*fhp->nvaluecols+j];\n    }\n    for(j=0; j < fhp->nheadercols; ++j) {\n      fheaders[i+j*fhp->nrows] = cheaders[i*fhp->nheadercols+j];\n    }\n  }\n  free(cmat);\n  free(cheaders);\n  \n  if ( matrix != NULL ) {\n    if ( *matrix != NULL ) {\n      free(*matrix);\n    }\n    *matrix = fmat;\n  }\n  \n  if ( headers != NULL ) {\n    if ( *headers != NULL ) {\n      free(*headers);\n    }\n    *headers = fheaders;\n  }\n}\n\nunsigned char* tokenize_tped_line_with_col_headers( struct HFILE* fhp, int nheadercols, char* delims, char* lbuf, unsigned char* values, char** headers, int* p_nvalues, int* p_nmiss ) {\n  int j;\n  char *token;\n  unsigned char ctoken;\n\n  char *ret = (fhp->gzflag == 1) ? gzgets(fhp->gzfp, lbuf, SZ_LONG_BUF) : fgets( lbuf, SZ_LONG_BUF, fhp->fp );\n  int nmiss = 0;\n\n  if ( ret == NULL ) {\n    return NULL;\n  }\n\n  if ( fhp->nheadercols != nheadercols ) {\n    emmax_error(\"# of header columns mismatch (%d vs %d) at line %d\",fhp->nheadercols,nheadercols,fhp->nrows);\n  }\n\n  //fprintf(stderr,\"tokenize-line called %s\\n\",lbuf);\n\n  token = strtok(lbuf, delims);\n  for( j=0; token != NULL; ++j ) {\n    if ( j < nheadercols ) {\n      headers[j] = strdup(token);\n    }\n    // if zero_miss_flag is set, assume the genotypes are encoded 0,1,2\n    // Additively encodes the two genotypes in the following way\n    // when (j-nheadercols) is even, 0->MISSING, add 1->0, 2->1\n    // when (j-nheadercols) is odd, check 0-0 consistency, and add 1->0, 2->1\n    else {\n      ctoken = (unsigned char)(token[0]-'0');\n      \n      if ( ctoken > 2 ) {\n\tfprintf(stderr,\"Unrecognized token %s\\n\",token);\n\tabort();\n      }\n      \n      if ( (j-nheadercols) % 2 == 0 ) {\n\tvalues[(j-nheadercols)/2] = ctoken;\n      }\n      else {\n\tif ( ( ctoken > 0 ) && ( values[(j-nheadercols)/2] == 0 ) ) {\n\t  fprintf(stderr,\"Unmatched token pair 0 %s\\n\",token);\n\t  abort();\n\t}\n\telse if ( ( ctoken == 0 ) && ( values[(j-nheadercols)/2] > 0 ) ) {\n\t  fprintf(stderr,\"Unmatched token pair - %d 0\\n\",(int)values[(j-nheadercols)/2]);\n\t  abort();\n\t}\n\tvalues[(j-nheadercols)/2] = (unsigned char)(values[(j-nheadercols)/2]+ctoken);\n      }\n    }\n    token = strtok(NULL, delims);\n  }\n  //fprintf(stderr,\"tokenize-line ended %d %d\\n\",j,nheadercols);\n  if ( (j-nheadercols) % 2 != 0 ) {\n    fprintf(stderr,\"Number of value tokens are not even %d\\n\",j-nheadercols);\n    abort();\n  }\n\n  *p_nvalues = (j-nheadercols)/2;\n  *p_nmiss += nmiss;\n  ++(fhp->nrows);\n\n  if ( j < nheadercols ) {\n    fprintf(stderr,\"Number of header columns are %d, but only %d columns were observed\\n\", nheadercols, j);\n    abort();\n  }\n\n  return values;\n}\n\n// open_file_with_suffix()\n// - [prefix].[suffix] : file name to open\n// - gzflag : gzip flag (use gzfp if gzflag=1, otherwise use fp)\n// - wflag : write flag (1 if write mode otherwise read mode\nstruct HFILE open_file_with_suffix(char* prefix, char* suffix, int gzflag, int wflag) {\n  char filename[SZBUF];\n  sprintf(filename,\"%s.%s\",prefix,suffix);\n  return open_file(filename,gzflag,wflag);\n}\n\n// open_file()\n// - filename : file name to open\n// - gzflag : gzip flag (use gzfp if gzflag=1, otherwise use fp)\n// - wflag : write flag (1 if write mode otherwise read mode)\nstruct HFILE open_file(char* filename, int gzflag, int wflag) {\n  struct HFILE fh;\n  fh.gzflag = gzflag;\n  fh.wflag = wflag;\n  fh.nheadercols = 0;\n  fh.nvaluecols = 0;\n  fh.nrows = 0;\n  if ( gzflag == 1 ) {\n    char* mode = (wflag == 1) ? \"wb\" : \"rb\";\n    fh.gzfp = gzopen(filename,mode);\n    fh.fp = NULL;\n\n    if ( fh.gzfp == NULL ) {\n      emmax_error(\"Cannot open file %s for reading\",filename);\n    }\n  }\n  else {\n    char* mode = (wflag == 1) ? \"w\" : \"r\";\n    fh.gzfp = (gzFile) NULL;\n    fh.fp = fopen(filename,mode);\n\n    if ( fh.fp == NULL ) {\n      emmax_error(\"Cannot open file %s for writing\",filename);\n    }\n  }\n  return fh;\n}\n\nvoid emmax_error( const char* format, ... ) {\n  va_list args;\n  fprintf(stderr, \"ERROR: \");\n  va_start (args, format);\n  vfprintf(stderr, format, args);\n  va_end (args);\n  fprintf(stderr,\"\\n\");\n  abort();\n}\n\nvoid close_file(struct HFILE* fhp) {\n  if ( fhp->gzflag == 1 ) {\n    gzclose(fhp->gzfp);\n    fhp->gzfp = NULL;\n  }\n  else {\n    fclose(fhp->fp);\n    fhp->fp = NULL;\n  }\n}\n\nint main(int argc, char** argv) {\n  int i, j, n, c, ac0, ac1, ac2, nmiss, nelems, nex, n_sum_nin, nin, nex_maf, nex_call_rate, nex_autosomal;\n  int verbose, ndigits, tped_nheadercols, tfam_nheadercols, flag_autosomal, rand_fill_flag, ibs_flag, n_unit_lines;\n  unsigned char *snprow;\n  char *suffix, buf[SZBUF];\n  double f, max_memory_GB, maf_thres, call_rate_thres, aaf, call_rate;\n  //long *fibs_sums, *scores, mean_score;\n  double *kin, *snpunit;\n  char *tpedf, *delims, *lbuf;\n  char **tfam_headers, **tped_headers;\n  struct HFILE tpedh, tfamh, kinsh;\n  struct timeval tv;\n\n  // set default params\n  gettimeofday(&tv, NULL);\n  srand((unsigned int)tv.tv_usec);\n  delims = DEFAULT_DELIMS;\n  tped_nheadercols = DEFAULT_TPED_NUM_HEADER_COLS;\n  tfam_nheadercols = DEFAULT_TFAM_NUM_HEADER_COLS;\n  tped_headers = tfam_headers = NULL;\n  tpedf = lbuf = 0;\n  flag_autosomal = 1;\n  rand_fill_flag = 0;\n  ibs_flag = 0;\n  verbose = 0;\n  ndigits = DEFAULT_NDIGITS;\n  max_memory_GB = 4.0; // 4.0GB\n  maf_thres = 0.0;\n  call_rate_thres = 0.0;\n\n  // read arguments and update params\n  while ((c = getopt(argc, argv, \"d:rsc:vxS:M:m:c:\")) != -1 ) {\n    switch(c) {\n    case 'd': // precision of digits\n      ndigits = atoi(optarg);\n      break;\n    case 'r':\n      rand_fill_flag = 1;\n      break;\n    case 's':\n      ibs_flag = 1;\n      break;\n    case 'v':\n      verbose = 1;\n      break;\n    case 'x':\n      flag_autosomal = 0;\n      break;\n    case 'S':\n      srand(atoi(optarg));\n      break;\n    case 'M':\n      max_memory_GB = atof(optarg);\n      break;\n    case 'm':\n      maf_thres = atof(optarg);\n      break;\n    case 'c':\n      call_rate_thres = atof(optarg);\n      break;\n    default:\n      fprintf(stderr,\"Error : Unknown option unsigned character %c\\n\",c);\n      abort();\n    }\n  }\n\n  // Sanity check for the number of required parameters\n  if ( argc != optind + 1 ) {\n    print_help();\n    abort();\n  }\n\n  // Read required parameters\n  tpedf = argv[optind++];\n\n  if ( verbose) fprintf(stderr,\"\\nReading TFAM file %s.tfam ....\\n\",tpedf);\n\n  tfamh = open_file_with_suffix(tpedf, \"tfam\", 0, 0);\n  //read_matrix_with_col_headers( &tfamh, tfam_nheadercols, delims, 0, &nmiss, NULL, &tfam_headers);\n  read_matrix_with_col_headers( &tfamh, tfam_nheadercols, delims, &nmiss, NULL, &tfam_headers);\n  n = tfamh.nrows; // n is # of individuals\n  if ( verbose ) fprintf(stderr,\"Identified %d individuals from TFAM file\\n\",n);\n\n  // compute the # of lines to read together\n  // we would need two n*n matrix, and n*m matrix\n  // (n*n + n*m)*sizeof(double) < M*1e9 \n  // m < M*1e9/sizeof(double)/n - n\n  n_unit_lines = (int)floor((max_memory_GB * 1.0e9 / sizeof(double) / n - n)/2)*2;\n  n_sum_nin = 0;\n#ifdef INTEL_COMPILER\n  char cn = 'N', ct = 'T';\n  double one = 1.;\n#endif\n  \n  if ( verbose ) fprintf(stderr,\"Setting # unit lines = %d to fit the memory requirement\\n\",n_unit_lines);\n\n  snprow = (unsigned char*)malloc(sizeof(unsigned char)*n);\n  tped_headers = (char**)malloc(sizeof(char*)*n);\n  lbuf = (char*) malloc(sizeof(char*) * SZ_LONG_BUF);\n\n  kin = (double*)calloc(n*n, sizeof(double));\n  snpunit = (double*)malloc(n*n_unit_lines * sizeof(double));\n\n  if ( verbose) fprintf(stderr,\"Reading TPED file %s.tped ....\\n\",tpedf);\n\n  tpedh = open_file_with_suffix(tpedf, \"tped\", 0, 0);\n  tpedh.nheadercols = tped_nheadercols;\n\n  nex_autosomal = nex_maf = nex_call_rate = 0;\n\n  for ( i=0, nin=0, nex = 0; tokenize_tped_line_with_col_headers( &tpedh, tped_nheadercols, delims, lbuf, snprow, tped_headers, &nelems, &nmiss) != NULL; ++i) {\n    if ( ( verbose ) && ( i % 10000 ) == 0 ) fprintf(stderr,\"Reading %d SNPs\\n\",i);\n\n    if ( ( flag_autosomal == 1 ) && ( ( atoi(tped_headers[0]) == 0 ) || ( atoi(tped_headers[0]) > 22 ) ) ) // if SNP is not in autosomal chromosomes\n      //if ( ( flag_autosomal == 1 ) && ( atoi(tped_headers[0]) > 22 ) ) // if SNP is not in autosomal chromosomes\n    {\n      ++nex; // # excluded snps from the last unit\n      ++nex_autosomal;\n      continue;\n    }\n\n    if ( nelems != n ) {\n      emmax_error(\"Number of values %d in line %d do not match to %d, the number of columns\\n\", nelems, tpedh.nvaluecols, n);\n    }\n\n  /*\n    Perform rapid kinship generate IBS, BN, NCOR matrix\n--------------------\nIBS pairwise matrix\n--------------------\ni/j  0  1  2  3\n0    NA NA NA NA\n1    NA 2  1  0 \n2    NA 1  2  1\n3    NA 0  1  2\n\nIn fact is what it does is\nX = (m*n) genotype matrix (1,2,3 coded)\nXn = X-2\nK = (t(Xn) %*% Xn)/(2*m)\n------------------\n* NA column may be just averaged or predicted based on r2 with previous SNP\n  with a certain window size\n\n---------------------\npairwise BN matrix\n--------------------\nX : (m*n) genotype matrix\nXn : (m*n) matrix each row standardized, missing assigned to 0\nK = t(Xn) %*% Xn / L\n--------------------\n*/\n\n    ac0 = ac1 = ac2 = 0;\n    for(j=0; j < n; ++j) {\n      if ( snprow[j] > 0 ) {\n\tif ( snprow[j] < 2 ) {\n\t  fprintf(stderr,\"Invalid snprow[%d] value %d at line %d, individual %d\\n\",j,(int)snprow[j],i,j);\n\t}\n\tsnprow[j] -= 2; // from 2,3,4 to 0,1,2 coding\n\n\tswitch(snprow[j]) {\n\tcase 0:\n\t  ++ac0;\n\t  break;\n\tcase 1:\n\t  ++ac1;\n\t  break;\n\tcase 2:\n\t  ++ac2; \n\t  break;\n\tdefault:\n\t  emmax_error(\"Unknown allele %s, converted to %d\\n\",buf,(int)snprow[j]);\n\t  break;\n\t}\n      }\n      else {\n\tsnprow[j] = (unsigned char)NA_GENO_CHAR;\n      }\n    }\n\n    call_rate = (double)(ac0+ac1+ac2)/(double)n;\n    //fprintf(stderr,\"CallRate = %lf\\n\", call_rate);\n    if ( call_rate <= call_rate_thres ) {\n      ++nex;\n      ++nex_call_rate;\n      continue;\n    }\n    aaf = (double)(ac1+2*ac2)/(double)(2*(ac0+ac1+ac2));\n    if ( ( aaf <= maf_thres ) || ( 1.-aaf <= maf_thres ) ) {\n      ++nex;\n      ++nex_maf;\n      continue;\n    }\n    \n    if ( rand_fill_flag == 1 ) {\n      for(j=0; j < n; ++j) {\n\tif ( snprow[j] == (unsigned char)NA_GENO_CHAR ) {\n\t  if ( (rand() / (double) RAND_MAX) > aaf ) {\n\t    if ( (rand() / (double) RAND_MAX) > aaf ) {\n\t      snprow[j] = (unsigned char)2;\n\t      //ac1 += 2;\n\t      ++ac2;\n\t    }\n\t    else {\n\t      snprow[j] = (unsigned char)1;\n\t      ++ac1;\n\t      //++ac0;\n\t      //++ac1;\n\t    }\n\t  }\n\t  else {\n\t    if ( (rand() / (double) RAND_MAX) > aaf ) {\n\t      snprow[j] = (unsigned char)1;\n\t      ++ac1;\n\t      //++ac0;\n\t      //++ac1;\n\t    }\n\t    else {\n\t      snprow[j] = (unsigned char)0;\n\t      ++ac0;\n\t      //ac0 += 2;\n\t    }\n\t  }\n\t}\n      }\n      aaf = (double)(ac1+2*ac2)/(double)(2*(ac0+ac1+ac2));\n      //aaf = (double)ac1/(double)(ac0+ac1);\n    }\n\n    // copy current values to arrays\n    // Xn = [-1,1] - two rows per SNP : IBS matrix\n    // Xn ~ N(0,1) : BN matrix\n    if ( ibs_flag == 1 ) {\n      for(j=0; j < n; ++j) {\n\tif ( snprow[j] == (unsigned char)NA_GENO_CHAR ) {\n\t  snpunit[nin+  j*n_unit_lines] = 2.*aaf-1.;\n\t  snpunit[nin+1+j*n_unit_lines] = 2.*aaf-1.;\n\t}\n\telse {\n\t  if ( snprow[j] == 0 ) {\n\t    snpunit[nin+  j*n_unit_lines] = -1.;\n\t    snpunit[nin+1+j*n_unit_lines] = -1.;\n\t  }\n\t  else if ( snprow[j] == 1 ) {\n\t    snpunit[nin+  j*n_unit_lines] = 1.;\n\t    snpunit[nin+1+j*n_unit_lines] = -1.;\n\t  }\n\t  else if ( snprow[j] == 2 ) {\n\t    snpunit[nin+  j*n_unit_lines] = 1.;\n\t    snpunit[nin+1+j*n_unit_lines] = 1.;\n\t  }\n\t  else {\n\t    emmax_error(\"Invalid genotype %d\\n\",snprow[j]);\n\t  }\n\t}\n      }\n      nin += 2;\n    }\n    else {\n      for(j=0; j < n; ++j) {\n\tif ( snprow[j] == (unsigned char)NA_GENO_CHAR ) {\n\t    snpunit[nin+j*n_unit_lines] = 0.;\n\t}\n\telse {\n\t  snpunit[nin+j*n_unit_lines] = ((double)snprow[j]-(aaf*2.))/sqrt(4*aaf*(1-aaf));\n\t}\n      }\n      ++nin;\n    }\n    \n    // check if nin == n_unit_lines \n    if ( nin >= n_unit_lines ) {\n      if ( verbose ) {\n\tfprintf(stderr,\"At SNP %d, intermediately computing kinship matrix with %d SNPs..\\n\",i,n_unit_lines);\n      }\n      // kin = kin + t(snpunit)%*%(snpunit)\n#ifdef INTEL_COMPILER\n      dgemm(&ct,&cn,&n,&n,&n_unit_lines,&one,snpunit,&n_unit_lines,snpunit,&n_unit_lines,&one,kin,&n);\n#else\n      cblas_dgemm(CblasColMajor, CblasTrans, CblasNoTrans, n, n, n_unit_lines, 1.0, snpunit, n_unit_lines, snpunit, n_unit_lines, 1.0, kin, n);\n#endif\n      memset(snpunit, 0, sizeof(double)*n_unit_lines*n);\n\n      n_sum_nin += nin;\n      nin = 0;\n    }\n  }\n  close_file(&tpedh);\n\n  if ( verbose ) {\n    fprintf(stderr,\"Succesfully finished reading TPED file\\n\");\n  }\n  if ( nin > 0 ) {\n    if ( verbose ) {\n      fprintf(stderr,\"Computing kinship matrix with the remaining %d SNPs..\\n\",nin);\n    }\n#ifdef INTEL_COMPILER\n    dgemm(&ct,&cn,&n,&n,&n_unit_lines,&one,snpunit,&n_unit_lines,snpunit,&n_unit_lines,&one,kin,&n);\n#else\n    cblas_dgemm(CblasColMajor, CblasTrans, CblasNoTrans, n, n, n_unit_lines, 1.0, snpunit, n_unit_lines, snpunit, n_unit_lines, 1.0, kin, n);\n#endif\n    n_sum_nin += nin;\n  }\n\n  if ( ibs_flag == 1 ) {\n    if ( rand_fill_flag == 1 ) {\n      suffix = \"rIBS.kinf\";\n    }\n    else {\n      suffix = \"aIBS.kinf\";\n    }\n  }\n  else {\n    if ( rand_fill_flag == 1 ) {\n      suffix = \"rBN.kinf\";\n    }\n    else {\n      suffix = \"aBN.kinf\";\n    }\n  }\n  kinsh = open_file_with_suffix( tpedf, suffix, 0, 1 );\n\n\n  if ( verbose ) fprintf(stderr,\"Printing the kinship matrix to file %s.%s\\n\",tpedf,suffix);\n\n  for(i=0; i < n; ++i) {\n    for(j=0; j < n; ++j) {\n      if ( j > 0 ) fprintf(kinsh.fp,\"\\t\");\n      f = (double)kin[i+j*n]/(double)(n_sum_nin);\n      if ( ibs_flag == 1 ) {\n\tfprintf(kinsh.fp,\"%-.*lf\",ndigits,0.5*f+0.5);\n      }\n      else {\n\tfprintf(kinsh.fp,\"%-.*lf\",ndigits,f);  \n      }\n    }\n    fprintf(kinsh.fp,\"\\n\");\n  }\n  close_file(&kinsh);\n  free(snprow);\n  free(kin);\n  free(snpunit);\n  free(lbuf);\n  free(tped_headers);\n  free(tfam_headers);\n  return 0;\n}\n", "meta": {"hexsha": "5e67228a536e4a2fccf07bd7d258d7a3051e3b97", "size": 18320, "ext": "c", "lang": "C", "max_stars_repo_path": "emmax-kin.c", "max_stars_repo_name": "slowkoni/EPI-EMMAX", "max_stars_repo_head_hexsha": "b214b602a8f7f90e13ab4b9ddeba811b67c03a19", "max_stars_repo_licenses": ["Intel"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "emmax-kin.c", "max_issues_repo_name": "slowkoni/EPI-EMMAX", "max_issues_repo_head_hexsha": "b214b602a8f7f90e13ab4b9ddeba811b67c03a19", "max_issues_repo_licenses": ["Intel"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-06-23T09:15:17.000Z", "max_issues_repo_issues_event_max_datetime": "2021-06-23T09:15:17.000Z", "max_forks_repo_path": "emmax-kin.c", "max_forks_repo_name": "slowkoni/EPI-EMMAX", "max_forks_repo_head_hexsha": "b214b602a8f7f90e13ab4b9ddeba811b67c03a19", "max_forks_repo_licenses": ["Intel"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-06-26T15:01:39.000Z", "max_forks_repo_forks_event_max_datetime": "2020-06-26T15:01:39.000Z", "avg_line_length": 29.7402597403, "max_line_length": 185, "alphanum_fraction": 0.6080786026, "num_tokens": 6049, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4378235137849365, "lm_q2_score": 0.03358950504546607, "lm_q1q2_score": 0.014706275125302808}}
{"text": "/*******************************************************************************  *\n*\n*       This file is part of the General Hidden Markov Model Library,\n*       GHMM version __VERSION__, see http://ghmm.org\n*\n*       Filename: ghmm/ghmm/root_finder.c\n*       Authors:  Achim Gaedke\n*\n*       Copyright (C) 1998-2004 Alexander Schliep\n*       Copyright (C) 1998-2001 ZAIK/ZPR, Universitaet zu Koeln\n*       Copyright (C) 2002-2004 Max-Planck-Institut fuer Molekulare Genetik,\n*                               Berlin\n*\n*       Contact: schliep@ghmm.org\n*\n*       This library is free software; you can redistribute it and/or\n*       modify it under the terms of the GNU Library General Public\n*       License as published by the Free Software Foundation; either\n*       version 2 of the License, or (at your option) any later version.\n*\n*       This library is distributed in the hope that it will be useful,\n*       but WITHOUT ANY WARRANTY; without even the implied warranty of\n*       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n*       Library General Public License for more details.\n*\n*       You should have received a copy of the GNU Library General Public\n*       License along with this library; if not, write to the Free\n*       Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n*\n*\n*       This file is version $Revision: 2267 $\n*                       from $Date: 2009-04-24 11:01:58 -0400 (Fri, 24 Apr 2009) $\n*             last change by $Author: grunau $.\n*\n*******************************************************************************/\n\n#ifdef HAVE_CONFIG_H\n#  include \"../config.h\"\n#endif  /*  */\n  \n#ifndef DO_WITH_GSL\n  \n#include <math.h>\n#include <stdio.h>\n#include <stdlib.h>\n\n#include \"ghmm_internals.h\"\n\ndouble ghmm_zbrent_AB (double (*func) (double, double, double, double),\n                   double x1, double x2, double tol, double A, double B,\n                   double eps) \n{\n  fprintf (stderr, \"Function ghmm_zbrent_AB() not implemented!\\n\");\n  exit (1);\n  \n    /*\n       double a, b, c;\n       double fa, fb, fc;\n       \n       a = min(x1, x2);\n       fa = (*func)(a);\n       c = max(x1, x2);\n       fc = (*func)(c);\n       b = (c - a)/2.0;\n       fb = (*func)(b);\n       \n       while (fabs(c - a) > tol + (tol * min(fabs(a), fabs(c))))\n       {\n       r = fb/fc;\n       s = fb/fa;\n       t = fa/fc;\n       p = s * (t * (r - t) * (c - b) - (1.0 - r) * (b - a));\n       q = (t - 1.0) * (r - 1.0) * (s - 1.0);\n       \n       x = b + p/q;\n       \n       if (x > a && x < c)\n       {\n       / * Accept interpolating point * /\n       if (x < b)\n       {\n       c = b;\n       fc = fb;\n       b = x;\n       fb = (*func)(b);\n       }\n       else if (x > b)\n       {\n       a = b;\n       fa = fb;\n       b = x;\n       fb = (*func)(b);\n       }\n       }\n       else\n       {\n       / * Use bisection * /\n       }\n       }\n     */ \n} \n#else   /*  */\n  \n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_roots.h>\n  \n/* struct for function pointer and parameters except 1st one */ \n  struct parameter_wrapper {\n  double (*func) (double, double, double, double);\n   double x2;\n    double x3;\n    double x4;\n } parameter;\n\n/* calls the given function during gsl root solving iteration\n   the first parameter variates, all other are kept constant\n*/ \ndouble function_wrapper (double x, void *p) \n{\n  struct parameter_wrapper *param = (struct parameter_wrapper *) p;\n  return param->func (x, param->x2, param->x3, param->x4);\n}\n\n\n/*\n  this interface is used in sreestimate.c\n */ \ndouble ghmm_zbrent_AB (double (*func) (double, double, double, double), double x1,\n                  double x2, double tol, double A, double B, double eps) \n{\n  \n    /* initialisation of wrapper structure */ \n  struct parameter_wrapper param;\n  gsl_function f;\n  \n#ifdef HAVE_GSL_INTERVAL /* gsl_interval vanished with version 0.9 */\n    gsl_interval x;\n  \n#endif  /*  */\n    gsl_root_fsolver * s;\n  double tolerance;\n  int success = 0;\n  double result = 0;\n  param.func = func;\n  param.x2 = A;\n  param.x3 = B;\n  param.x4 = eps;\n  f.function = &function_wrapper;\n  f.params = (void *) &param;\n  tolerance = tol;\n  \n    /* initialisation */ \n#ifdef HAVE_GSL_INTERVAL\n# ifdef GSL_ROOT_FSLOVER_ALLOC_WITH_ONE_ARG\n    x.lower = x1;\n  x.upper = x2;\n  s = gsl_root_fsolver_alloc (gsl_root_fsolver_brent);\n  gsl_root_fsolver_set (s, &f, x);\n  \n# else\n    s = gsl_root_fsolver_alloc (gsl_root_fsolver_brent, &f, x);\n  \n# endif\n#else   /* gsl_interval vanished with version 0.9 */\n    s = gsl_root_fsolver_alloc (gsl_root_fsolver_brent);\n  gsl_root_fsolver_set (s, &f, x1, x2);\n  \n#endif  /*  */\n    \n    /* iteration */ \n    do {\n    success = gsl_root_fsolver_iterate (s);\n    if (success == GSL_SUCCESS)\n       {\n      \n#ifdef HAVE_GSL_INTERVAL\n        gsl_interval new_x;\n      new_x = gsl_root_fsolver_interval (s);\n      success = gsl_root_test_interval (new_x, tolerance, tolerance);\n      \n#else   /* gsl_interval vanished with version 0.9 */\n      double x_up;\n      double x_low;\n      (void) gsl_root_fsolver_iterate (s);\n      x_up = gsl_root_fsolver_x_upper (s);\n      x_low = gsl_root_fsolver_x_lower (s);\n      success = gsl_root_test_interval (x_low, x_up, tolerance, tolerance);\n      \n#endif  /*  */\n      }\n  } while (success == GSL_CONTINUE);\n  \n    /* result */ \n    if (success != GSL_SUCCESS)\n     {\n    gsl_error (\"solver failed\", __FILE__, __LINE__, success);\n    }\n  \n  else\n     {\n    result = gsl_root_fsolver_root (s);\n    }\n  \n    /* destruction */ \n    gsl_root_fsolver_free (s);\n  return result;\n}\n\n\n#endif  /*  */\n\n", "meta": {"hexsha": "1f1a39c6a8a15ba660e688cd78818ceab46fb116", "size": 5577, "ext": "c", "lang": "C", "max_stars_repo_path": "Trash/sandbox/hmm/ghmm-0.9-rc3/ghmm/root_finder.c", "max_stars_repo_name": "ruslankuzmin/julia", "max_stars_repo_head_hexsha": "2ad5bfb9c9684b1c800e96732a9e2f1e844b856f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 7.0, "max_stars_repo_stars_event_min_datetime": "2017-03-13T17:32:26.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-27T16:51:22.000Z", "max_issues_repo_path": "Trash/sandbox/hmm/ghmm-0.9-rc3/ghmm/root_finder.c", "max_issues_repo_name": "ruslankuzmin/julia", "max_issues_repo_head_hexsha": "2ad5bfb9c9684b1c800e96732a9e2f1e844b856f", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-05-29T19:54:02.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-29T19:54:52.000Z", "max_forks_repo_path": "Trash/sandbox/hmm/ghmm-0.9-rc3/ghmm/root_finder.c", "max_forks_repo_name": "ruslankuzmin/julia", "max_forks_repo_head_hexsha": "2ad5bfb9c9684b1c800e96732a9e2f1e844b856f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 25.0, "max_forks_repo_forks_event_min_datetime": "2016-10-18T03:31:44.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-29T13:23:10.000Z", "avg_line_length": 26.3066037736, "max_line_length": 83, "alphanum_fraction": 0.5664335664, "num_tokens": 1548, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.39233683016710835, "lm_q2_score": 0.03676946383261257, "lm_q1q2_score": 0.014426014887031352}}
{"text": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <iniparser.h>\n#include \"prepmt/prepmt_hudson96.h\"\n#ifdef PARMT_USE_INTEL\n#include <mkl_cblas.h>\n#else\n#include <cblas.h>\n#endif\n#include \"cps.h\"\n#include \"iscl/array/array.h\"\n#include \"iscl/fft/fft.h\"\n#include \"iscl/memory/memory.h\"\n#include \"iscl/os/os.h\"\n\n/*!\n * @brief Reads the ini file for Computer Programs in Seismology hudson96\n *        forward modeling variables.\n *\n * @param[in] iniFile    Name of ini file.\n * @param[in] section    Section of ini file to read.\n *\n * @param[out] parms     The hudson96 parameters.\n *\n * @result 0 indicates success.\n *\n * @author Ben Baker, ISTI\n *\n */\nint prepmt_hudson96_readHudson96Parameters(const char *iniFile,\n                                           const char *section,\n                                           struct hudson96_parms_struct *parms)\n{\n    const char *s;\n    char vname[256];\n    dictionary *ini;\n    //------------------------------------------------------------------------//\n    cps_setHudson96Defaults(parms);\n    if (!os_path_isfile(iniFile))\n    {\n        fprintf(stderr, \"%s: ini file: %s does not exist\\n\", __func__, iniFile);\n        return -1;\n    }\n    ini = iniparser_load(iniFile);\n    if (ini == NULL)\n    {\n        fprintf(stderr, \"%s: Cannot parse ini file\\n\", __func__);\n        return -1;\n    }\n    // Teleseismic model\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:modeltel\", section);\n    s = iniparser_getstring(ini, vname, NULL);\n    if (s != NULL)\n    {\n        strcpy(parms->modeltel, s);\n    }\n    else\n    {\n        strcpy(parms->modeltel, \"tak135sph.mod\\0\");\n    }\n    // Receiver model\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:modelrec\", section);\n    s = iniparser_getstring(ini, vname, NULL);\n    if (s != NULL)\n    {\n        strcpy(parms->modelrec, s);\n    }\n    else\n    {\n        strcpy(parms->modelrec, parms->modelrec);\n    }\n    // Source model\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:modelsrc\", section);\n    s = iniparser_getstring(ini, vname, NULL);\n    if (s != NULL)\n    {\n        strcpy(parms->modelsrc, s);\n    }\n    else\n    {\n        strcpy(parms->modelsrc, parms->modelsrc);\n    }\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:hs\", section);\n    parms->hs = iniparser_getdouble(ini, vname, 0.0);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:dt\", section);\n    parms->dt = iniparser_getdouble(ini, vname, 1.0);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:npts\", section);\n    parms->npts = iniparser_getint(ini, vname, 1024);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:gcarc\", section);\n    parms->gcarc = iniparser_getdouble(ini, vname, 50.0);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:offset\", section);\n    parms->offset = iniparser_getdouble(ini, vname, 10.0);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:dosrc\", section);\n    parms->dosrc = iniparser_getboolean(ini, vname, 1);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:dorec\", section);\n    parms->dorec = iniparser_getboolean(ini, vname, 1);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:dotel\", section);\n    parms->dotel = iniparser_getboolean(ini, vname, 1);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:dop\", section);\n    parms->dop = iniparser_getboolean(ini, vname, 1);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:dokjar\", section);\n    parms->dokjar = iniparser_getboolean(ini, vname, 1);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:loffsetdefault\", section);\n    parms->loffsetdefault = iniparser_getboolean(ini, vname, 1);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:verbose\", section);\n    parms->verbose = iniparser_getboolean(ini, vname, 0);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:utstar\", section);\n    parms->utstar = iniparser_getdouble(ini, vname, -12345.0);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:dottonly\", section);\n    parms->dottonly = iniparser_getboolean(ini, vname, 0);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:zsrc\", section);\n    parms->zsrc = iniparser_getdouble(ini, vname, 100.0);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:zrec\", section);\n    parms->zrec = iniparser_getdouble(ini, vname, 60.0);\n    // Free ini dictionary\n    iniparser_freedict(ini);\n    return 0;\n}\n//============================================================================//\n/*!\n * @brief Computes the fundamental fault Green's functions for the teleseismic\n *        body waves with hudson96.\n *\n * @param[in] nobs            Number of observations.\n * @param[in] obs             Observations with source location and\n *                            receiver location.  This is an array of length\n *                            nobs.\n * @param[in] luseCrust1      If true then use crust1.0 models at source\n *                            and receiver.\n * @param[in] crust1Dir       If luseCrust1 is true then this is the name\n *                            of the crust1.0 directory.  If NULL and \n *                            luseCrust1 is used then it will default to\n *                            libcps configuration.\n * @param[in] luseSrcModel    If true then use the local source velocity\n *                            at the source.  This supersedes the crust1.0\n *                            source velocity if it is defined.\n * @param[in] sourceModel     If luseSrcModel is true then this is the name\n *                            of the CPS style source model to read.\n *\n * @param[out] telmod         Holds the teleseismic model (ak135).\n * @param[out] srcmod         Holds the local source model.\n * @param[in,out] recmod      On input contains sufficient space and should\n *                            be an array of length nobs.\n *                            On output holds the receiver models.\n *\n * @param[out] ierr           0 indicates success.\n *\n * @author Ben Baker, ISTI\n *\n * @bug I need better handling of the offset.\n *\n */\nint hudson96_getModels(const int nobs, const struct sacData_struct *obs,\n                       const bool luseCrust1, const char *crust1Dir,\n                       const bool luseSrcModel, const char *sourceModel,\n                       struct vmodel_struct *telmod,\n                       struct vmodel_struct *srcmod, \n                       struct vmodel_struct *recmod)\n{\n    double *lats, *lons, evla, evlo;\n    int ierr, iobs;\n    ierr = 0;\n    // Set the teleseismic model\n    memset(srcmod, 0, sizeof(struct vmodel_struct));\n    memset(telmod, 0, sizeof(struct vmodel_struct));\n    cps_globalModel_ak135f(telmod);\n    if (luseCrust1)\n    {\n        fprintf(stdout, \"%s: Reading crust1.0...\\n\", __func__);\n        lats = memory_calloc64f(nobs);\n        lons = memory_calloc64f(nobs);\n        ierr = sacio_getFloatHeader(SAC_FLOAT_EVLA, obs[0].header, &evla);\n        if (ierr != 0)\n        {\n            fprintf(stderr, \"%s: Error - evla not set\\n\", __func__);\n            return ierr;\n        }\n        ierr = sacio_getFloatHeader(SAC_FLOAT_EVLO, obs[0].header, &evlo);\n        if (ierr != 0)\n        {\n            fprintf(stderr, \"%s: Error - evlo not set\\n\", __func__);\n            return ierr;\n        }\n        for (iobs=0; iobs<nobs; iobs++)\n        {\n            sacio_getFloatHeader(SAC_FLOAT_STLA, obs[iobs].header,\n                                 &lats[iobs]);\n            sacio_getFloatHeader(SAC_FLOAT_STLO, obs[iobs].header,\n                                 &lons[iobs]);\n        }\n        ierr = cps_crust1_getCrust1ForHerrmann(crust1Dir, false,\n                                               evla, evlo,\n                                               lats, lons,\n                                               nobs,\n                                               srcmod, recmod);\n        if (ierr != 0)\n        {\n            fprintf(stderr, \"%s: Failed to load crust1.0 model\\n\", __func__);\n            return ierr;\n        }\n        memory_free64f(&lats);\n        memory_free64f(&lons);\n    }\n    // Use teleseismic model for receiver model\n    else\n    {\n        fprintf(stdout, \"%s: Setting receiver models to teleseismic model\\n\",\n                __func__);\n        for (iobs=0; iobs<nobs; iobs++)\n        {\n            cps_utils_copyVmodelStruct(*telmod, &recmod[iobs]);\n        }\n    }\n    // Use source model\n    if (luseSrcModel)\n    {\n        fprintf(stdout, \"%s: Using source model: %s\\n\", __func__, sourceModel);\n        cps_utils_freeVmodelStruct(srcmod);\n        ierr = cps_getmod(sourceModel, srcmod);\n        if (ierr != 0)\n        {\n            fprintf(stderr, \"%s: Error loading srcmod\\n\", __func__);\n            return ierr;\n        }\n    }\n    fprintf(stdout, \"%s: Computing Green's functions...\\n\", __func__);\n    // Otherwise source to teleseismic model\n    if (!luseSrcModel && !luseCrust1)\n    {\n        fprintf(stdout, \"%s: Setting source model to teleseismic model\\n\",\n                __func__);\n        cps_utils_copyVmodelStruct(*telmod, srcmod);\n    }\n    return 0;\n}\n//============================================================================//\n/*!\n * @brief Computes the fundamental fault Green's functions for the teleseismic\n *        body waves with hudson96.\n *\n * @param[in] hudson96Parms   hudson96 forward modeling parameters.\n * @param[in] hpulse96Parms   hpulse96 forward modeling parameters.\n * @param[in] telmod          Holds the teleseismic model (ak135).\n * @param[in] srcmod          Holds the local source model.\n * @param[in] recmod          Holds each receiver model.\n *                            This is an array of dimension [nobs].\n * @param[in] ntstar          Number of t*'s in grid.\n * @param[in] tstars          Array of dimension [ntstar] with the attenuation\n *                            factors.\n * @param[in] ndepth          Number of source depths in grid.\n * @param[in] depths          Array of dimension [ndepth] with the source\n *                            depths specified in (km).\n * @param[in] nobs            Number of observations.\n * @param[in] obs             Observed waveforms which contain the receiver\n *                            locations, components of motion, first\n *                            arrival time, sampling period, and number of\n *                            points in waveform.\n *\n * @param[out] ierr           0 indicates success.\n *\n * @author Ben Baker, ISTI\n *\n * @bug I need better handling of the offset.\n *\n */\nstruct sacData_struct *prepmt_hudson96_computeGreensFF(\n    const struct hudson96_parms_struct hudson96Parms,\n    const struct hpulse96_parms_struct hpulse96Parms,\n    const struct vmodel_struct telmod,\n    const struct vmodel_struct srcmod,\n    const struct vmodel_struct *recmod,\n    const int ntstar, const double *__restrict__ tstars,\n    const int ndepth, const double *__restrict__ depths,\n    const int nobs, const struct sacData_struct *obs, int *ierr)\n{\n    struct hudson96_parms_struct hudson96ParmsWork;\n    struct hpulse96_parms_struct hpulse96ParmsWork;\n    struct hpulse96_data_struct zresp;\n    struct sacData_struct *sacFFGrns;\n    struct hwave_greens_struct *ffGrns;\n    char sncl[64], phaseName[8];\n    double *dptr, cmpaz, cmpinc, dt, gcarc, offset0,\n           pickTime, xnorm;\n    int i, idep, ierrAll, ierr1, ierr2, indx, iobs, iobs0, ip, it,\n        factor, kndx, nloop, npts;\n    bool lzero[10], lfound, lsh;\n    enum isclError_enum isclError;\n    const enum sacHeader_enum pickVars[11]\n       = {SAC_FLOAT_A,\n          SAC_FLOAT_T0, SAC_FLOAT_T1, SAC_FLOAT_T2, SAC_FLOAT_T3,\n          SAC_FLOAT_T4, SAC_FLOAT_T5, SAC_FLOAT_T6, SAC_FLOAT_T7,\n          SAC_FLOAT_T8, SAC_FLOAT_T9};\n    const enum sacHeader_enum pickTypes[11]\n       = {SAC_CHAR_KA,\n          SAC_CHAR_KT0, SAC_CHAR_KT1, SAC_CHAR_KT2, SAC_CHAR_KT3,\n          SAC_CHAR_KT4, SAC_CHAR_KT5, SAC_CHAR_KT6, SAC_CHAR_KT7,\n          SAC_CHAR_KT8, SAC_CHAR_KT9};\n    // Here's the idea: I want to input magnitudes with units of N-m so:\n    // N-m -> Dyne-dm (1.e+7)\n    // CPS internally scales from Dyne-cm to cm (1.e+20)\n    // Finally, I want outputs proprotional to m (1.e-2)\n    const double xmom = 1.0;     // no confusing `relative' magnitudes \n    const double xcps = 1.e-20;  // convert dyne-cm mt to output cm\n    const double cm2m = 1.e-2;   // cm to meters\n    const double dcm2nm = 1.e+7; // magnitudes intended to be specified in\n                                 // Dyne-cm but I work in N-m\n    // Given a M0 in Newton-meters get a seismogram in meters\n    const double xscal = xmom*xcps*cm2m*dcm2nm;\n    const char *cfaults[10] = {\"ZDS\\0\", \"ZSS\\0\", \"ZDD\", \"ZEX\\0\",\n                               \"RDS\\0\", \"RSS\\0\", \"RDD\", \"REX\\0\",\n                               \"TDS\\0\", \"TSS\\0\"};\n    const int npTypes = 11;\n    const int nrDist = 1;\n    const int nrDepths = 1;\n    const int nsDepths = 1;\n    //------------------------------------------------------------------------//\n    //\n    // Quick error checks \n    *ierr = 0;\n    sacFFGrns = NULL;\n    if (nobs < 1 || obs == NULL ||\n        ntstar < 1 || tstars == NULL ||\n        ndepth < 1 || depths == NULL)\n    {\n        *ierr = 1;\n        if (nobs < 1){fprintf(stderr, \"%s: Error no observations\\n\", __func__);}\n        if (obs == NULL){fprintf(stderr, \"%s: Error obs is NULL\\n\", __func__);}\n        if (ntstar < 1){fprintf(stderr, \"%s: Error no t*'s\\n\", __func__);}\n        if (tstars == NULL)\n        {\n            fprintf(stderr, \"%s: Error tstars is NULL\\n\", __func__);\n        }\n        if (ndepth < 1){fprintf(stderr, \"%s: Error no depths\\n\", __func__);}\n        if (depths == NULL)\n        {\n            fprintf(stderr, \"%s: Error depths is NULL\\n\", __func__);\n        }\n        return sacFFGrns;\n    }\n    // Set the modeling structures\n    memset(&hudson96ParmsWork, 0, sizeof(struct hudson96_parms_struct));\n    memset(&hpulse96ParmsWork, 0, sizeof(struct hpulse96_parms_struct));\n    cps_setHudson96Defaults(&hudson96ParmsWork);\n    cps_setHpulse96Defaults(&hpulse96ParmsWork);\n    cps_utils_copyHudson96ParmsStruct(hudson96Parms, &hudson96ParmsWork);\n    cps_utils_copyHpulse96ParmsStruct(hpulse96Parms, &hpulse96ParmsWork);\n    offset0 = hudson96Parms.offset;\n    // Set space for output\n    nloop = nobs*ndepth*ntstar;\n    sacFFGrns = (struct sacData_struct *)\n                 calloc((size_t) (10*nloop), sizeof(struct sacData_struct));\n    // Loop on the distances, depths, t*'s and compute greens functions\n    iobs0 =-1;\n    ierrAll = 0;\n    for (indx=0; indx<nloop; indx++)\n    {\n        ffGrns = NULL;\n        // Convert 3D grid into loop indices (i->n1 is fast; k->n3 is slow)\n        *ierr = prepmt_hudson96_grd2ijk(indx,\n                                        ntstar, ndepth, nobs,\n                                        &it, &idep, &iobs);\n        if (*ierr != 0)\n        {\n            fprintf(stderr, \"%s: Failed to convert to grid\\n\", __func__);\n            break;\n        }\n        // New observation (station) -> may need to update velocity model\n        if (iobs != iobs0)\n        {\n            iobs0 = iobs;\n        }\n        *ierr = sacio_getFloatHeader(SAC_FLOAT_DELTA,\n                                     obs[iobs].header, &dt);\n        if (*ierr != 0)\n        {\n            fprintf(stderr, \"%s: Could not get sampling period\\n\", __func__);\n            break;\n        }\n        *ierr = sacio_getFloatHeader(SAC_FLOAT_GCARC,\n                                     obs[iobs].header, &gcarc);\n        if (*ierr != 0)\n        {\n            fprintf(stderr, \"%s: Could not get gcarc\\n\", __func__);\n            break;\n        }\n        *ierr = sacio_getIntegerHeader(SAC_INT_NPTS,\n                                       obs[iobs].header, &npts);\n        if (*ierr != 0)\n        {\n            fprintf(stderr, \"%s: Could not get npts\\n\", __func__);\n            break;\n        }\n        // Tie waveform modeling to first pick type \n        lfound = false;\n        hudson96ParmsWork.dop = true;\n        for (ip=0; ip<npTypes; ip++)\n        {\n            ierr1 = sacio_getCharacterHeader(pickTypes[ip],\n                                             obs[iobs].header, phaseName);\n            ierr2 = sacio_getFloatHeader(pickVars[ip], \n                                         obs[iobs].header, &pickTime);\n            if (ierr1 == 0 && ierr2 == 0)\n            {\n                lfound = true;\n                if (strncasecmp(phaseName, \"P\", 1) == 0)\n                {\n                    hudson96ParmsWork.dop = true;\n                }\n                else if (strncasecmp(phaseName, \"S\", 1) == 0)\n                {\n                    hudson96ParmsWork.dop = false;\n                }\n                else\n                {\n                    fprintf(stderr, \"%s: Can't classify phase: %s\\n\",\n                            __func__, phaseName);\n                    lfound = false;\n                }\n                break;\n            }\n        }\n        if (!lfound)\n        {\n            fprintf(stdout, \"%s: No pick available - won't be able to align\\n\",\n                    __func__);\n            continue;\n        }\n        memset(&zresp, 0, sizeof(struct hpulse96_data_struct));\n        hudson96ParmsWork.hs = depths[idep];\n        hudson96ParmsWork.dt = dt;\n        hudson96ParmsWork.gcarc = gcarc;\n        hudson96ParmsWork.utstar = tstars[it];\n        factor = 2;\n        if (hudson96ParmsWork.dt < 0.1){factor = 4;}\n        hudson96ParmsWork.npts = MAX(256,\n                                     MIN(2048,\n                                         factor*fft_nextpow2(MAX(1, npts), ierr)));\n        hudson96ParmsWork.offset = fmin(pickTime, offset0); //TODO: fmin or fmax?\n//printf(\"%s %f\\n\", phaseName, pickTime);\n        // Try to pad this out a little\n        hudson96ParmsWork.offset = fmax(hudson96ParmsWork.offset,\n                                  (double) (hudson96ParmsWork.npts - 1)*dt*0.2);\n//        printf(\"%e %d\\n\", hudson96ParmsWork.offset/dt, npts);\n/*\n        if (pickTime < hudson96ParmsWork.offset)\n        {\n            hudson96ParmsWork.offset = (double) (int) (pickTime/dt + 0.5)*dt;\n        }\n*/\n        zresp = hudson96_interface(hudson96ParmsWork,\n                                   telmod, recmod[iobs], srcmod, ierr);\n        if (*ierr != 0)\n        {\n            fprintf(stderr, \"%s: Error calling hudson96\\n\", __func__);\n            ierrAll = ierrAll + 1;\n            goto NEXT_OBS;\n        }\n        ffGrns = hpulse96_interface(nrDist, nrDepths, nsDepths,\n                                    hpulse96ParmsWork,\n                                    &zresp, ierr);\n        if (*ierr != 0)\n        {\n            fprintf(stderr, \"%s: Error calling hpulse96 interface\\n\", __func__);\n            ierrAll = ierrAll + 1;\n            goto NEXT_OBS;\n        }\n        // Set the fundamental fault Green's functions\n        for (i=0; i<10; i++)\n        {\n            dptr = NULL;\n            lsh = false;\n            lzero[i] = false;\n            if (i == 0)\n            {\n                dptr = ffGrns->zds;\n            }\n            else if (i == 1)\n            {\n                dptr = ffGrns->zss;\n            }\n            else if (i == 2)\n            {\n                dptr = ffGrns->zdd;\n            }\n            else if (i == 3)\n            {\n                dptr = ffGrns->zex;\n            }\n            else if (i == 4)\n            {\n                dptr = ffGrns->rds;\n                cmpinc = 90.0;\n            }\n            else if (i == 5)\n            {\n                dptr = ffGrns->rss;\n                cmpinc = 90.0;\n            }\n            else if (i == 6)\n            {\n                dptr = ffGrns->rdd;\n                cmpinc = 90.0;\n            }\n            else if (i == 7)\n            {\n                dptr = ffGrns->rex;\n                cmpinc = 90.0;\n            }\n            else if (i == 8)\n            {\n                dptr = ffGrns->tds;\n                lsh = true;\n                cmpaz = 90.0;\n                cmpinc = 90.0;\n            }\n            else if (i == 9)\n            {\n                dptr = ffGrns->tss;\n                lsh = true;\n                cmpaz = 90.0;\n                cmpinc = 90.0;\n            }\n            kndx = indx*10 + i;\n            sacio_setDefaultHeader(&sacFFGrns[kndx].header);\n            sacFFGrns[kndx].header.lhaveHeader = true;\n            sacio_setIntegerHeader(SAC_INT_NPTS, ffGrns->npts,\n                                   &sacFFGrns[kndx].header);\n            sacio_setIntegerHeader(SAC_INT_NZYEAR, 1970,\n                                   &sacFFGrns[kndx].header);\n            sacio_setIntegerHeader(SAC_INT_NZJDAY, 1,\n                                   &sacFFGrns[kndx].header);\n            sacio_setIntegerHeader(SAC_INT_NZHOUR, 0,\n                                   &sacFFGrns[kndx].header);\n            sacio_setIntegerHeader(SAC_INT_NZMIN, 0,\n                                   &sacFFGrns[kndx].header);\n            sacio_setIntegerHeader(SAC_INT_NZSEC, 0,\n                                   &sacFFGrns[kndx].header);\n            sacio_setIntegerHeader(SAC_INT_NZMSEC, 0,\n                                   &sacFFGrns[kndx].header);\n            sacio_setBooleanHeader(SAC_BOOL_LCALDA, false,\n                                   &sacFFGrns[kndx].header);\n            sacio_setFloatHeader(SAC_FLOAT_DELTA, ffGrns->dt,\n                                 &sacFFGrns[kndx].header);\n            sacio_setFloatHeader(SAC_FLOAT_GCARC, ffGrns->dist/111.195,\n                                 &sacFFGrns[kndx].header);\n            sacio_setFloatHeader(SAC_FLOAT_DIST, ffGrns->dist,\n                                 &sacFFGrns[kndx].header);\n            sacio_setFloatHeader(SAC_FLOAT_EVDP, depths[idep],\n                                 &sacFFGrns[kndx].header);\n            sacio_setFloatHeader(SAC_FLOAT_STEL, ffGrns->stelel,\n                                 &sacFFGrns[kndx].header); \n            sacio_setFloatHeader(SAC_FLOAT_AZ,  0.0,\n                                 &sacFFGrns[kndx].header);\n            sacio_setFloatHeader(SAC_FLOAT_BAZ, 180.0,\n                                 &sacFFGrns[kndx].header);\n            sacio_setFloatHeader(SAC_FLOAT_O, -ffGrns->t0, \n                                 &sacFFGrns[kndx].header); \n            sacio_setFloatHeader(SAC_FLOAT_B, ffGrns->t0,\n                                 &sacFFGrns[kndx].header);\n            sacio_setFloatHeader(SAC_FLOAT_CMPAZ, cmpaz,\n                                 &sacFFGrns[kndx].header);\n            sacio_setFloatHeader(SAC_FLOAT_CMPINC, cmpinc,\n                                 &sacFFGrns[kndx].header);\n            if (hudson96ParmsWork.dop)\n            {\n                sacio_setFloatHeader(SAC_FLOAT_A, ffGrns->timep,\n                                     &sacFFGrns[kndx].header);\n                sacio_setCharacterHeader(SAC_CHAR_KA, \"P\",\n                                         &sacFFGrns[kndx].header);\n            }\n            else\n            {\n                if (!lsh)\n                {\n                    sacio_setFloatHeader(SAC_FLOAT_A, ffGrns->timesv,\n                                         &sacFFGrns[kndx].header);\n                }\n                else\n                {\n                    sacio_setFloatHeader(SAC_FLOAT_A, ffGrns->timesh,\n                                         &sacFFGrns[kndx].header);\n                }\n                sacio_setCharacterHeader(SAC_CHAR_KA, \"S\",\n                                         &sacFFGrns[kndx].header);\n            }\n            sacio_setCharacterHeader(SAC_CHAR_KO, \"O\\0\",\n                                     &sacFFGrns[kndx].header);\n            sacio_setCharacterHeader(SAC_CHAR_KEVNM, \"SYNTHETIC\\0\",\n                                     &sacFFGrns[kndx].header);\n            sacio_setCharacterHeader(SAC_CHAR_KCMPNM, cfaults[i],\n                                     &sacFFGrns[kndx].header);\n            sacFFGrns[kndx].npts = ffGrns->npts;\n            sacFFGrns[kndx].data = sacio_malloc64f(ffGrns->npts);\n            if (dptr != NULL)\n            {\n                array_copy64f_work(ffGrns->npts, dptr, sacFFGrns[kndx].data);\n            }\n            else\n            {\n                array_set64f_work(ffGrns->npts, 0.0, sacFFGrns[kndx].data);\n            }\n            xnorm = cblas_dnrm2(sacFFGrns[kndx].npts, sacFFGrns[kndx].data, 1);\n            if (xnorm == 0.0){lzero[i] = true;}\n            // Handle scaling\n            cblas_dscal(sacFFGrns[kndx].npts, xscal, sacFFGrns[kndx].data, 1);\n            dptr = NULL;\n        } // Loop on fundamnetal faults\n        if (array_sum8l(10, lzero, &isclError) == 10)\n        {\n            memset(sncl, 0, 64*sizeof(char));\n            sprintf(sncl, \"%s.%s.%s.%s\",\n                    obs[iobs].header.knetwk, obs[iobs].header.kstnm, \n                    obs[iobs].header.kcmpnm, obs[iobs].header.khole);\n            fprintf(stdout,\n                    \"%s: Warning Greens fn %s w/ npts %d at gcarc=%e is zero\\n\",\n                    __func__, sncl, hudson96ParmsWork.npts, gcarc);\n        }\nNEXT_OBS:;\n        if (ffGrns != NULL)\n        {\n            cps_utils_freeHwaveGreensStruct(ffGrns);\n            free(ffGrns);\n        }\n        cps_utils_freeHpulse96DataStruct(&zresp);\n    }\n    return sacFFGrns;\n}\n//============================================================================//\n/*!\n * @brief Converts a 1D index to 3D grid indices:\n *\n *        Changes:\n *        for (igrd=0; igrd<n1*n2*n3; igrd++)\n *        {\n *\n *        }\n *        To: \n *        for (k=0; k<n3; k++)\n *        {\n *            for (j=0; j<n2; j++)\n *            {\n *                for (i=0; i<n1; i++)\n *                {\n *                    igrd = k*n2*n1 + j*n1 + i;\n *                }\n *            }\n *        }\n *\n * @param[in] igrd  Flattened C numbered grid index: igrd = k*n2*n1 + j*n1 + i.\n * @param[in] n1    This is the fastest loop iterator (innermost loop).\n * @param[in] n2    This is the middle loop iterator (intermediate loop).\n * @param[in] n3    This is the slowest loop iterator (outermost loop).\n * @param[out] i    C index in inner loop [0,n1).\n * @param[out] j    C index in intermediate loop [0,n2).\n * @param[out] k    C index in outermost loop [0,n3).\n *\n * @result 0 indicates success.\n *\n */\nint prepmt_hudson96_grd2ijk(const int igrd,\n                            const int n1, const int n2, const int n3,\n                            int *i, int *j, int *k) \n{\n    int ierr, n12;\n    ierr = 0;\n    n12 = n1*n2;\n    *k = (igrd)/n12;\n    *j = (igrd - *k*n12)/n1;\n    *i =  igrd - *k*n12 - *j*n1;\n    if (*i < 0 || *i > n1 - 1){ierr = ierr + 1;}\n    if (*j < 0 || *j > n2 - 1){ierr = ierr + 1;} \n    if (*k < 0 || *k > n3 - 1){ierr = ierr + 1;} \n    return ierr; \n}\n//============================================================================//\n/*!\n * @brief Maps the observation, depth, and t* to the global index.\n *\n * @param[in] ndepth    Number of depths.\n * @param[in] ntstar    Number of t*'s.\n * @param[in] iobs      C indexed observation number [0,nobs-1]\n * @param[in] idep      C indexed depth number [0,ndepth-1]\n * @param[in] it        C indexed t* number [0,ntstar-1]\n *\n * @result If >= 0 then this (iobs, idep, it) index in the Green's functions\n *         table.\n * \n * @author Ben Baker, ISTI\n *\n */\nint prepmt_hudson96_observationDepthTstarToIndex(\n    const int ndepth, const int ntstar,\n    const int iobs, const int idep, const int it)\n{\n    int indx;\n    indx = iobs*ntstar*ndepth + idep*ntstar + it;\n    return indx;\n}\n", "meta": {"hexsha": "ab7dabd404e7d7606c1c65b466a545bf216b887b", "size": 27566, "ext": "c", "lang": "C", "max_stars_repo_path": "prepmt/hudson96.c", "max_stars_repo_name": "bakerb845/parmt", "max_stars_repo_head_hexsha": "2b4097df02ef5e56407d40e821d5c7155c2e4416", "max_stars_repo_licenses": ["Intel"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "prepmt/hudson96.c", "max_issues_repo_name": "bakerb845/parmt", "max_issues_repo_head_hexsha": "2b4097df02ef5e56407d40e821d5c7155c2e4416", "max_issues_repo_licenses": ["Intel"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "prepmt/hudson96.c", "max_forks_repo_name": "bakerb845/parmt", "max_forks_repo_head_hexsha": "2b4097df02ef5e56407d40e821d5c7155c2e4416", "max_forks_repo_licenses": ["Intel"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.5558583106, "max_line_length": 83, "alphanum_fraction": 0.5168686063, "num_tokens": 7388, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.2909808785120009, "lm_q2_score": 0.04885778312321277, "lm_q1q2_score": 0.014216680655341261}}
{"text": "/* monte/gsl_monte_vegas.h\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Michael Booth\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* header for the gsl \"vegas\" routines.  Mike Booth, May 1998 */\n\n#ifndef __GSL_MONTE_VEGAS_H__\n#define __GSL_MONTE_VEGAS_H__\n\n#include <gsl/gsl_rng.h>\n#include <gsl/gsl_monte.h>\n\n#undef __BEGIN_DECLS\n#undef __END_DECLS\n#ifdef __cplusplus\n# define __BEGIN_DECLS extern \"C\" {\n# define __END_DECLS }\n#else\n# define __BEGIN_DECLS /* empty */\n# define __END_DECLS /* empty */\n#endif\n\n__BEGIN_DECLS\n\nenum {GSL_VEGAS_MODE_IMPORTANCE = 1, \n      GSL_VEGAS_MODE_IMPORTANCE_ONLY = 0, \n      GSL_VEGAS_MODE_STRATIFIED = -1};\n\ntypedef struct {\n  /* grid */\n  size_t dim;\n  size_t bins_max;\n  unsigned int bins;\n  unsigned int boxes; /* these are both counted along the axes */\n  double * xi;\n  double * xin;\n  double * delx;\n  double * weight;\n  double vol;\n\n  double * x;\n  int * bin;\n  int * box;\n  \n  /* distribution */\n  double * d;\n\n  /* control variables */\n  double alpha;\n  int mode;\n  int verbose;\n  unsigned int iterations;\n  int stage;\n\n  /* scratch variables preserved between calls to vegas1/2/3  */\n  double jac;\n  double wtd_int_sum; \n  double sum_wgts;\n  double chi_sum;\n  double chisq;\n\n  double result;\n  double sigma;\n\n  unsigned int it_start;\n  unsigned int it_num;\n  unsigned int samples;\n  unsigned int calls_per_box;\n\n  FILE * ostream;\n\n} gsl_monte_vegas_state;\n\nint gsl_monte_vegas_integrate(gsl_monte_function * f, \n                              double xl[], double xu[], \n                              size_t dim, size_t calls,\n                              gsl_rng * r,\n                              gsl_monte_vegas_state *state,\n                              double* result, double* abserr);\n\ngsl_monte_vegas_state* gsl_monte_vegas_alloc(size_t dim);\n\nint gsl_monte_vegas_init(gsl_monte_vegas_state* state);\n\nvoid gsl_monte_vegas_free (gsl_monte_vegas_state* state);\n\n__END_DECLS\n\n#endif /* __GSL_MONTE_VEGAS_H__ */\n\n", "meta": {"hexsha": "b328307e1e879ea026548bd82d77fc9852a8887a", "size": 2654, "ext": "h", "lang": "C", "max_stars_repo_path": "pkgs/libs/gsl/src/monte/gsl_monte_vegas.h", "max_stars_repo_name": "manggoguy/parsec-modified", "max_stars_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 64.0, "max_stars_repo_stars_event_min_datetime": "2015-03-06T00:30:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T13:26:53.000Z", "max_issues_repo_path": "pkgs/libs/gsl/src/monte/gsl_monte_vegas.h", "max_issues_repo_name": "manggoguy/parsec-modified", "max_issues_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2020-12-15T08:30:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-13T03:54:24.000Z", "max_forks_repo_path": "pkgs/libs/gsl/src/monte/gsl_monte_vegas.h", "max_forks_repo_name": "manggoguy/parsec-modified", "max_forks_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 40.0, "max_forks_repo_forks_event_min_datetime": "2015-02-26T15:31:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T23:23:37.000Z", "avg_line_length": 25.0377358491, "max_line_length": 81, "alphanum_fraction": 0.6868877167, "num_tokens": 699, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3738758227716966, "lm_q2_score": 0.03789242690123016, "lm_q1q2_score": 0.014167062284513797}}
{"text": "#include <stdlib.h>\n#include <stdio.h>\n#include <math.h>\n#include <string.h>\n#include <sys/stat.h>\n#include <sys/time.h>\n#include <gsl/gsl_rng.h>\n#include <gsl/gsl_randist.h>\n#include <Accelerate/Accelerate.h>\n\n#include \"infmcmc.h\"\n\n#define nj1 32\n#define nk1 32\n\nvoid infmcmc_initChain(INFCHAIN *C, const int nj, const int nk) {\n  const int maxk      = (nk >> 1) + 1;\n  const int sspectral = sizeof(fftw_complex) * nj * maxk;\n  const int sphysical = sizeof(double      ) * nj * nk;\n  //const int obsVecMem = sizeof(double      ) * sizeObsVector;\n  FILE *fp;\n  unsigned long int seed;\n  \n  // Set up variables\n  C->nj = nj;\n  C->nk = nk;\n  //C->sizeObsVector = sizeObsVector;\n  C->currentIter = 0;\n  C->accepted = 0;\n  C->_shortTimeAccProbAvg = 0.0;\n  C->_bLow = 0.0;\n  C->_bHigh = 1.0;\n  \n  // Allocate a ton of memory\n  C->currentPhysicalState      = (double *)malloc(sphysical);\n  C->avgPhysicalState          = (double *)malloc(sphysical);\n  C->varPhysicalState          = (double *)malloc(sphysical);\n  C->proposedPhysicalState     = (double *)malloc(sphysical);\n  C->_M2                       = (double *)malloc(sphysical);\n  //C->currentStateObservations  = (double *)malloc(obsVecMem);\n  //C->proposedStateObservations = (double *)malloc(obsVecMem);\n  //C->data                      = (double *)malloc(obsVecMem);\n  \n  C->currentSpectralState  = (fftw_complex *)fftw_malloc(sspectral);\n  C->avgSpectralState      = (fftw_complex *)fftw_malloc(sspectral);\n  C->priorDraw             = (fftw_complex *)fftw_malloc(sspectral);\n  C->proposedSpectralState = (fftw_complex *)fftw_malloc(sspectral);\n  \n  memset(C->currentPhysicalState,  0, sphysical);\n  memset(C->avgPhysicalState,      0, sphysical);\n  memset(C->varPhysicalState,      0, sphysical);\n  memset(C->proposedPhysicalState, 0, sphysical);\n  memset(C->_M2,                   0, sphysical);\n  memset(C->currentSpectralState,  0, sspectral);\n  memset(C->avgSpectralState,      0, sspectral);\n  memset(C->proposedSpectralState, 0, sspectral);\n  \n  C->accProb = 0.0;\n  C->avgAccProb = 0.0;\n  C->logLHDCurrentState = 0.0;\n  \n  /*\n   * Set some default values\n   */\n  C->alphaPrior = 3.0;\n  C->rwmhStepSize = 1e-4;\n  C->priorVar = 1.0;\n  C->priorStd = 1.0;\n  \n  C->r = gsl_rng_alloc(gsl_rng_taus2);\n  \n  fp = fopen(\"/dev/urandom\", \"rb\");\n  \n  if (fp != NULL) {\n    fread(&seed, sizeof(unsigned long int), 1, fp);\n    gsl_rng_set(C->r, seed);\n    fclose(fp);\n    printf(\"Using random seed\\n\");\n  }\n  else {\n    gsl_rng_set(C->r, 0);\n    printf(\"Using zero seed\\n\");\n  }\n  \n  C->_c2r = fftw_plan_dft_c2r_2d(nj, nk, C->proposedSpectralState, C->proposedPhysicalState, FFTW_MEASURE);\n  C->_r2c = fftw_plan_dft_r2c_2d(nj, nk, C->currentPhysicalState, C->currentSpectralState, FFTW_MEASURE);\n}\n\nvoid infmcmc_freeChain(INFCHAIN *C) {\n  // Free all allocated memory used by the chain\n  free(C->currentPhysicalState);\n  free(C->avgPhysicalState);\n  free(C->varPhysicalState);\n  free(C->proposedPhysicalState);\n  free(C->_M2);\n  //free(C->currentStateObservations);\n  //free(C->proposedStateObservations);\n  \n  fftw_free(C->currentSpectralState);\n  fftw_free(C->avgSpectralState);\n  fftw_free(C->priorDraw);\n  fftw_free(C->proposedSpectralState);\n  \n  gsl_rng_free(C->r);\n}\n\nvoid infmcmc_resetChain(INFCHAIN *C) {\n  infmcmc_freeChain(C);\n  infmcmc_initChain(C, C->nj, C->nk);\n}\n\nvoid infmcmc_writeChain(const INFCHAIN *C, FILE *fp) {\n  const int s = C->nj * C->nk;\n  \n  fwrite(&(C->nj),                 sizeof(int),    1,         fp);\n  fwrite(&(C->nk),                 sizeof(int),    1,         fp);\n  fwrite(&(C->currentIter),        sizeof(int),    1,         fp);\n  fwrite(C->currentPhysicalState,  sizeof(double), s,         fp);\n  fwrite(C->avgPhysicalState,      sizeof(double), s,         fp);\n  fwrite(C->varPhysicalState,      sizeof(double), s,         fp);\n  fwrite(&(C->logLHDCurrentState), sizeof(double), 1,         fp);\n  fwrite(&(C->accProb),            sizeof(double), 1,         fp);\n  fwrite(&(C->avgAccProb),         sizeof(double), 1,         fp);\n}\n\nvoid infmcmc_writeChainInfo(const INFCHAIN *C, FILE *fp) {\n  fwrite(&(C->nj),             sizeof(int), 1, fp);\n  fwrite(&(C->nk),             sizeof(int), 1, fp);\n}\n\nvoid infmcmc_writeVFChain(const INFCHAIN *U, const INFCHAIN *V, FILE *fp) {\n  const int s = U->nj * U->nk;\n  \n  fwrite(U->currentPhysicalState,  sizeof(double), s,         fp);\n  fwrite(U->avgPhysicalState,      sizeof(double), s,         fp);\n  fwrite(U->varPhysicalState,      sizeof(double), s,         fp);\n  fwrite(V->currentPhysicalState,  sizeof(double), s,         fp);\n  fwrite(V->avgPhysicalState,      sizeof(double), s,         fp);\n  fwrite(V->varPhysicalState,      sizeof(double), s,         fp);\n  fwrite(&(U->logLHDCurrentState), sizeof(double), 1,         fp);\n  fwrite(&(U->accProb),            sizeof(double), 1,         fp);\n  fwrite(&(U->avgAccProb),         sizeof(double), 1,         fp);\n}\n\nvoid infmcmc_printChain(INFCHAIN *C) {\n  printf(\"Iteration %d\\n\", C->currentIter);\n  printf(\"-- Length is         %d x %d\\n\", C->nj, C->nk);\n  printf(\"-- llhd val is       %lf\\n\", C->logLHDCurrentState);\n  printf(\"-- Acc. prob is      %.10lf\\n\", C->accProb);\n  printf(\"-- Avg. acc. prob is %.10lf\\n\", C->avgAccProb);\n  printf(\"-- Beta is           %.10lf\\n\\n\", C->rwmhStepSize);\n  //finmcmc_printCurrentState(C);\n  //finmcmc_printAvgState(C);\n  //finmcmc_printVarState(C);\n}\n\nvoid randomPriorDraw(INFCHAIN *C) {\n  int j, k;\n  const int maxk = (C->nk >> 1) + 1;\n  const int nko2 = C->nk >> 1;\n  const int njo2 = C->nj >> 1;\n  double xrand, yrand, c;\n  //const double one = 1.0;\n  \n  c = 4.0 * M_PI * M_PI;\n  \n  for(j = 0; j < C->nj; j++) {\n    for(k = 0; k < maxk; k++) {\n      xrand = gsl_ran_gaussian_ziggurat(C->r, C->priorStd);\n      if((j == 0) && (k == 0)) {\n        C->priorDraw[0] = 0.0;\n      }\n      else if((j == njo2) && (k == nko2)) {\n        C->priorDraw[maxk*njo2+nko2] = /*C->nj */ xrand / pow(c * ((j * j) + (k * k)), (double)C->alphaPrior/2.0);\n      }\n      else if((j == 0) && (k == nko2)) {\n        C->priorDraw[nko2] = /*C->nj */ xrand / pow(c * ((j * j) + (k * k)), (double)C->alphaPrior/2.0);\n      }\n      else if((j == njo2) && (k == 0)) {\n        C->priorDraw[maxk*njo2] = /*C->nj */ xrand / pow(c * ((j * j) + (k * k)), (double)C->alphaPrior/2.0);\n      }\n      else {\n        xrand /= sqrt(2.0);\n        yrand = gsl_ran_gaussian_ziggurat(C->r, C->priorStd) / sqrt(2.0);\n        C->priorDraw[maxk*j+k] = /*C->nj */ (xrand + I * yrand) / pow(c * ((j * j) + (k * k)), (double)C->alphaPrior/2.0);\n        if(j > njo2) {\n          C->priorDraw[maxk*j+k] = conj(C->priorDraw[maxk*(C->nj-j)+k]);\n        }\n      }\n    }\n  }\n}\n\nvoid randomDivFreePriorDraw(INFCHAIN *C1, INFCHAIN *C2) {\n  int j, k;\n  const int maxk = (C1->nk >> 1) + 1;\n  const int njo2 = C2->nj >> 1;\n  const int nko2 = C1->nk >> 1;\n  double modk;\n  \n  randomPriorDraw(C1);\n  \n  for (j = 0; j < C1->nj; j++) {\n    for (k = 0; k < maxk; k++) {\n      if (j == 0 && k == 0) {\n        C1->priorDraw[0] = 0.0;\n        C2->priorDraw[0] = 0.0;\n        continue;\n      }\n      \n      modk = sqrt(j * j + k * k);\n      if (j < njo2) {\n        C2->priorDraw[maxk*j+k] = -j * C1->priorDraw[maxk*j+k] / modk;\n      }\n      else if (j > njo2) {\n        C2->priorDraw[maxk*j+k] = -(j - C1->nj) * C1->priorDraw[maxk*j+k] / modk;\n      }\n      else {\n        C2->priorDraw[maxk*j+k] = 0.0;\n      }\n      \n      if (k < nko2) {\n        C1->priorDraw[maxk*j+k] *= k / modk;\n      }\n      else {\n        C1->priorDraw[maxk*j+k] = 0.0;\n      }\n    }\n  }\n}\n\nvoid infmcmc_seedWithPriorDraw(INFCHAIN *C) {\n  const int size = sizeof(fftw_complex) * C->nj * ((C->nk >> 1) + 1);\n  fftw_complex *uk = (fftw_complex *)fftw_malloc(size);\n  const fftw_plan p = fftw_plan_dft_c2r_2d(C->nj, C->nk, uk, C->currentPhysicalState, FFTW_ESTIMATE);\n  \n  randomPriorDraw(C);\n  memcpy(uk, C->priorDraw, size);\n  \n  //fixme: put into current spectral state\n  \n  fftw_execute(p);\n  fftw_destroy_plan(p);\n  fftw_free(uk);\n}\n\nvoid infmcmc_seedWithDivFreePriorDraw(INFCHAIN *C1, INFCHAIN *C2) {\n  const int size = sizeof(fftw_complex) * C1->nj * ((C1->nk >> 1) + 1);\n  fftw_complex *uk = (fftw_complex *)fftw_malloc(size);\n  const fftw_plan p = fftw_plan_dft_c2r_2d(C1->nj, C1->nk, uk, C1->currentPhysicalState, FFTW_ESTIMATE);\n  \n  randomDivFreePriorDraw(C1, C2);\n  \n  memcpy(uk, C1->priorDraw, size);\n  fftw_execute_dft_c2r(p, uk, C1->currentPhysicalState);\n  \n  memcpy(uk, C2->priorDraw, size);\n  fftw_execute_dft_c2r(p, uk, C2->currentPhysicalState);\n  \n  memcpy(C1->currentSpectralState, C1->priorDraw, size);\n  memcpy(C2->currentSpectralState, C2->priorDraw, size);\n  \n  fftw_destroy_plan(p);\n  fftw_free(uk);\n}\n\nvoid infmcmc_proposeRWMH(INFCHAIN *C) {\n  int j, k;\n  const int maxk = (C->nk >> 1) + 1;\n  const int N = C->nj * C->nk;\n  const double sqrtOneMinusBeta2 = sqrt(1.0 - C->rwmhStepSize * C->rwmhStepSize);\n  double *u = (double *)malloc(sizeof(double) * C->nj * C->nk);\n  fftw_complex *uk = (fftw_complex *)fftw_malloc(sizeof(fftw_complex) * C->nj * maxk);\n  \n  memcpy(u, C->currentPhysicalState, sizeof(double) * C->nj * C->nk);\n  fftw_execute_dft_r2c(C->_r2c, u, C->currentSpectralState);\n  \n  // Draw from prior distribution\n  randomPriorDraw(C);\n  \n  for(j = 0; j < C->nj; j++) {\n    for(k = 0; k < maxk; k++) {\n      C->proposedSpectralState[maxk*j+k] = sqrtOneMinusBeta2 * C->currentSpectralState[maxk*j+k] + C->rwmhStepSize * C->priorDraw[maxk*j+k];\n      C->proposedSpectralState[maxk*j+k] /= N;\n    }\n  }\n  \n  memcpy(uk, C->proposedSpectralState, sizeof(fftw_complex) * C->nj * maxk);\n  fftw_execute_dft_c2r(C->_c2r, uk, C->proposedPhysicalState);\n  fftw_free(uk);\n  free(u);\n}\n\nvoid infmcmc_adaptRWMHStepSize(INFCHAIN *C, double inc) {\n  // Adapt to stay in 20-30% range.\n  int adaptFreq = 100;\n  double rate;\n  \n  if (C->currentIter > 0 && C->currentIter % adaptFreq == 0) {\n    rate = (double) C->_shortTimeAccProbAvg / adaptFreq;\n    \n    if (rate < 0.2) {\n      //C->_bHigh = C->rwmhStepSize;\n      //C->rwmhStepSize = (C->_bLow + C->_bHigh) / 2.0;\n      C->rwmhStepSize -= inc;\n    }\n    else if (rate > 0.3) {\n      //C->_bLow = C->rwmhStepSize;\n      //C->rwmhStepSize = (C->_bLow + C->_bHigh) / 2.0;\n      C->rwmhStepSize += inc;\n    }\n    \n    C->_shortTimeAccProbAvg = 0.0;\n  }\n  else {\n    C->_shortTimeAccProbAvg += C->accProb;\n  }\n}\n\nvoid infmcmc_proposeDivFreeRWMH(INFCHAIN *C1, INFCHAIN *C2) {\n  int j, k;\n  const int maxk = (C1->nk >> 1) + 1;\n  const int N = C1->nj * C1->nk;\n  const double sqrtOneMinusBeta2 = sqrt(1.0 - C1->rwmhStepSize * C1->rwmhStepSize);\n  double *u = (double *)malloc(sizeof(double) * C1->nj * C1->nk);\n  fftw_complex *uk = (fftw_complex *)fftw_malloc(sizeof(fftw_complex) * C1->nj * maxk);\n  \n  memcpy(u, C1->currentPhysicalState, sizeof(double) * C1->nj * C1->nk);\n  fftw_execute_dft_r2c(C1->_r2c, u, C1->currentSpectralState);\n  \n  memcpy(u, C2->currentPhysicalState, sizeof(double) * C2->nj * C2->nk);\n  fftw_execute_dft_r2c(C2->_r2c, u, C2->currentSpectralState);\n    \n  // Draw from prior distribution\n  randomDivFreePriorDraw(C1, C2);\n  \n  for(j = 0; j < C1->nj; j++) {\n    for(k = 0; k < maxk; k++) {\n      C1->currentSpectralState[maxk*j+k] /= N;\n      C2->currentSpectralState[maxk*j+k] /= N;\n      C1->proposedSpectralState[maxk*j+k] = sqrtOneMinusBeta2 * C1->currentSpectralState[maxk*j+k] + C1->rwmhStepSize * C1->priorDraw[maxk*j+k];\n      //C1->proposedSpectralState[maxk*j+k] /= N;\n      C2->proposedSpectralState[maxk*j+k] = sqrtOneMinusBeta2 * C2->currentSpectralState[maxk*j+k] + C2->rwmhStepSize * C2->priorDraw[maxk*j+k];\n      //C2->proposedSpectralState[maxk*j+k] /= N;\n    }\n  }\n  \n  memcpy(uk, C1->proposedSpectralState, sizeof(fftw_complex) * C1->nj * maxk);\n  fftw_execute_dft_c2r(C1->_c2r, uk, C1->proposedPhysicalState);\n  memcpy(uk, C2->proposedSpectralState, sizeof(fftw_complex) * C1->nj * maxk);\n  fftw_execute_dft_c2r(C2->_c2r, uk, C2->proposedPhysicalState);\n  \n  fftw_free(uk);\n  free(u);\n}\n\nvoid infmcmc_updateAvgs(INFCHAIN *C) {\n  int j, k;\n  double deltar;\n  fftw_complex deltac;\n  C->currentIter++;\n  \n  /*\n   Update physical vectors\n   */\n  if (C->currentIter == 1) {\n    for (j = 0; j < C->nj; j++) {\n      for (k = 0; k < C->nk; k++) {\n        deltar = C->currentPhysicalState[C->nk * j + k] - C->avgPhysicalState[C->nk * j + k];\n        C->avgPhysicalState[C->nk * j + k] += (deltar / C->currentIter);\n        C->_M2[C->nk * j + k] += (deltar * (C->currentPhysicalState[C->nk * j + k] - C->avgPhysicalState[C->nk * j + k]));\n        C->varPhysicalState[C->nk * j + k] = -1.0;\n      }\n    }\n  }\n  else {\n    for (j = 0; j < C->nj; j++) {\n      for (k = 0; k < C->nk; k++) {\n        deltar = C->currentPhysicalState[C->nk * j + k] - C->avgPhysicalState[C->nk * j + k];\n        C->avgPhysicalState[C->nk * j + k] += (deltar / C->currentIter);\n        C->_M2[C->nk * j + k] += (deltar * (C->currentPhysicalState[C->nk * j + k] - C->avgPhysicalState[C->nk * j + k]));\n        C->varPhysicalState[C->nk * j + k] = C->_M2[C->nk * j + k] / (C->currentIter - 1);\n      }\n    }\n  }\n  \n  /*\n   Update spectral vectors\n  */\n  if (C->currentIter == 1) {\n    for (j = 0; j < C->nj; j++) {\n      for (k = 0; k < C->nk/2 + 1; k++) {\n        deltac = C->currentSpectralState[(C->nk/2 + 1) * j + k] - C->avgSpectralState[(C->nk/2 + 1) * j + k];\n        C->avgSpectralState[(C->nk/2 + 1) * j + k] += (deltac / C->currentIter);\n      }\n    }\n  }\n  else {\n    for (j = 0; j < C->nj; j++) {\n      for (k = 0; k < C->nk/2 + 1; k++) {\n        deltac = C->currentSpectralState[(C->nk/2 + 1) * j + k] - C->avgSpectralState[(C->nk/2 + 1) * j + k];\n        C->avgSpectralState[(C->nk/2 + 1) * j + k] += (deltac / C->currentIter);\n      }\n    }\n  }\n  \n  /*\n   Update scalars\n   */\n  C->avgAccProb += ((C->accProb - C->avgAccProb) / C->currentIter);\n}\n\nvoid infmcmc_updateRWMH(INFCHAIN *C, double logLHDOfProposal) {\n  double alpha;\n  \n  alpha = exp(C->logLHDCurrentState - logLHDOfProposal);\n  \n  if (alpha > 1.0) {\n    alpha = 1.0;\n  }\n  // fixme: set acc prob here instead\n  if (gsl_rng_uniform(C->r) < alpha) {\n    memcpy(C->currentSpectralState, C->proposedSpectralState, sizeof(fftw_complex) * C->nj * ((C->nk >> 1) + 1));\n    memcpy(C->currentPhysicalState, C->proposedPhysicalState, sizeof(double) * C->nj * C->nk);\n    C->accProb = alpha;\n    C->logLHDCurrentState = logLHDOfProposal;\n  }\n  \n  infmcmc_updateAvgs(C);\n}\n\nvoid infmcmc_updateVectorFieldRWMH(INFCHAIN *C1, INFCHAIN *C2, double logLHDOfProposal) {\n  double alpha;\n  \n  // log likelihoods will be the same for both chains\n\talpha = exp(C1->logLHDCurrentState - logLHDOfProposal);\n\t\n  if (alpha > 1.0) {\n    alpha = 1.0;\n  }\n  \n  C1->accepted = 0;\n  C2->accepted = 0;\n  C1->accProb = alpha;\n  C2->accProb = alpha;\n  \n  if (gsl_rng_uniform(C1->r) < alpha) {\n    C1->accepted = 1;\n    C2->accepted = 1;\n    memcpy(C1->currentSpectralState, C1->proposedSpectralState, sizeof(fftw_complex) * C1->nj * ((C1->nk >> 1) + 1));\n    memcpy(C1->currentPhysicalState, C1->proposedPhysicalState, sizeof(double) * C1->nj * C1->nk);\n    C1->logLHDCurrentState = logLHDOfProposal;\n    memcpy(C2->currentSpectralState, C2->proposedSpectralState, sizeof(fftw_complex) * C2->nj * ((C2->nk >> 1) + 1));\n    memcpy(C2->currentPhysicalState, C2->proposedPhysicalState, sizeof(double) * C2->nj * C2->nk);\n    C2->logLHDCurrentState = logLHDOfProposal;\n  }\n  \n  infmcmc_updateAvgs(C1);\n  infmcmc_updateAvgs(C2);\n}\n\nvoid infmcmc_setRWMHStepSize(INFCHAIN *C, double beta) {\n  C->rwmhStepSize = beta;\n}\n\nvoid infmcmc_setPriorAlpha(INFCHAIN *C, double alpha) {\n  C->alphaPrior = alpha;\n}\n\nvoid infmcmc_setPriorVar(INFCHAIN *C, double var) {\n  C->priorVar = var;\n  C->priorStd = sqrt(var);\n}\n\ndouble L2Field(fftw_complex *uk, int nj, int nk) {\n  int j, k;\n  const int maxk = (nk >> 1) + 1;\n  double sum = 0.0;\n  \n  for (j = 0; j < nj; j++) {\n    for (k = 0; k < maxk; k++) {\n      sum += cabs(uk[maxk*j+k]) * cabs(uk[maxk*j+k]);\n    }\n  }\n  \n  return 2.0 * sum;\n}\n\ndouble infmcmc_L2Current(INFCHAIN *C) {\n  return L2Field(C->currentSpectralState, C->nj, C->nk);\n}\n\ndouble infmcmc_L2Proposed(INFCHAIN *C) {\n  return L2Field(C->proposedSpectralState, C->nj, C->nk);\n}\n\ndouble infmcmc_L2Prior(INFCHAIN *C) {\n  return L2Field(C->priorDraw, C->nj, C->nk);\n}\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nvoid randomPriorDrawOLD(gsl_rng *r, double PRIOR_ALPHA, fftw_complex *randDrawCoeffs) {\n  int j, k;\n  double xrand, yrand, c;//, scale;\n  //const double one = 1.0;\n  \n  c = 4.0 * M_PI * M_PI;\n  \n  for(j = 0; j < nj1; j++) {\n    for(k = 0; k < nk1/2 + 1; k++) {\n      if((j == 0) && (k == 0)) {\n        randDrawCoeffs[0] = 0.0;\n      }\n      else if((j == nj1/2) && (k == nk1/2)) {\n        xrand = gsl_ran_gaussian_ziggurat(r, 1.0);\n        randDrawCoeffs[(nk1/2 + 1) * nj1/2 + nk1/2] = xrand / pow((c * ((j * j) + (k * k))), (double)PRIOR_ALPHA/2.0);\n      }\n      else if((j == 0) && (k == nk1/2)) {\n        xrand = gsl_ran_gaussian_ziggurat(r, 1.0);\n        randDrawCoeffs[nk1/2] = xrand / pow((c * ((j * j) + (k * k))), (double)PRIOR_ALPHA/2.0);\n      }\n      else if((j == nj1/2) && (k == 0)) {\n        xrand = gsl_ran_gaussian_ziggurat(r, 1.0);\n        randDrawCoeffs[(nk1/2 + 1) * nj1/2] = xrand / pow((c * ((j * j) + (k * k))), (double)PRIOR_ALPHA/2.0);\n      }\n      else {\n        xrand = gsl_ran_gaussian_ziggurat(r, 1.0) / sqrt(2.0);\n        yrand = gsl_ran_gaussian_ziggurat(r, 1.0) / sqrt(2.0);\n        randDrawCoeffs[(nk1/2 + 1) * j + k] = (xrand + I * yrand) / pow((c * ((j * j) + (k * k))), (double)PRIOR_ALPHA/2.0);\n        if(j > nj1/2) {\n          randDrawCoeffs[(nk1/2 + 1) * j + k] = conj(randDrawCoeffs[(nk1/2+1)*(nj1-j)+k]);\n        }\n      }\n    }\n  }\n  \n  /*\n  for(j = 1; j < nj1 / 2; j++) {\n    for(k = 0; k < nk1 / 2 + 1; k++) {\n      xrand = gsl_ran_gaussian_ziggurat(r, 1.0) / M_SQRT2;\n      yrand = gsl_ran_gaussian_ziggurat(r, 1.0) / M_SQRT2;\n      scale = pow(c * ((j * j) + (k * k)), (double)PRIOR_ALPHA/2.0);\n      randDrawCoeffs[(nk1/2 + 1) * j + k] = (xrand + I * yrand) / scale;\n      randDrawCoeffs[(nk1/2 + 1) * (nj1-j) + k] = (xrand - I * yrand) / scale;\n    }\n  }\n  \n  for(k = 1; k < nk1 / 2 + 1; k++) {\n    xrand = gsl_ran_gaussian_ziggurat(r, 1.0) / M_SQRT2;\n    randDrawCoeffs[k] = (xrand + I * yrand) / pow(c * (k * k), (double)PRIOR_ALPHA/2.0);\n  }\n  \n  for(k = 0; k < nk1/2; k++) {\n    xrand = gsl_ran_gaussian_ziggurat(r, 1.0) / M_SQRT2;\n    randDrawCoeffs[(nk1/2+1)*(nj1/2)+k] = (xrand + I * yrand) / pow(c * ((nj1 * nj1 / 4) + (k * k)), (double)PRIOR_ALPHA/2.0);\n  }\n  \n  randDrawCoeffs[0] = 0.0;\n  \n  xrand = gsl_ran_gaussian_ziggurat(r, 1.0);\n  randDrawCoeffs[(nk1/2+1)*(nj1/2)+(nk1/2)] = xrand / pow(c * ((j * j) + (k * k)), (double)PRIOR_ALPHA/2.0);\n  */\n}\n\nvoid setRWMHStepSize(CHAIN *C, double stepSize) {\n  C->rwmhStepSize = stepSize;\n}\n\nvoid resetAvgs(CHAIN *C) {\n  /*\n    Sets avgPhysicalState to currentPhysicalState and\n         avgSpectralState to currentSpectralState\n  */\n  const size_t size_doublenj = sizeof(double) * C->nj;\n  memcpy(C->avgPhysicalState, C->currentPhysicalState, size_doublenj * C->nk);\n  memcpy(C->avgSpectralState, C->currentSpectralState, size_doublenj * ((C->nk >> 1) + 1));\n}\n\nvoid resetVar(CHAIN *C) {\n  // Sets varPhysicalState to 0\n  memset(C->varPhysicalState, 0, sizeof(double) * C->nj * C->nk);\n}\n\nvoid proposeIndependence(CHAIN *C) {\n  const int maxk = (C->nk >> 1) + 1;\n  \n  memcpy(C->proposedSpectralState, C->priorDraw, sizeof(fftw_complex) * C->nj * maxk);\n}\n\ndouble lsqFunctional(const double * const data, const double * const obsVec, const int obsVecSize, const double obsStdDev) {\n  int i;\n  double temp1, sum1 = 0.0;\n  \n  for(i = 0; i < obsVecSize; i++) {\n    temp1 = (data[i] - obsVec[i]);\n    sum1 += temp1 * temp1;\n  }\n  \n  return sum1 / (2.0 * obsStdDev * obsStdDev);\n}\n\nvoid acceptReject(CHAIN *C) {\n  const double phi1 = lsqFunctional(C->data, C->currentStateObservations, C->sizeObsVector, C->obsStdDev);\n  const double phi2 = lsqFunctional(C->data, C->proposedStateObservations, C->sizeObsVector, C->obsStdDev);\n  double tempAccProb = exp(phi1 - phi2);\n  \n  if(tempAccProb > 1.0) {\n    tempAccProb = 1.0;\n  }\n  \n  if(gsl_rng_uniform(C->r) < tempAccProb) {\n    memcpy(C->currentSpectralState, C->proposedSpectralState, sizeof(fftw_complex) * C->nj * ((C->nk >> 1) + 1));\n    memcpy(C->currentPhysicalState, C->proposedPhysicalState, sizeof(double) * C->nj * C->nk);\n    memcpy(C->currentStateObservations, C->proposedStateObservations, sizeof(double) * C->sizeObsVector);\n    \n    C->accProb = tempAccProb;\n    C->currentLSQFunctional = phi2;\n  }\n  else {\n    C->currentLSQFunctional = phi1;\n  }\n}\n\n//\n//void updateChain(CHAIN *C) {\n//C->currentIter++;\n//void updateAvgs(CHAIN *C);\n//void updateVar(CHAIN *C);\n/*\nint main(void) {\n  int nj = 32, nk = 32, sizeObsVector = 0;\n  unsigned long int randseed = 0;\n  \n  FILE *fp;\n  CHAIN *C;\n  \n  C = (CHAIN *)malloc(sizeof(CHAIN));\n  \n  initChain(C, nj, nk, sizeObsVector, randseed);\n  \n  randomPriorDraw2(C);\n  \n  fp = fopen(\"2.dat\", \"w\");\n  fwrite(C->priorDraw, sizeof(fftw_complex), nj * (nk / 2 + 1), fp);\n  fclose(fp);\n  \n  return 0;\n}\n*/\n", "meta": {"hexsha": "b59756ab4ab54757e990c3d111b85c761083bf7e", "size": 21045, "ext": "c", "lang": "C", "max_stars_repo_path": "mcmclib/infmcmc.c", "max_stars_repo_name": "dmcdougall/mcmclib", "max_stars_repo_head_hexsha": "b745c933203c52732a5daac12e84f52d7af13266", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2015-11-21T22:02:58.000Z", "max_stars_repo_stars_event_max_datetime": "2015-11-21T22:02:58.000Z", "max_issues_repo_path": "mcmclib/infmcmc.c", "max_issues_repo_name": "dmcdougall/mcmclib", "max_issues_repo_head_hexsha": "b745c933203c52732a5daac12e84f52d7af13266", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "mcmclib/infmcmc.c", "max_forks_repo_name": "dmcdougall/mcmclib", "max_forks_repo_head_hexsha": "b745c933203c52732a5daac12e84f52d7af13266", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.9941089838, "max_line_length": 144, "alphanum_fraction": 0.5901164172, "num_tokens": 7589, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4882833952958347, "lm_q2_score": 0.028436035926617798, "lm_q1q2_score": 0.013884844171003276}}
{"text": "/**\n * \\author Sylvain Marsat, University of Maryland - NASA GSFC\n *\n * \\brief C header for functions computing coeffcients of Not-A-Knot and Quadratic splines in matrix form.\n *\n */\n\n#ifndef _FRESNEL_H\n#define _FRESNEL_H\n\n#define _XOPEN_SOURCE 500\n\n#ifdef __GNUC__\n#define UNUSED __attribute__ ((unused))\n#else\n#define UNUSED\n#endif\n\n#include <stdio.h>\n#include <stdlib.h>\n#include <math.h>\n#include <complex.h>\n#include <time.h>\n#include <unistd.h>\n#include <getopt.h>\n#include <stdbool.h>\n#include <string.h>\n\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_bspline.h>\n#include <gsl/gsl_blas.h>\n#include <gsl/gsl_min.h>\n#include <gsl/gsl_spline.h>\n#include <gsl/gsl_complex.h>\n\n#include \"constants.h\"\n#include \"struct.h\"\n\n\n#if defined(__cplusplus)\n#define complex _Complex\nextern \"C\" {\n#elif 0\n} /* so that editors will match preceding brace */\n#endif\n\ndouble complex ComputeInt(\n  gsl_matrix* splinecoeffsAreal,         /*  */\n  gsl_matrix* splinecoeffsAimag,         /*  */\n  gsl_matrix* splinecoeffsphase);        /*  */\n\ndouble complex ComputeIntCase1a(\n  const double complex* coeffsA,         /* */\n  const double p1,                       /* */\n  const double p2,                       /* */\n  const double scale);                   /* */\ndouble complex ComputeIntCase1b(\n  const double complex* coeffsA,         /* */\n  const double p1,                       /* */\n  const double p2,                       /* */\n  const double scale);                   /* */\ndouble complex ComputeIntCase2(\n  const double complex* coeffsA,         /* */\n  const double p1,                       /* */\n  const double p2);                      /* */\ndouble complex ComputeIntCase3(\n  const double complex* coeffsA,         /* */\n  const double p1,                       /* */\n  const double p2);                      /* */\ndouble complex ComputeIntCase4(\n  const double complex* coeffsA,         /* */\n  const double p1,                       /* */\n  const double p2);                      /* */\n\n\n#if 0\n{ /* so that editors will match succeeding brace */\n#elif defined(__cplusplus)\n}\n#endif\n\n#endif /* _FRESNEL_H */\n", "meta": {"hexsha": "af0862b0fe9deb21faebc2fd49603e81ec81f59e", "size": 2107, "ext": "h", "lang": "C", "max_stars_repo_path": "tools/fresnel.h", "max_stars_repo_name": "titodalcanton/flare", "max_stars_repo_head_hexsha": "4ffb02977d19786ab8c1a767cc495a799d9575ae", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2015-05-26T15:21:13.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-20T02:56:25.000Z", "max_issues_repo_path": "tools/fresnel.h", "max_issues_repo_name": "titodalcanton/flare", "max_issues_repo_head_hexsha": "4ffb02977d19786ab8c1a767cc495a799d9575ae", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "tools/fresnel.h", "max_forks_repo_name": "titodalcanton/flare", "max_forks_repo_head_hexsha": "4ffb02977d19786ab8c1a767cc495a799d9575ae", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2018-09-20T14:19:13.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-20T02:56:30.000Z", "avg_line_length": 25.3855421687, "max_line_length": 106, "alphanum_fraction": 0.5866160418, "num_tokens": 504, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.46490155654565424, "lm_q2_score": 0.029760091364389046, "lm_q1q2_score": 0.01383551279824535}}
{"text": "/* multifit/work.c\n * \n * Copyright (C) 2000 Brian Gough\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include <config.h>\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_multifit.h>\n\ngsl_multifit_linear_workspace *\ngsl_multifit_linear_alloc (size_t n, size_t p)\n{\n  gsl_multifit_linear_workspace *w;\n\n  w = (gsl_multifit_linear_workspace *)\n    malloc (sizeof (gsl_multifit_linear_workspace));\n\n  if (w == 0)\n    {\n      GSL_ERROR_VAL (\"failed to allocate space for multifit_linear struct\",\n                     GSL_ENOMEM, 0);\n    }\n\n  w->n = n;                     /* number of observations */\n  w->p = p;                     /* number of parameters */\n\n  w->A = gsl_matrix_alloc (n, p);\n\n  if (w->A == 0)\n    {\n      free (w);\n      GSL_ERROR_VAL (\"failed to allocate space for A\", GSL_ENOMEM, 0);\n    }\n\n  w->Q = gsl_matrix_alloc (p, p);\n\n  if (w->Q == 0)\n    {\n      gsl_matrix_free (w->A);\n      free (w);\n      GSL_ERROR_VAL (\"failed to allocate space for Q\", GSL_ENOMEM, 0);\n    }\n\n  w->QSI = gsl_matrix_alloc (p, p);\n\n  if (w->QSI == 0)\n    {\n      gsl_matrix_free (w->Q);\n      gsl_matrix_free (w->A);\n      free (w);\n      GSL_ERROR_VAL (\"failed to allocate space for QSI\", GSL_ENOMEM, 0);\n    }\n\n  w->S = gsl_vector_alloc (p);\n\n  if (w->S == 0)\n    {\n      gsl_matrix_free (w->QSI);\n      gsl_matrix_free (w->Q);\n      gsl_matrix_free (w->A);\n      free (w);\n      GSL_ERROR_VAL (\"failed to allocate space for S\", GSL_ENOMEM, 0);\n    }\n\n  w->t = gsl_vector_alloc (n);\n\n  if (w->t == 0)\n    {\n      gsl_vector_free (w->S);\n      gsl_matrix_free (w->QSI);\n      gsl_matrix_free (w->Q);\n      gsl_matrix_free (w->A);\n      free (w);\n      GSL_ERROR_VAL (\"failed to allocate space for t\", GSL_ENOMEM, 0);\n    }\n\n  w->xt = gsl_vector_calloc (p);\n\n  if (w->xt == 0)\n    {\n      gsl_vector_free (w->t);\n      gsl_vector_free (w->S);\n      gsl_matrix_free (w->QSI);\n      gsl_matrix_free (w->Q);\n      gsl_matrix_free (w->A);\n      free (w);\n      GSL_ERROR_VAL (\"failed to allocate space for xt\", GSL_ENOMEM, 0);\n    }\n\n  w->D = gsl_vector_calloc (p);\n\n  if (w->D == 0)\n    {\n      gsl_vector_free (w->D);\n      gsl_vector_free (w->t);\n      gsl_vector_free (w->S);\n      gsl_matrix_free (w->QSI);\n      gsl_matrix_free (w->Q);\n      gsl_matrix_free (w->A);\n      free (w);\n      GSL_ERROR_VAL (\"failed to allocate space for xt\", GSL_ENOMEM, 0);\n    }\n\n  return w;\n}\n\nvoid\ngsl_multifit_linear_free (gsl_multifit_linear_workspace * work)\n{\n  gsl_matrix_free (work->A);\n  gsl_matrix_free (work->Q);\n  gsl_matrix_free (work->QSI);\n  gsl_vector_free (work->S);\n  gsl_vector_free (work->t);\n  gsl_vector_free (work->xt);\n  gsl_vector_free (work->D);\n  free (work);\n}\n\n", "meta": {"hexsha": "f05e3ff4b5da9bd0ee5c6308a0b6141585c7b1ba", "size": 3349, "ext": "c", "lang": "C", "max_stars_repo_path": "pkgs/libs/gsl/src/multifit/work.c", "max_stars_repo_name": "manggoguy/parsec-modified", "max_stars_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 64.0, "max_stars_repo_stars_event_min_datetime": "2015-03-06T00:30:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T13:26:53.000Z", "max_issues_repo_path": "pkgs/libs/gsl/src/multifit/work.c", "max_issues_repo_name": "manggoguy/parsec-modified", "max_issues_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2020-12-15T08:30:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-13T03:54:24.000Z", "max_forks_repo_path": "pkgs/libs/gsl/src/multifit/work.c", "max_forks_repo_name": "manggoguy/parsec-modified", "max_forks_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 40.0, "max_forks_repo_forks_event_min_datetime": "2015-02-26T15:31:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T23:23:37.000Z", "avg_line_length": 24.9925373134, "max_line_length": 81, "alphanum_fraction": 0.6174977605, "num_tokens": 976, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3738758227716966, "lm_q2_score": 0.03676946871440616, "lm_q1q2_score": 0.013747215368476761}}
{"text": "//! \\file heat_driver.h\n//! Driver for Magnolia's heat transfer solver\n#ifndef ENRICO_SURROGATE_HEAT_DRIVER_H\n#define ENRICO_SURROGATE_HEAT_DRIVER_H\n\n#include \"enrico/geom.h\"\n#include \"enrico/heat_fluids_driver.h\"\n\n#include <gsl/gsl>\n#include <mpi.h>\n#include <pugixml.hpp>\n#include <xtensor/xtensor.hpp>\n\n#include <cstddef>\n\nnamespace enrico {\n\n//! Struct containing geometric information for a flow channel\nstruct Channel {\n  //! Channel index\n  int index_;\n\n  //! Channel flow area\n  double area_;\n\n  //! Vector of rod IDs connected to this channel, all with a fractional perimeter\n  //! in contact with the channel equal to 0.25\n  std::vector<std::size_t> rod_ids_;\n};\n\n//! Struct containing geometry information for a cylindrical solid rod\nstruct Rod {\n  //! Rod index\n  int index_;\n\n  //! Rod cladding outer radius\n  double clad_outer_radius_;\n\n  //! Rod cladding inner radius\n  double clad_inner_radius_;\n\n  //! Rod pellet radius\n  double pellet_radius_;\n\n  //! Vector of channel IDs connected to this rod, all with a fractional perimeter\n  //! in contact with the rod equal to 0.25\n  std::vector<std::size_t> channel_ids_;\n};\n\n//! Class to construct flow channels for a Cartesian lattice of pins\nclass ChannelFactory {\npublic:\n  ChannelFactory(double pitch, double rod_radius)\n    : pitch_(pitch)\n    , radius_(rod_radius)\n    , interior_area_(pitch_ * pitch_ - M_PI * radius_ * radius_)\n  {}\n\n  //! Make a corner subchannel connected to given rods\n  Channel make_corner(const std::vector<std::size_t>& rods) const\n  {\n    Channel c;\n    c.index_ = index_++;\n    c.area_ = 0.25 * interior_area_;\n    c.rod_ids_ = rods;\n    return c;\n  }\n\n  //! Make an edge subchannel connected to given rods\n  Channel make_edge(const std::vector<std::size_t>& rods) const\n  {\n    Channel c;\n    c.index_ = index_++;\n    c.area_ = 0.5 * interior_area_;\n    c.rod_ids_ = rods;\n    return c;\n  }\n\n  //! Make an interior subchannel connected to given rods\n  Channel make_interior(const std::vector<std::size_t>& rods) const\n  {\n    Channel c;\n    c.index_ = index_++;\n    c.area_ = interior_area_;\n    c.rod_ids_ = rods;\n    return c;\n  }\n\nprivate:\n  //! rod pitch\n  double pitch_;\n\n  //! rod outer radius\n  double radius_;\n\n  //! interior channel flow area, which is proportional to flow areas for all\n  //! other channel types\n  double interior_area_;\n\n  //! index of constructed channel\n  static int index_;\n};\n\nclass RodFactory {\npublic:\n  RodFactory(double clad_OR, double clad_IR, double pellet_OR)\n    : clad_outer_r_(clad_OR)\n    , clad_inner_r_(clad_IR)\n    , pellet_outer_r_(pellet_OR)\n  {}\n\n  //! Make a rod connected to given channels\n  Rod make_rod(const std::vector<std::size_t>& channels) const\n  {\n    Rod r;\n    r.index_ = index_++;\n    r.clad_inner_radius_ = clad_inner_r_;\n    r.clad_outer_radius_ = clad_outer_r_;\n    r.pellet_radius_ = pellet_outer_r_;\n    r.channel_ids_ = channels;\n    return r;\n  }\n\nprivate:\n  //! Cladding outer radius\n  double clad_outer_r_;\n\n  //! Cladding inner radius\n  double clad_inner_r_;\n\n  //! Pellet outer radius\n  double pellet_outer_r_;\n\n  //! Index of constructed rod\n  static int index_;\n};\n\n/**\n * Class providing surrogate thermal-hydraulic solution for a Cartesian\n * bundle of rods with upwards-flowing coolant. A conduction model is used\n * for the solid phase, with axial conduction neglected. The solid phase is\n * linked to the fluid phase by conjugate heat transfer, which is treated\n * here with a pseudo-steady-state approach where the power entering the fluid\n * matches the power in the rod at that axial elevation. It is assumed that\n * there is zero thermal resistance between the rod and the fluid.\n *\n * The fluid solution is obtained with a very simplified \"subchannel\" method\n * that neglects all crossflow terms between channels such that the method\n * is more akin to a single-pin analysis in a coolant-centered basis. The\n * enthalpy is solved by simply axial energy balance, while the axial momentum\n * equation is solved for pressure (the mass flow rate in each channel being\n * fixed) while neglecting friction effects.\n */\nclass SurrogateHeatDriver : public HeatFluidsDriver {\npublic:\n  //! Initializes heat-fluids surrogate with the given MPI communicator.\n  //!\n  //! \\param comm  The MPI communicator used to initialze the surrogate\n  //! \\param node  XML node containing settings for surrogate\n  explicit SurrogateHeatDriver(MPI_Comm comm, pugi::xml_node node);\n\n  //! Verbosity options for printing simulation results\n  enum class verbose { NONE, LOW, HIGH };\n\n  bool has_coupling_data() const final { return comm_.rank == 0; }\n\n  //! Get the number of local mesh elements\n  //! \\return Number of local mesh elements\n  int n_local_elem() const override;\n\n  //! Get the number of global mesh elements\n  //! \\return Number of global mesh elements\n  std::size_t n_global_elem() const override;\n\n  //! Set the heat source for a given local element\n  //!\n  //! \\param local_elem A local element ID\n  //! \\param heat A heat source term\n  //! \\return Error code\n  int set_heat_source_at(int32_t local_elem, double heat) override;\n\n  //! Solves the heat-fluids surrogate solver\n  void solve_step() final;\n\n  void solve_heat();\n\n  void solve_fluid();\n\n  //! Returns Number of rings in fuel and clad\n  std::size_t n_rings() const { return n_fuel_rings_ + n_clad_rings_; }\n\n  //! Returns cladding inner radius\n  double clad_inner_radius() const { return clad_inner_radius_; }\n\n  //! Returns cladding outer radius\n  double clad_outer_radius() const { return clad_outer_radius_; }\n\n  //! Returns pellet outer radius\n  double pellet_radius() const { return pellet_radius_; }\n\n  //! Returns number of fuel rings\n  std::size_t n_fuel_rings() const { return n_fuel_rings_; }\n\n  //! Returns number of clad rings\n  std::size_t n_clad_rings() const { return n_clad_rings_; }\n\n  //! Returns number of pins in x-direction\n  std::size_t n_pins_x() const { return n_pins_x_; }\n\n  //! Returns number of pins in y-direction\n  std::size_t n_pins_y() const { return n_pins_y_; }\n\n  //! Returns pin pitch\n  double pin_pitch() const { return pin_pitch_; }\n\n  //! Returns inlet temperature boundary condition in [K]\n  double inlet_temperature() const { return inlet_temperature_; }\n\n  //! Returns inlet mass flowrate boundary condition in [kg/s]\n  double mass_flowrate() const { return mass_flowrate_; }\n\n  //! Returns maximum number of subchannel iterations\n  std::size_t max_subchannel_its() const { return max_subchannel_its_; }\n\n  //! Returns subchannel convergence tolerance for enthalpy\n  double subchannel_tol_h() const { return subchannel_tol_h_; }\n\n  //! Returns subchannel convergence tolerance for pressure\n  double subchannel_tol_p() const { return subchannel_tol_p_; }\n\n  //! Returns convergence tolerance for solid energy equation\n  double heat_tol() const { return heat_tol_; }\n\n  //! Write data to VTK\n  void write_step(int timestep, int iteration) final;\n\n  //! Returns solid temperature in [K] for given region\n  double solid_temperature(std::size_t pin, std::size_t axial, std::size_t ring) const;\n\n  //! Returns fluid density in [g/cm^3] for given region\n  double fluid_density(std::size_t pin, std::size_t axial) const;\n\n  //! Returns fluid temperature in [K] for given region\n  double fluid_temperature(std::size_t pin, std::size_t axial) const;\n\n  // Data on fuel pins\n  xt::xtensor<double, 2> pin_centers_; //!< (x,y) values for center of fuel pins\n  xt::xtensor<double, 1> z_;           //!< Bounding z-values for axial segments\n  std::size_t n_axial_;                //!< number of axial segments\n  std::size_t n_azimuthal_{4};         //!< number of azimuthal segments\n\n  //! Total number of pins\n  std::size_t n_pins_;\n\n  // Dimensions for a single fuel pin axial segment\n  double clad_outer_radius_;     //!< clad outer radius in [cm]\n  double clad_inner_radius_;     //!< clad inner radius in [cm]\n  double pellet_radius_;         //!< fuel pellet radius in [cm]\n  std::size_t n_fuel_rings_{20}; //!< number of fuel rings\n  std::size_t n_clad_rings_{2};  //!< number of clad rings\n\n  //!< Channels in the domain\n  std::vector<Channel> channels_;\n\n  //!< Rods in the domain\n  std::vector<Rod> rods_;\n\n  //! Mass flowrate for coolant-centered channels; this is determine by distributing\n  //! a total inlet mass flowrate among the channels based on the fractional flow area.\n  xt::xtensor<double, 1> channel_flowrates_;\n\n  // solver variables and settings\n  xt::xtensor<double, 4>\n    source_; //!< heat source for each (pin, axial segment, ring, azimuthal segment)\n  xt::xtensor<double, 1> r_grid_clad_; //!< radii of each clad ring in [cm]\n  xt::xtensor<double, 1> r_grid_fuel_; //!< radii of each fuel ring in [cm]\n\n  //! Cross-sectional areas of rings in fuel and cladding\n  xt::xtensor<double, 1> solid_areas_;\n\n  // visualization\n  std::string viz_basename_{\n    \"heat_surrogate\"}; //!< base filename for visualization files (default: magnolia)\n  std::string viz_iterations_{\n    \"none\"};                    //!< visualization iterations to write (none, all, final)\n  std::string viz_data_{\"all\"}; //!< visualization data to write\n  std::string viz_regions_{\"all\"}; //!< visualization regions to write\n  size_t vtk_radial_res_{20};      //!< radial resolution of resulting vtk files\n\nprivate:\n  //! Get temperature of local mesh elements\n  //! \\return Temperature of local mesh elements in [K]\n  std::vector<double> temperature_local() const override;\n\n  //! Get density of local mesh elements\n  //! \\return Density of local mesh elements in [g/cm^3]\n  std::vector<double> density_local() const override;\n\n  //! States whether each local region is in fluid\n  //! \\return For each local region, 1 if region is in fluid and 0 otherwise\n  std::vector<int> fluid_mask_local() const override;\n\n  //! Get centroids of local mesh elements\n  //! \\return Centroids of local mesh elements\n  std::vector<Position> centroid_local() const override;\n\n  //! Get volumes of local mesh elements\n  //! \\return Volumes of local mesh elements\n  std::vector<double> volume_local() const override;\n\n  //! Create internal arrays used for heat equation solver\n  void generate_arrays();\n\n  //! Channel index in terms of row, column index\n  int channel_index(int row, int col) const { return row * (n_pins_x_ + 1) + col; }\n\n  //! Rod power at a given node in a given pin, computed by integrating the heat source\n  //! (assumed constant in each ring) over the pin.\n  //! \\param pin   pin index\n  //! \\param axial axial index\n  double rod_axial_node_power(const int pin, const int axial) const;\n\n  //! Diagnostic function to assess whether the mass is conserved by the subchannel\n  //! solver by comparing the mass flowrate in each axial plane (at cell-centered\n  //! positions) to the specified inlet mass flowrate.\n  //! \\param rho density in a cell-centered basis\n  //! \\param u   axial velocity in a face-centered basis\n  bool is_mass_conserved(const xt::xtensor<double, 2>& rho,\n                         const xt::xtensor<double, 2>& u) const;\n\n  //! Diagnostic function to assess whether the energy is conserved by the subchannel\n  //! solver by comparing the energy deposition in each channel in each axial plane\n  //! (at cell-centered positions) to the powers of the rods connected to that channel.\n  //! \\param rho density in a cell-centered basis\n  //! \\param u   axial velocity in a face-centered basis\n  //! \\param h   enthalpy in a face-centered basis\n  //! \\param q   powers in each channel in a cell-centered basis\n  bool is_energy_conserved(const xt::xtensor<double, 2>& rho,\n                           const xt::xtensor<double, 2>& u,\n                           const xt::xtensor<double, 2>& h,\n                           const xt::xtensor<double, 2>& q) const;\n\n  //!< solid temperature in [K] for each (pin, axial segment, ring)\n  xt::xtensor<double, 3> solid_temperature_;\n\n  //! Flow areas for coolant-centered channels\n  xt::xtensor<double, 1> channel_areas_;\n\n  //! Fluid temperature in a rod-centered basis indexed by rod ID and axial ID\n  xt::xtensor<double, 2> fluid_temperature_;\n\n  //! Fluid density in [g/cm^3] in a rod-centered basis indexed by rod ID and axial ID\n  xt::xtensor<double, 2> fluid_density_;\n\n  //! Number of pins in the x-direction in a Cartesian grid\n  std::size_t n_pins_x_;\n\n  //! Number of pins in the y-direction in a Cartesian grid\n  std::size_t n_pins_y_;\n\n  //! Pin pitch, assumed the same for the x and y directions\n  double pin_pitch_;\n\n  //! Inlet fluid temperature [K]\n  double inlet_temperature_;\n\n  //! Mass flowrate of fluid into the domain [kg/s]\n  double mass_flowrate_;\n\n  //! Number of channels\n  std::size_t n_channels_;\n\n  //! Maximum number of iterations for subchannel solution, set to a default value\n  //! of 100 if not set by the user\n  int max_subchannel_its_ = 100;\n\n  //! Convergence tolerance on enthalpy for the subchannel solution for use in\n  //! convergence based on the L-1 norm, set to a default value of 1e-2\n  double subchannel_tol_h_ = 1e-2;\n\n  //! Convergence tolerance on pressure for the subchannel solution for use in\n  //! convergence based on the L-1 norm, set to a default value of 1e-2\n  double subchannel_tol_p_ = 1e-2;\n\n  //! Convergence tolerance for solid temperature solution, set to a default value\n  //! of 1e-4\n  double heat_tol_ = 1e-4;\n\n  //! Gravitational acceleration\n  const double g_ = 9.81;\n\n  //! Verbosity setting for printing simulation results; defaults to NONE\n  verbose verbosity_ = verbose::NONE;\n\n}; // end SurrogateHeatDriver\n\n} // namespace enrico\n\n#endif // ENRICO_SURROGATE_HEAT_DRIVER_H\n", "meta": {"hexsha": "4fa134e88c81e6b5de66c28e254de49c266845b8", "size": 13558, "ext": "h", "lang": "C", "max_stars_repo_path": "include/enrico/surrogate_heat_driver.h", "max_stars_repo_name": "pshriwise/enrico", "max_stars_repo_head_hexsha": "72b95ca947804f672e5f1726e169ef6f4889e78e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/enrico/surrogate_heat_driver.h", "max_issues_repo_name": "pshriwise/enrico", "max_issues_repo_head_hexsha": "72b95ca947804f672e5f1726e169ef6f4889e78e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2020-06-14T18:14:35.000Z", "max_issues_repo_issues_event_max_datetime": "2020-06-15T15:30:51.000Z", "max_forks_repo_path": "include/enrico/surrogate_heat_driver.h", "max_forks_repo_name": "lebuller/enrico", "max_forks_repo_head_hexsha": "edd04f1e02caf1c3fae2992e55d9a47e4429655c", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.895, "max_line_length": 89, "alphanum_fraction": 0.71087181, "num_tokens": 3366, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4186969238628498, "lm_q2_score": 0.032589747702267004, "lm_q1q2_score": 0.013645227112405572}}
{"text": "/* This program is free software; you can redistribute it and/or\n   modify it under the terms of the GNU General Public License as\n   published by the Free Software Foundation; either version 2 of the\n   License, or (at your option) any later version.\n\n   This program is distributed in the hope that it will be useful, but\n   WITHOUT ANY WARRANTY; without even the implied warranty of\n   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n   General Public License for more details.  You should have received\n   a copy of the GNU General Public License along with this program;\n   if not, write to the Free Foundation, Inc., 59 Temple Place, Suite\n   330, Boston, MA 02111-1307 USA\n\n   Original implementation was copyright (C) 1997 Makoto Matsumoto and\n   Takuji Nishimura. Coded by Takuji Nishimura, considering the\n   suggestions by Topher Cooper and Marc Rieffel in July-Aug. 1997, \"A\n   C-program for MT19937: Integer version (1998/4/6)\"\n\n   This implementation copyright (C) 1998 Brian Gough. I reorganized\n   the code to use the module framework of GSL.  The license on this\n   implementation was changed from LGPL to GPL, following paragraph 3\n   of the LGPL, version 2.\n\n   The seeding procedure has been updated to match the 10/99 release\n   of MT19937.\n\n   The original code included the comment: \"When you use this, send an\n   email to: matumoto@math.keio.ac.jp with an appropriate reference to\n   your work\".\n\n   Makoto Matsumoto has a web page with more information about the\n   generator, http://www.math.keio.ac.jp/~matumoto/emt.html. \n\n   The paper below has details of the algorithm.\n\n   From: Makoto Matsumoto and Takuji Nishimura, \"Mersenne Twister: A\n   623-dimensionally equidistributerd uniform pseudorandom number\n   generator\". ACM Transactions on Modeling and Computer Simulation,\n   Vol. 8, No. 1 (Jan. 1998), Pages 3-30\n\n   You can obtain the paper directly from Makoto Matsumoto's web page.\n\n   The period of this generator is 2^{19937} - 1.\n\n*/\n\n#include <config.h>\n#include <stdlib.h>\n#include <gsl/gsl_rng.h>\n\nstatic inline unsigned long int mt_get (void *vstate);\nstatic double mt_get_double (void *vstate);\nstatic void mt_set (void *state, unsigned long int s);\n\n#define N 624\t/* Period parameters */\n#define M 397\n\n/* most significant w-r bits */\nstatic const unsigned long UPPER_MASK = 0x80000000UL;\t\n\n/* least significant r bits */\nstatic const unsigned long LOWER_MASK = 0x7fffffffUL;\t\n\ntypedef struct\n  {\n    unsigned long mt[N];\n    int mti;\n  }\nmt_state_t;\n\nstatic inline unsigned long\nmt_get (void *vstate)\n{\n  mt_state_t *state = (mt_state_t *) vstate;\n\n  unsigned long k ;\n  unsigned long int *const mt = state->mt;\n\n#define MAGIC(y) (((y)&0x1) ? 0x9908b0dfUL : 0)\n\n  if (state->mti >= N)\n    {\t/* generate N words at one time */\n      int kk;\n\n      for (kk = 0; kk < N - M; kk++)\n\t{\n\t  unsigned long y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK);\n\t  mt[kk] = mt[kk + M] ^ (y >> 1) ^ MAGIC(y);\n\t}\n      for (; kk < N - 1; kk++)\n\t{\n\t  unsigned long y = (mt[kk] & UPPER_MASK) | (mt[kk + 1] & LOWER_MASK);\n\t  mt[kk] = mt[kk + (M - N)] ^ (y >> 1) ^ MAGIC(y);\n\t}\n\n      {\n\tunsigned long y = (mt[N - 1] & UPPER_MASK) | (mt[0] & LOWER_MASK);\n\tmt[N - 1] = mt[M - 1] ^ (y >> 1) ^ MAGIC(y);\n      }\n\n      state->mti = 0;\n    }\n\n  /* Tempering */\n  \n  k = mt[state->mti];\n  k ^= (k >> 11);\n  k ^= (k << 7) & 0x9d2c5680UL;\n  k ^= (k << 15) & 0xefc60000UL;\n  k ^= (k >> 18);\n\n  state->mti++;\n\n  return k;\n}\n\nstatic double\nmt_get_double (void * vstate)\n{\n  return mt_get (vstate) / 4294967296.0 ;\n}\n\nstatic void\nmt_set (void *vstate, unsigned long int s)\n{\n  mt_state_t *state = (mt_state_t *) vstate;\n  int i;\n\n  if (s == 0)\n    s = 4357;\t/* the default seed is 4357 */\n\n  /* This is the October 1999 version of the seeding procedure. It\n     was updated by the original developers to avoid the periodicity\n     in the simple congruence originally used.\n\n     Note that an ANSI-C unsigned long integer arithmetic is\n     automatically modulo 2^32 (or a higher power of two), so we can\n     safely ignore overflow. */\n\n#define LCG(x) ((69069 * x) + 1) &0xffffffffUL\n\n  for (i = 0; i < N; i++)\n    {\n      state->mt[i] = s & 0xffff0000UL;\n      s = LCG(s);\n      state->mt[i] |= (s &0xffff0000UL) >> 16;\n      s = LCG(s);\n    }\n\n  state->mti = i;\n}\n\n/* This is the original version of the seeding procedure, no longer\n   used but available for compatibility with the original MT19937. */\n\nstatic void\nmt_1998_set (void *vstate, unsigned long int s)\n{\n  mt_state_t *state = (mt_state_t *) vstate;\n  int i;\n\n  if (s == 0)\n    s = 4357;\t/* the default seed is 4357 */\n\n  state->mt[0] = s & 0xffffffffUL;\n\n#define LCG1998(n) ((69069 * n) & 0xffffffffUL)\n\n  for (i = 1; i < N; i++)\n    state->mt[i] = LCG1998 (state->mt[i - 1]);\n\n  state->mti = i;\n}\n\nstatic const gsl_rng_type mt_type =\n{\"mt19937\",\t\t\t/* name */\n 0xffffffffUL,\t\t\t/* RAND_MAX  */\n 0,\t\t\t        /* RAND_MIN  */\n sizeof (mt_state_t),\n &mt_set,\n &mt_get,\n &mt_get_double};\n\nstatic const gsl_rng_type mt_1998_type =\n{\"mt19937_1998\",\t\t/* name */\n 0xffffffffUL,\t\t\t/* RAND_MAX  */\n 0,\t\t\t        /* RAND_MIN  */\n sizeof (mt_state_t),\n &mt_1998_set,\n &mt_get,\n &mt_get_double};\n\nconst gsl_rng_type *gsl_rng_mt19937 = &mt_type;\nconst gsl_rng_type *gsl_rng_mt19937_1998 = &mt_1998_type;\n\n/* MT19937 is the default generator, so define that here too */\n\nconst gsl_rng_type *gsl_rng_default = &mt_type;\nunsigned long int gsl_rng_default_seed = 0;\n", "meta": {"hexsha": "eac955534d7b6c6c7d0a8b42c7c3683d7c15fe55", "size": 5449, "ext": "c", "lang": "C", "max_stars_repo_path": "code/em/treba/gsl-1.0/rng/mt.c", "max_stars_repo_name": "ICML14MoMCompare/spectral-learn", "max_stars_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "code/em/treba/gsl-1.0/rng/mt.c", "max_issues_repo_name": "ICML14MoMCompare/spectral-learn", "max_issues_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/em/treba/gsl-1.0/rng/mt.c", "max_forks_repo_name": "ICML14MoMCompare/spectral-learn", "max_forks_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2015-10-02T01:32:59.000Z", "max_forks_repo_forks_event_max_datetime": "2015-10-02T01:32:59.000Z", "avg_line_length": 27.245, "max_line_length": 71, "alphanum_fraction": 0.6630574417, "num_tokens": 1678, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.31742627850202554, "lm_q2_score": 0.04272219739413732, "lm_q1q2_score": 0.013561148128249944}}
{"text": "/*\t$Id$ */\n/*\n * Copyright (c) 2014 Kristaps Dzonsons <kristaps@kcons.eu>\n *\n * Permission to use, copy, modify, and distribute this software for any\n * purpose with or without fee is hereby granted, provided that the above\n * copyright notice and this permission notice appear in all copies.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\n * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\n * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\n * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\n * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\n * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF\n * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n */\n#include <assert.h>\n#include <ctype.h>\n#include <math.h>\n#include <stdint.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\n#include <gtk/gtk.h>\n#include <gsl/gsl_rng.h>\n#include <gsl/gsl_multifit.h>\n#include <gsl/gsl_histogram.h>\n#include <kplot.h>\n\n#include \"extern.h\"\n\n#define\tBUFSZ 1024\n\n/*\n * All possible input tokens, including some which are \"virtual\" tokens\n * in that they don't map to an exact character representation.\n */\nenum\ttoken {\n\tTOKEN_PAREN_OPEN,\n\tTOKEN_PAREN_CLOSE,\n\tTOKEN_ADD,\n\tTOKEN_SUB,\n\tTOKEN_MUL,\n\tTOKEN_DIV,\n\tTOKEN_EXP,\n\tTOKEN_END,\n\tTOKEN_NUMBER,\n\tTOKEN_SQRT,\n\tTOKEN_EXPF,\n\tTOKEN_P1,\n\tTOKEN_PN,\n\tTOKEN_N,\n\tTOKEN_ERROR,\n\tTOKEN_SKIP,\n\tTOKEN_POSITIVE,\n\tTOKEN_NEGATIVE,\n\tTOK__MAX\n};\n\nenum\tarity {\n\tARITY_NONE = 0,\n\tARITY_ONE,\n\tARITY_TWO\n};\n\nenum\tassoc {\n\tASSOC_NONE = 0,\n\tASSOC_L,\n\tASSOC_R,\n};\n\nstruct\ttok {\n\tchar\t\t key; /* input identifier */\n\tint\t\t prec; /* precedence (if applicable) */\n\tint\t\t oper; /* is operator? */\n\tint\t\t func; /* is function? */\n\tenum assoc\t assoc; /* associativity */\n\tenum arity\t arity; /* n-ary-ess */\n\tenum htype\t map; /* map to htype (if applicable) */\n};\n\nstatic\tconst struct tok toks[TOK__MAX] = {\n\t{ '(',  -1, 0, 0, ASSOC_NONE, ARITY_NONE, HNODE__MAX }, /* TOKEN_PAREN_OPEN */\n\t{ ')',  -1, 0, 0, ASSOC_NONE, ARITY_NONE, HNODE__MAX }, /* TOKEN_PAREN_CLOSE */\n\t{ '+',  2, 1, 0, ASSOC_L, ARITY_TWO, HNODE_ADD }, /* TOKEN_ADD */\n\t{ '-',  2, 1, 0, ASSOC_L, ARITY_TWO, HNODE_SUB }, /* TOKEN_SUB */\n\t{ '*',  3, 1, 0, ASSOC_L, ARITY_TWO, HNODE_MUL }, /* TOKEN_MUL */\n\t{ '/',  3, 1, 0, ASSOC_L, ARITY_TWO, HNODE_DIV }, /* TOKEN_DIV */\n\t{ '^',  5, 1, 0, ASSOC_R, ARITY_TWO, HNODE_EXP }, /* TOKEN_EXP */\n\t{ '\\0', -1, 0, 0, ASSOC_NONE, ARITY_NONE, HNODE__MAX }, /* TOKEN_END */\n\t{ '\\0', -1, 0, 0, ASSOC_NONE, ARITY_NONE, HNODE_NUMBER }, /* TOKEN_NUMBER */\n\t{ '\\0', -1, 0, 1, ASSOC_NONE, ARITY_NONE, HNODE_SQRT }, /* TOKEN_SQRT */\n\t{ '\\0', -1, 0, 1, ASSOC_NONE, ARITY_NONE, HNODE_EXPF }, /* TOKEN_EXPF */\n\t{ 'x',  -1, 0, 0, ASSOC_NONE, ARITY_NONE, HNODE_P1 }, /* TOKEN_P1 */\n\t{ 'X',  -1, 0, 0, ASSOC_NONE, ARITY_NONE, HNODE_PN }, /* TOKEN_PN */\n\t{ 'n',  -1, 0, 0, ASSOC_NONE, ARITY_NONE, HNODE_N }, /* TOKEN_N */\n\t{ '\\0', -1, 0, 0, ASSOC_NONE, ARITY_NONE, HNODE__MAX }, /* TOKEN_ERROR */\n\t{ ' ',  -1, 0, 0, ASSOC_NONE, ARITY_NONE, HNODE__MAX }, /* TOKEN_SKIP */\n\t{ '+',  4, 1, 0, ASSOC_R, ARITY_ONE, HNODE_POSITIVE }, /* TOKEN_POSITIVE */\n\t{ '-',  4, 1, 0, ASSOC_R, ARITY_ONE, HNODE_NEGATIVE }, /* TOKEN_NEGATIVE */\n};\n\n#if 0\nstatic void\nhnode_print(struct hnode **p)\n{\n\tstruct hnode\t**pp;\n\n\tif (NULL == p)\n\t\treturn;\n\n\tfor (pp = p; NULL != *pp; pp++) {\n\t\tswitch ((*pp)->type) {\n\t\tcase (HNODE_VAR):\n\t\t\tputchar('v');\n\t\t\tbreak;\n\t\tcase (HNODE_P1):\n\t\t\tputchar('x');\n\t\t\tbreak;\n\t\tcase (HNODE_P2):\n\t\t\tputchar('y');\n\t\t\tbreak;\n\t\tcase (HNODE_NUMBER):\n\t\t\tprintf(\"%g\", (*pp)->real);\n\t\t\tbreak;\n\t\tcase (HNODE_SQRT):\n\t\t\tprintf(\"sqrt\");\n\t\t\tbreak;\n\t\tcase (HNODE_ADD):\n\t\t\tputchar('+');\n\t\t\tbreak;\n\t\tcase (HNODE_EXP):\n\t\t\tputchar('^');\n\t\t\tbreak;\n\t\tcase (HNODE_SUB):\n\t\t\tputchar('-');\n\t\t\tbreak;\n\t\tcase (HNODE_MUL):\n\t\t\tputchar('*');\n\t\t\tbreak;\n\t\tcase (HNODE_DIV):\n\t\t\tputchar('/');\n\t\t\tbreak;\n\t\tcase (HNODE_POSITIVE):\n\t\t\tprintf(\"+'\");\n\t\t\tbreak;\n\t\tcase (HNODE_NEGATIVE):\n\t\t\tprintf(\"-'\");\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tabort();\n\t\t}\n\t\tputchar(' ');\n\t}\n\tputchar('\\n');\n}\n#endif\n\n/*\n * Check if the current token (which has ARITY_ONE, we assume) is in\n * fact unary.\n * We do this by checking the previous token: if it's a binary operator\n * or an open parenthesis, then we're a unary operator.\n */\nstatic int\ncheck_unary(enum token lasttok)\n{\n\tswitch (lasttok) {\n\tcase (TOK__MAX):\n\t\t/* FALLTHROUGH */\n\tcase (TOKEN_PAREN_OPEN):\n\t\t/* FALLTHROUGH */\n\tcase (TOKEN_ADD):\n\t\t/* FALLTHROUGH */\n\tcase (TOKEN_SUB):\n\t\t/* FALLTHROUGH */\n\tcase (TOKEN_MUL):\n\t\t/* FALLTHROUGH */\n\tcase (TOKEN_DIV):\n\t\t/* FALLTHROUGH */\n\tcase (TOKEN_EXP):\n\t\treturn(1);\n\tdefault:\n\t\tbreak;\n\t}\n\treturn(0);\n}\n\n/*\n * Check if the current token (which has ARITY_TWO, we assume) is in\n * fact binary.\n * We do this by checking the previous token: if it's an operand or a\n * close-paren (i.e., an operand), then we're a binary operator.\n */\nstatic int\ncheck_binary(enum token lasttok)\n{\n\tswitch (lasttok) {\n\tcase (TOKEN_PAREN_CLOSE):\n\t\t/* FALLTHROUGH */\n\tcase (TOKEN_NUMBER):\n\t\t/* FALLTHROUGH */\n\tcase (TOKEN_P1):\n\t\t/* FALLTHROUGH */\n\tcase (TOKEN_PN):\n\t\t/* FALLTHROUGH */\n\tcase (TOKEN_N):\n\t\treturn(1);\n\tdefault:\n\t\tbreak;\n\t}\n\treturn(0);\n}\n\n/*\n * Extra a token from input.\n * If TOKEN_ERROR, something bad has happened in the attempt to do so.\n * Otherwise, this returns a valid token (possibly end of input).\n */\nstatic enum token\ntokenise(const char **v, char *buf, enum token lasttok)\n{\n\tsize_t\t\ti, sz;\n\n\t/* Short-circuit this case. */\n\tif ('\\0' == **v)\n\t\treturn(TOKEN_END);\n\n\t/* Look for token in our predefined inputs. */\n\tfor (i = 0; i < TOK__MAX; i++)\n\t\tif ('\\0' != toks[i].key && **v == toks[i].key) {\n\t\t\tswitch (toks[i].arity) {\n\t\t\tcase (ARITY_NONE):\n\t\t\t\t(*v)++;\n\t\t\t\treturn((enum token)i);\n\t\t\tcase (ARITY_ONE):\n\t\t\t\tif ( ! check_unary(lasttok))\n\t\t\t\t\tcontinue;\n\t\t\t\tbreak;\n\t\t\tcase (ARITY_TWO):\n\t\t\t\tif ( ! check_binary(lasttok))\n\t\t\t\t\tcontinue;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\t(*v)++;\n\t\t\treturn((enum token)i);\n\t\t}\n\n\t/* See if we're a real number or identifier. */\n\tif (isdigit((int)**v) || '.' == **v) {\n\t\tsz = 0;\n\t\tfor ( ; isdigit((int)**v) || '.' == **v; (*v)++) {\n\t\t\tassert(sz < BUFSZ);\n\t\t\tbuf[sz++] = **v;\n\t\t}\n\t\tbuf[sz] = '\\0';\n\t\treturn(TOKEN_NUMBER);\n\t} else if (isalpha((int)**v)) {\n\t\tsz = 0;\n\t\tfor ( ; isalpha((int)**v); (*v)++) {\n\t\t\tassert(sz < BUFSZ);\n\t\t\tbuf[sz++] = **v;\n\t\t}\n\t\tbuf[sz] = '\\0';\n\t\tif (0 == strcmp(buf, \"sqrt\"))\n\t\t\treturn(TOKEN_SQRT);\n\t\telse if (0 == strcmp(buf, \"exp\"))\n\t\t\treturn(TOKEN_EXPF);\n\t} \n\n\t/* Eh... */\n\treturn(TOKEN_ERROR);\n}\n\n/*\n * Queue something onto the output RPN queue.\n */\nstatic void\nenqueue(struct hnode ***q, size_t *qsz, enum token tok)\n{\n\n\t*q = realloc(*q, ++(*qsz) * sizeof(struct hnode *));\n\t(*q)[*qsz - 1] = calloc(1, sizeof(struct hnode));\n\t(*q)[*qsz - 1]->type = toks[tok].map;\n\tassert(HNODE__MAX != toks[tok].map);\n}\n\n/*\n * Make sure that all operators and functions are matched with\n * arguments.\n * The Shunting-Yard algorithm itself doesn't do this, so we need to do\n * it now.\n */\nstatic int\ncheck(struct hnode **p)\n{\n\tstruct hnode\t**pp;\n\tsize_t\t\t  ssz;\n\n\tfor (ssz = 0, pp = p; NULL != *pp; pp++)\n\t\tswitch ((*pp)->type) {\n\t\tcase (HNODE_P1):\n\t\t\t/* FALLTHROUGH */\n\t\tcase (HNODE_PN):\n\t\t\t/* FALLTHROUGH */\n\t\tcase (HNODE_N):\n\t\t\t/* FALLTHROUGH */\n\t\tcase (HNODE_NUMBER):\n\t\t\tssz++;\n\t\t\tbreak;\n\t\tcase (HNODE_POSITIVE):\n\t\t\t/* FALLTHROUGH */\n\t\tcase (HNODE_NEGATIVE):\n\t\t\t/* FALLTHROUGH */\n\t\tcase (HNODE_SQRT):\n\t\t\t/* FALLTHROUGH */\n\t\tcase (HNODE_EXPF):\n\t\t\tif (0 == ssz)\n\t\t\t\treturn(0);\n\t\t\tbreak;\n\t\tcase (HNODE_ADD):\n\t\t\t/* FALLTHROUGH */\n\t\tcase (HNODE_SUB):\n\t\t\t/* FALLTHROUGH */\n\t\tcase (HNODE_MUL):\n\t\t\t/* FALLTHROUGH */\n\t\tcase (HNODE_DIV):\n\t\t\t/* FALLTHROUGH */\n\t\tcase (HNODE_EXP):\n\t\t\tif (ssz < 2)\n\t\t\t\treturn(0);\n\t\t\tssz--;\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tabort();\n\t\t}\n\n\treturn(1 == ssz);\n}\n\n/*\n * Dijkstra's Shunting-Yard algorithm for converting an infix-order\n * expression to prefix order.\n * This returns a NULL-terminated list of expressions to evaluate in\n * post-fix order.\n */\nstruct hnode **\nhnode_parse(const char **v)\n{\n\tenum token\t  tok, lasttok;\n\tenum token\t  stack[STACKSZ];\n\tchar\t\t  buf[BUFSZ + 1];\n\tstruct hnode\t**q;\n\tint\t\t  found;\n\tsize_t\t\t  i, qsz, ssz;\n\n\tq = NULL;\n\tqsz = ssz = 0;\n\tlasttok = TOK__MAX;\n\n\twhile (TOKEN_END != (tok = tokenise(v, buf, lasttok))) {\n\t\tswitch (tok) {\n\t\tcase (TOKEN_ERROR): \n\t\t\tgoto err;\n\t\tcase (TOKEN_SKIP):\n\t\t\tbreak;\n\t\tcase (TOKEN_P1):\n\t\t\t/* FALLTHROUGH */\n\t\tcase (TOKEN_PN):\n\t\t\t/* FALLTHROUGH */\n\t\tcase (TOKEN_N):\n\t\t\tenqueue(&q, &qsz, tok);\n\t\t\tbreak;\n\t\tcase (TOKEN_NUMBER):\n\t\t\tenqueue(&q, &qsz, tok);\n\t\t\tq[qsz - 1]->real = atof(buf);\n\t\t\tbreak;\n\t\tcase (TOKEN_SQRT):\n\t\t\t/* FALLTHROUGH */\n\t\tcase (TOKEN_EXPF):\n\t\t\t/* FALLTHROUGH */\n\t\tcase (TOKEN_PAREN_OPEN):\n\t\t\tassert(ssz < STACKSZ);\n\t\t\tstack[ssz++] = tok;\n\t\t\tbreak;\n\t\tcase (TOKEN_PAREN_CLOSE):\n\t\t\tassert(ssz > 0);\n\t\t\tfound = 0;\n\t\t\tdo {\n\t\t\t\tif (TOKEN_PAREN_OPEN == stack[--ssz])\n\t\t\t\t\tfound = 1;\n\t\t\t\telse\n\t\t\t\t\tenqueue(&q, &qsz, stack[ssz]);\n\t\t\t} while ( ! found && ssz > 0);\n\t\t\tassert(found);\n\t\t\tif (ssz > 0 && toks[stack[ssz - 1]].func)\n\t\t\t\tenqueue(&q, &qsz, stack[--ssz]);\n\t\t\tbreak;\n\t\tcase (TOKEN_POSITIVE):\n\t\t\t/* FALLTHROUGH */\n\t\tcase (TOKEN_NEGATIVE):\n\t\t\t/* FALLTHROUGH */\n\t\tcase (TOKEN_SUB):\n\t\t\t/* FALLTHROUGH */\n\t\tcase (TOKEN_MUL):\n\t\t\t/* FALLTHROUGH */\n\t\tcase (TOKEN_DIV):\n\t\t\t/* FALLTHROUGH */\n\t\tcase (TOKEN_EXP):\n\t\t\t/* FALLTHROUGH */\n\t\tcase (TOKEN_ADD):\n\t\t\tassert(toks[tok].prec >= 0);\n\t\t\tassert(ASSOC_NONE != toks[tok].assoc);\n\t\t\twhile (ssz > 0 && toks[stack[ssz - 1]].oper) {\n\t\t\t\tassert(toks[stack[ssz - 1]].prec >= 0);\n\t\t\t\tassert(ASSOC_NONE != \n\t\t\t\t\ttoks[stack[ssz - 1]].assoc);\n\t\t\t\tif ((ASSOC_L == toks[tok].assoc \n\t\t\t\t\t && toks[tok].prec == \n\t\t\t\t\t toks[stack[ssz - 1]].prec) || \n\t\t\t\t\t (toks[tok].prec < \n\t\t\t\t\t  toks[stack[ssz - 1]].prec))\n\t\t\t\t\tenqueue(&q, &qsz, stack[--ssz]);\n\t\t\t\telse\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t\tassert(ssz < STACKSZ);\n\t\t\tstack[ssz++] = tok;\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tabort();\n\t\t}\n\t\tif (TOKEN_SKIP != tok)\n\t\t\tlasttok = tok;\n\t}\n\n\twhile (ssz > 0) {\n\t\t--ssz;\n\t\tif (TOKEN_PAREN_OPEN == stack[ssz])\n\t\t\tgoto err;\n\t\tenqueue(&q, &qsz, stack[ssz]);\n\t} \n\n\tq = realloc(q, ++qsz * sizeof(struct hnode *));\n\tq[qsz - 1] = NULL;\n\n\tif ( ! check(q))\n\t\tgoto err;\n\n#if 0\n\thnode_print(q);\n#endif\n\treturn(q);\nerr:\n\tfor (i = 0; i < qsz; i++)\n\t\tfree(q[i]);\n\tfree(q);\n\treturn(NULL);\n}\n\nstruct hnode **\nhnode_copy(struct hnode **p)\n{\n\tstruct hnode\t**pp;\n\tsize_t\t\t  sz;\n\n\tfor (sz = 0, pp = p; NULL != *pp; pp++)\n\t\tsz++;\n\n\tpp = calloc(sz + 1, sizeof(struct hnode *));\n\tfor (sz = 0; NULL != *p; p++, sz++) {\n\t\tpp[sz] = calloc(1, sizeof(struct hnode));\n\t\tpp[sz]->type = (*p)->type;\n\t\tpp[sz]->real = (*p)->real;\n\t}\n\n\treturn(pp);\n}\n\nvoid\nhnode_free(struct hnode **p)\n{\n\tstruct hnode\t**pp;\n\n\tif (NULL == p)\n\t\treturn;\n\n\tfor (pp = p; NULL != *pp; pp++)\n\t\tfree(*pp);\n\n\tfree(p);\n}\n\n/*\n * Execute a function in prefix order given variables x (given player's\n * strategy), y (other player's strategy), and var (given player's\n * morality index).\n */\ndouble\nhnode_exec(const struct hnode *const *p, double x, double X, size_t n)\n{\n\tdouble\t\t  stack[STACKSZ];\n\tconst struct hnode *const *pp;\n\tsize_t\t\t  ssz;\n\tdouble\t\t  val;\n\n\tfor (ssz = 0, pp = p; NULL != *pp; pp++)\n\t\tswitch ((*pp)->type) {\n\t\tcase (HNODE_P1):\n\t\t\tassert(ssz < STACKSZ);\n\t\t\tstack[ssz++] = x;\n\t\t\tbreak;\n\t\tcase (HNODE_PN):\n\t\t\tassert(ssz < STACKSZ);\n\t\t\tstack[ssz++] = X;\n\t\t\tbreak;\n\t\tcase (HNODE_N):\n\t\t\tassert(ssz < STACKSZ);\n\t\t\tstack[ssz++] = (double)n;\n\t\t\tbreak;\n\t\tcase (HNODE_NUMBER):\n\t\t\tassert(ssz < STACKSZ);\n\t\t\tstack[ssz++] = (*pp)->real;\n\t\t\tbreak;\n\t\tcase (HNODE_SQRT):\n\t\t\tassert(ssz > 0);\n\t\t\tval = sqrt(stack[--ssz]);\n\t\t\tstack[ssz++] = val;\n\t\t\tbreak;\n\t\tcase (HNODE_EXPF):\n\t\t\tassert(ssz > 0);\n\t\t\tval = exp(stack[--ssz]);\n\t\t\tstack[ssz++] = val;\n\t\t\tbreak;\n\t\tcase (HNODE_ADD):\n\t\t\tassert(ssz > 1);\n\t\t\tval = stack[ssz - 2] + stack[ssz - 1];\n\t\t\tssz -= 2;\n\t\t\tstack[ssz++] = val;\n\t\t\tbreak;\n\t\tcase (HNODE_SUB):\n\t\t\tassert(ssz > 1);\n\t\t\tval = stack[ssz - 2] - stack[ssz - 1];\n\t\t\tssz -= 2;\n\t\t\tstack[ssz++] = val;\n\t\t\tbreak;\n\t\tcase (HNODE_MUL):\n\t\t\tassert(ssz > 1);\n\t\t\tval = stack[ssz - 2] * stack[ssz - 1];\n\t\t\tssz -= 2;\n\t\t\tstack[ssz++] = val;\n\t\t\tbreak;\n\t\tcase (HNODE_DIV):\n\t\t\tassert(ssz > 1);\n\t\t\tval = stack[ssz - 2] / stack[ssz - 1];\n\t\t\tssz -= 2;\n\t\t\tstack[ssz++] = val;\n\t\t\tbreak;\n\t\tcase (HNODE_EXP):\n\t\t\tassert(ssz > 1);\n\t\t\tval = pow(stack[ssz - 2], stack[ssz - 1]);\n\t\t\tssz -= 2;\n\t\t\tstack[ssz++] = val;\n\t\t\tbreak;\n\t\tcase (HNODE_POSITIVE):\n\t\t\tassert(ssz > 0);\n\t\t\tbreak;\n\t\tcase (HNODE_NEGATIVE):\n\t\t\tassert(ssz > 0);\n\t\t\tval = -(stack[--ssz]);\n\t\t\tstack[ssz++] = val;\n\t\t\tbreak;\n\t\tdefault:\n\t\t\tabort();\n\t\t}\n\n\tassert(1 == ssz);\n\treturn(stack[0]);\n}\n\nstatic void\nhnode_test_expect(double x, double X, \n\tdouble n, const char *expf, double vexp)\n{\n\tstruct hnode\t **exp;\n\tdouble\t\t   v;\n\tconst char\t  *expfp;\n\n\texpfp = expf;\n\texp = hnode_parse((const char **)&expfp);\n\tassert(NULL != exp);\n\tv = hnode_exec\n\t\t((const struct hnode *const *)exp, x, X, n);\n\tg_debug(\"pi(x=%g, X=%g, n=%g) = %s = %g (want %g)\", \n\t\tx, X, n, expf, v, vexp);\n\thnode_free(exp);\n}\n\nvoid\nhnode_test(void)\n{\n\tdouble\tx, X, n;\n\n\tx = 10.0;\n\tX = 20.0;\n\tn = 2.0;\n\thnode_test_expect(x, X, n, \n\t\t\"(1 - exp(-X)) - x\", \n\t\t(1.0 - exp(-X)) - x);\n\thnode_test_expect(x, X, n, \n\t\t\"sqrt(1 / n * X) - 0.5 * x^2\", \n\t\tsqrt(1.0 / n * X) - 0.5 * pow(x, 2.0));\n\thnode_test_expect(x, X, n, \n\t\t\"x - (X - x) * x - x^2\",\n\t\tx - (X - x) * x - pow(x, 2.0));\n\thnode_test_expect(x, X, n, \n\t\t\"x * (1 / X) - x\",\n\t\tx * (1.0 / X) - x);\n}\n", "meta": {"hexsha": "eeb79d3cad3fada0c42ac79f1107fd4d1d8c64ed", "size": 13390, "ext": "c", "lang": "C", "max_stars_repo_path": "parser.c", "max_stars_repo_name": "kristapsdz/bmigrate", "max_stars_repo_head_hexsha": "0280a899564031a5a14af87d9264cd239a89851f", "max_stars_repo_licenses": ["0BSD"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2018-03-03T17:13:19.000Z", "max_stars_repo_stars_event_max_datetime": "2018-03-03T17:13:19.000Z", "max_issues_repo_path": "parser.c", "max_issues_repo_name": "kristapsdz/bmigrate", "max_issues_repo_head_hexsha": "0280a899564031a5a14af87d9264cd239a89851f", "max_issues_repo_licenses": ["0BSD"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "parser.c", "max_forks_repo_name": "kristapsdz/bmigrate", "max_forks_repo_head_hexsha": "0280a899564031a5a14af87d9264cd239a89851f", "max_forks_repo_licenses": ["0BSD"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 21.5619967794, "max_line_length": 80, "alphanum_fraction": 0.5910380881, "num_tokens": 4603, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.44167300566462553, "lm_q2_score": 0.03067580038142513, "lm_q1q2_score": 0.013548672955632104}}
{"text": "/*\r\n * Copyright 2014 RWTH Aachen University. All rights reserved.\r\n *\r\n * Licensed under the RWTH LM License (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n#pragma once\r\n#include <gsl/gsl_cblas.h>\r\n#include <cassert>\r\n#include <cstring>\r\n#include <cmath>\r\n#include <algorithm>\r\n#include <numeric>\r\n\r\ntypedef double Real;\r\n\r\ninline void FastZero(const int size, float x[]) {\r\n  std::fill(x, x + size, 0.0f);\r\n}\r\n\r\ninline void FastZero(const int size, double x[]) {\r\n  std::fill(x, x + size, 0.0);\r\n}\r\n\r\ninline void FastCopy(const float source[],\r\n                     const int size,\r\n                     float destination[]) {\r\n  memcpy(destination, source, size * sizeof(float));\r\n}\r\n\r\ninline void FastCopy(const double source[], \r\n                     const int size,\r\n                     double destination[]) {\r\n  memcpy(destination, source, size * sizeof(double));\r\n}\r\n\r\ninline float FastMax(const float x[], const int size) {\r\n  return *std::max_element(x, x + size);\r\n}\r\n\r\ninline double FastMax(const double x[], const int size) {\r\n  return *std::max_element(x, x + size);\r\n}\r\n\r\ninline float FastComputeSum(const float x[], const int size) {\r\n  return std::accumulate(x, x + size, 0.0f);\r\n}\r\n\r\ninline double FastComputeSum(const double x[], const int size) {\r\n  return std::accumulate(x, x + size, 0.0);\r\n}\r\n\r\ninline void FastAddConstant(const float source[],\r\n                            const int size,\r\n                            const float value,\r\n                            float destination[]) {\r\n  std::transform(source,\r\n                 source + size,\r\n                 destination,\r\n                 [value](const float x) { return x + value; });\r\n}\r\n\r\ninline void FastAddConstant(const double source[],\r\n                            const int size,\r\n                            const double value,\r\n                            double destination[]) {\r\n  std::transform(source,\r\n                 source + size,\r\n                 destination,\r\n                 [value](const double x) { return x + value; });\r\n}\r\n\r\ninline void FastSubtractConstant(const float source[],\r\n                                 const int size,\r\n                                 const float value,\r\n                                 float destination[]) {\r\n  std::transform(source,\r\n                 source + size,\r\n                 destination,\r\n                 [value](const double x) { return x - value; });\r\n}\r\n\r\ninline void FastSubtractConstant(const double source[],\r\n                                 const int size,\r\n                                 const double value,\r\n                                 double destination[]) {\r\n  std::transform(source,\r\n                 source + size,\r\n                 destination,\r\n                 [value](const double x) { return x - value; });\r\n}\r\n\r\ninline void FastReverseSubtractConstant(\r\n    const float source[],\r\n    const int size,\r\n    const float value,\r\n    float destination[]) {\r\n  std::transform(source,\r\n                 source + size,\r\n                 destination,\r\n                 [value](const float x) { return value - x; });\r\n}\r\n\r\ninline void FastReverseSubtractConstant(\r\n    const double source[],\r\n    const int size,\r\n    const double value,\r\n    double destination[]) {\r\n  std::transform(source,\r\n                 source + size,\r\n                 destination,\r\n                 [value](const double x) { return value - x; });\r\n}\r\n\r\ninline void FastMultiplyByConstant(const float source[],\r\n                                   const int size,\r\n                                   const float value,\r\n                                   float destination[]) {\r\n  std::transform(source,\r\n                 source + size,\r\n                 destination,\r\n                 [value](const float x) { return value * x; });\r\n}\r\n\r\ninline void FastMultiplyByConstant(const double source[],\r\n                                   const int size,\r\n                                   const double value,\r\n                                   double destination[]) {\r\n  std::transform(source,\r\n                 source + size,\r\n                 destination,\r\n                 [value](const double x) { return value * x; });\r\n}\r\n\r\ninline void FastDivideByConstant(const float source[],\r\n                                 const int size,\r\n                                 const float value,\r\n                                 float destination[]) {\r\n  std::transform(source,\r\n                 source + size,\r\n                 destination,\r\n                 [value](const float x) { return x / value; });\r\n}\r\n\r\ninline void FastDivideByConstant(const double source[],\r\n                                 const int size,\r\n                                 const double value,\r\n                                 double destination[]) {\r\n  std::transform(source,\r\n                 source + size,\r\n                 destination,\r\n                 [value](const double x) { return x / value; });\r\n}\r\n\r\ninline void FastInvert(const float source[],\r\n                       const int size,\r\n                       float destination[]) {\r\n  std::transform(source,\r\n                 source + size,\r\n                 destination,\r\n                 [](const double x) { return 1.0f / x; });\r\n}\r\n\r\ninline void FastInvert(const double source[],\r\n                       const int size,\r\n                       double destination[]) {\r\n  std::transform(source,\r\n                 source + size,\r\n                 destination,\r\n                 [](const double x) { return 1.0 / x; });\r\n}\r\n\r\ninline void FastAdd(const float a[],\r\n                    const int size,\r\n                    const float b[],\r\n                    float c[]) {\r\n  std::transform(a,\r\n                 a + size,\r\n                 b,\r\n                 c,\r\n                 [](const float x, const float y) { return x + y; });\r\n}\r\n\r\ninline void FastAdd(const double a[],\r\n                    const int size,\r\n                    const double b[],\r\n                    double c[]) {\r\n  std::transform(a,\r\n                 a + size,\r\n                 b,\r\n                 c,\r\n                 [](const double x, const double y) { return x + y; });\r\n}\r\n\r\ninline void FastMultiplyByConstantAdd(const float alpha,\r\n                                      const float a[],\r\n                                      const int size,\r\n                                      float b[]) {\r\n  cblas_saxpy(size, alpha, a, 1, b, 1);\r\n}\r\n\r\ninline void FastMultiplyByConstantAdd(const double alpha,\r\n                                      const double a[],\r\n                                      const int size,\r\n                                      double b[]) {\r\n  cblas_daxpy(size, alpha, a, 1, b, 1);\r\n}\r\n\r\ninline void FastSub(const float a[],\r\n                    const int size,\r\n                    const float b[],\r\n                    float c[]) {\r\n  std::transform(a,\r\n                 a + size,\r\n                 b,\r\n                 c,\r\n                 [](const float x, const float y) { return x - y; });\r\n}\r\n\r\ninline void FastSub(const double a[],\r\n                    const int size,\r\n                    const double b[],\r\n                    double c[]) {\r\n  std::transform(a,\r\n                 a + size,\r\n                 b,\r\n                 c,\r\n                 [](const double x, const double y) { return x - y; });\r\n}\r\n\r\ninline void FastMultiply(const float a[],\r\n                         const int size,\r\n                         const float b[],\r\n                         float c[]) {\r\n  std::transform(a,\r\n                 a + size,\r\n                 b,\r\n                 c,\r\n                 [](const float x, const float y) { return x * y; });\r\n}\r\n\r\ninline void FastMultiply(const double a[],\r\n                         const int size,\r\n                         const double b[],\r\n                         double c[]) {\r\n  std::transform(a,\r\n                 a + size,\r\n                 b,\r\n                 c,\r\n                 [](const double x, const double y) { return x * y; });\r\n}\r\n\r\ninline void FastMultiplyAdd(const float a[],\r\n                            const int size,\r\n                            const float b[],\r\n                            float c[]) {\r\n  for (int i = 0; i < size; ++i)\r\n    c[i] += a[i] * b[i];\r\n}\r\n\r\ninline void FastMultiplyAdd(const double a[],\r\n                            const int size,\r\n                            const double b[],\r\n                            double c[]) {\r\n  for (int i = 0; i < size; ++i)\r\n    c[i] += a[i] * b[i];\r\n}\r\n\r\ninline void FastTanh(const float source[],\r\n                     const int size,\r\n                     float destination[]) {\r\n  std::transform(source,\r\n                 source + size,\r\n                 destination,\r\n                 [](const float x) { return std::tanh(x); });\r\n}\r\n\r\ninline void FastTanh(const double source[],\r\n                     const int size,\r\n                     double destination[]) {\r\n  std::transform(source,\r\n                 source + size,\r\n                 destination,\r\n                 [](const double x) { return std::tanh(x); });\r\n}\r\n\r\ninline void FastExponential(const float source[],\r\n                            const int size,\r\n                            float destination[]) {\r\n  std::transform(source,\r\n                 source + size,\r\n                 destination,\r\n                 [](const float x) { return std::exp(x); });\r\n}\r\n\r\ninline void FastExponential(const double source[],\r\n                            const int size,\r\n                            double destination[]) {\r\n  std::transform(source,\r\n                 source + size,\r\n                 destination,\r\n                 [](const double x) { return std::exp(x); });\r\n}\r\n\r\ninline void FastMatrixVectorMultiply(const float a[],\r\n                                     const bool transpose_a,\r\n                                     const int rows_a,\r\n                                     const int columns_a,\r\n                                     const float x[],\r\n                                     float y[]) {\r\n  cblas_sgemv(CblasColMajor,\r\n              transpose_a ? CblasTrans : CblasNoTrans,\r\n              rows_a,\r\n              columns_a,\r\n              1.0f,\r\n              a,\r\n              rows_a,\r\n              x,\r\n              1,\r\n              1.0f,\r\n              y,\r\n              1);\r\n}\r\n\r\ninline void FastMatrixVectorMultiply(const double a[],\r\n                                     const bool transpose_a,\r\n                                     const int rows_a,\r\n                                     const int columns_a,\r\n                                     const double x[],\r\n                                     double y[]) {\r\n  cblas_dgemv(CblasColMajor,\r\n              transpose_a ? CblasTrans : CblasNoTrans,\r\n              rows_a,\r\n              columns_a,\r\n              1.0,\r\n              a,\r\n              rows_a,\r\n              x,\r\n              1,\r\n              1.0,\r\n              y,\r\n              1);\r\n}\r\n\r\ninline void FastOuterProduct(const float alpha,\r\n                             const float x[],\r\n                             const int size_x,\r\n                             const float y[],\r\n                             const int size_y,\r\n                             float a[]) {\r\n  cblas_sger(CblasColMajor,\r\n             size_x,\r\n             size_y,\r\n             alpha,\r\n             x,\r\n             1,\r\n             y,\r\n             1,\r\n             a,\r\n             size_x);\r\n}\r\n\r\ninline void FastOuterProduct(const double alpha,\r\n                             const double x[],\r\n                             const int size_x,\r\n                             const double y[],\r\n                             const int size_y,\r\n                             double a[]) {\r\n  cblas_dger(CblasColMajor,\r\n             size_x,\r\n             size_y,\r\n             alpha,\r\n             x,\r\n             1,\r\n             y,\r\n             1,\r\n             a,\r\n             size_x);\r\n}\r\n\r\ninline void FastMatrixMatrixMultiply(\r\n      const float alpha,\r\n      const float a[],\r\n      const bool transpose_a,\r\n      const int rows_a,\r\n      const int columns_a,\r\n      const float b[],\r\n      const bool transpose_b,\r\n      const int columns_b,\r\n      float c[]) {\r\n  cblas_sgemm(CblasColMajor,\r\n              transpose_a ? CblasTrans : CblasNoTrans,\r\n              transpose_b ? CblasTrans : CblasNoTrans,\r\n              rows_a,\r\n              columns_b,\r\n              columns_a,\r\n              alpha,\r\n              a,\r\n              transpose_a ? columns_a : rows_a,\r\n              b,\r\n              transpose_b ? columns_b : columns_a,\r\n              1.0f,\r\n              c,\r\n              rows_a);\r\n}\r\n\r\ninline void FastMatrixMatrixMultiply(\r\n      const double alpha,\r\n      const double a[],\r\n      const bool transpose_a,\r\n      const int rows_a,  // m\r\n      const int columns_a,  // k\r\n      const double b[],\r\n      const bool transpose_b,\r\n      const int columns_b,  // n\r\n      double c[]) {\r\n  cblas_dgemm(CblasColMajor,\r\n              transpose_a ? CblasTrans : CblasNoTrans,\r\n              transpose_b ? CblasTrans : CblasNoTrans,\r\n              rows_a,  // m\r\n              columns_b,  // n\r\n              columns_a,  // k\r\n              alpha,\r\n              a,\r\n              transpose_a ? columns_a : rows_a,\r\n              b,\r\n              transpose_b ? columns_b : columns_a,\r\n              1.0,\r\n              c,\r\n              rows_a);\r\n}\r\n\r\ninline Real *FastMalloc(const int size) {\r\n  Real *result = new Real[size];\r\n  assert(result != nullptr || size == 0);\r\n  return result;\r\n}\r\n\r\ninline void FastFree(Real *x) {\r\n  delete [] x;\r\n}\r\n", "meta": {"hexsha": "071ae714f20d6848b23998a5cceadfb2f26f5e35", "size": 13959, "ext": "h", "lang": "C", "max_stars_repo_path": "rwthlm/fast.h", "max_stars_repo_name": "darongliu/Input_Method", "max_stars_repo_head_hexsha": "28055937fc777cbba8cbc4c87ba5a2670da7d4e2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2018-07-03T07:42:42.000Z", "max_stars_repo_stars_event_max_datetime": "2018-07-03T07:42:42.000Z", "max_issues_repo_path": "rwthlm/fast.h", "max_issues_repo_name": "darongliu/Input_Method", "max_issues_repo_head_hexsha": "28055937fc777cbba8cbc4c87ba5a2670da7d4e2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "rwthlm/fast.h", "max_forks_repo_name": "darongliu/Input_Method", "max_forks_repo_head_hexsha": "28055937fc777cbba8cbc4c87ba5a2670da7d4e2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.1584821429, "max_line_length": 76, "alphanum_fraction": 0.4335554123, "num_tokens": 2567, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.34158249943831703, "lm_q2_score": 0.039638839668221494, "lm_q1q2_score": 0.013539933928705807}}
{"text": "/****************************************************************\n *\n * Copyright (C) Max Planck Institute\n * for Biological Cybernetics, Tuebingen, Germany\n *\n * Author: Gabriele Lohmann, 2015\n *\n * This program is free software; you can redistribute it and/or\n * modify it under the terms of the GNU General Public License\n * as published by the Free Software Foundation; either version 2\n * of the License, or (at your option) any later version.\n *\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.\n *\n *****************************************************************/\n\n/*\n** trial average using spline interpolation\n**\n** G.Lohmann, May 2014\n*/\n#include <viaio/Vlib.h>\n#include <viaio/VImage.h>\n#include <viaio/mu.h>\n#include <viaio/option.h>\n\n#include <gsl/gsl_cblas.h>\n#include <gsl/gsl_matrix.h>\n#include <gsl/gsl_vector.h>\n#include <gsl/gsl_spline.h>\n\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <ctype.h>\n#include <math.h>\n\n#define ABS(x) ((x) > 0 ? (x) : -(x))\n#define SQR(x) ((x)*(x))\n\n#define LEN     10000   /* buffer length        */\n#define NTRIALS 10000   /* max number of trials */\n\ntypedef struct SpointStruct {\n  VShort x;\n  VShort y;\n  VShort z;\n} SPoint;\n\ntypedef struct TrialStruct {\n  int   id;\n  float onset;\n  float duration;\n  float height;\n} Trial;\n\n\n\nTrial trial[NTRIALS];\nint ntrials=0;\nint nevents=0;\n\nint test_ascii(int val)\n{\n  if (val >= 'a' && val <= 'z') return 1;\n  if (val >= 'A' && val <= 'Z') return 1;\n  if (val >= '0' && val <= '9') return 1;\n  if (val ==  ' ') return 1;\n  if (val == '\\0') return 1;\n  if (val == '\\n') return 1;\n  if (val == '\\r') return 1;\n  if (val == '\\t') return 1;\n  if (val == '\\v') return 1;\n  return 0;\n}\n\n\n\n/* parse design file */\nvoid ReadDesign(VString designfile)\n{\n  FILE *fp=NULL;\n  int  i,j,k,id;\n  char buf[LEN];\n  float onset=0,duration=0,height=0;\n\n  fp = fopen(designfile,\"r\");\n  if (!fp) VError(\" error opening design file %s\",designfile);\n\n  i = ntrials = nevents = 0;\n  while (!feof(fp)) {\n    for (j=0; j<LEN; j++) buf[j] = '\\0';\n    if (fgets(buf,LEN,fp) == NULL) break;\n    if (strlen(buf) < 2) continue;\n    if (buf[0] == '%' || buf[0] == '#') continue;\n    if (! test_ascii((int)buf[0])) VError(\" input file must be a text file\");\n\n    /* remove non-alphanumeric characters */\n    for (j=0; j<strlen(buf); j++) {\n      k = (int)buf[j];\n      if (!isgraph(k) && buf[j] != '\\n' && buf[j] != '\\r' && buf[j] != '\\0') {\n\tbuf[j] = ' ';\n      }\n      if (buf[j] == '\\v') buf[j] = ' '; /* remove tabs */\n      if (buf[j] == '\\t') buf[j] = ' ';\n    }\n\n    if (sscanf(buf,\"%d %f %f %f\",&id,&onset,&duration,&height) != 4)\n      VError(\" line %d: illegal input format\",i+1);\n\n    if (duration < 0.5 && duration >= -0.0001) duration = 0.5;\n    trial[i].id       = id;\n    trial[i].onset    = onset;\n    trial[i].duration = duration;\n    trial[i].height   = height;\n    i++;\n    if (i > NTRIALS) VError(\" too many trials %d\",i);\n\n    if (id > nevents) nevents = id;\n  }\n  fclose(fp);\n\n  ntrials = i;\n}\n\nint main (int argc,char *argv[])\n{\n  static VString  designfile = \"\";\n  static VShort   cond_id = 1;\n  static VShort   trial_id = 0;\n  static VDouble  temporal_resolution = 1.0;\n  static VDouble  start = 0;\n  static VDouble  length = 20;\n  static VOptionDescRec  options[] = {\n    {\"design\", VStringRepn, 1, & designfile, VRequiredOpt, NULL,\"Design file (ascii)\" },\n    {\"cond\", VShortRepn, 1, & cond_id, VOptionalOpt, NULL,\"Id of experimental condition\"},\n    {\"trial\", VShortRepn, 1, & trial_id, VOptionalOpt, NULL,\"Id of trial (starts at 0)\"},\n    {\"resolution\", VDoubleRepn, 1, & temporal_resolution, VOptionalOpt, NULL,\" output temporal resolution in secs\"},\n    {\"start\", VDoubleRepn, 1, & start, VOptionalOpt, NULL, \"start relative to beginning of trial in secs\"},\n    {\"length\", VDoubleRepn, 1, & length, VOptionalOpt, NULL, \"trial length in seconds\"},\n  };\n  FILE *in_file=NULL,*out_file=NULL;\n  VAttrList list=NULL;\n  VAttrListPosn posn;\n  int i,j,k,slice,row,col;\n  int nslices=0,nrows=0,ncols=0,ntimesteps=0;\n  double t=0;\n  char *prg = GetLipsiaName(\"vcuttrials\");\n  fprintf (stderr, \"%s\\n\", prg);\n\n\n  /*  parse command line */\n  VParseFilterCmd (VNumber (options),options,argc,argv,&in_file,&out_file);\n\n\n  /* get image dimensions, read functional data */\n  if (! (list = VReadFile (in_file, NULL))) exit (1);\n  fclose(in_file);\n\n  nslices = 0;\n  VImage tmp=NULL;\n  for (VFirstAttr (list, & posn); VAttrExists (& posn); VNextAttr (& posn)) {\n    if (VGetAttrRepn (& posn) != VImageRepn) continue;\n    VGetAttrValue (& posn, NULL,VImageRepn, & tmp);\n    /* if (VPixelRepn(tmp) != VShortRepn) continue; */\n    nslices++;\n  }\n  if (nslices < 1) VError(\" no slices\");\n\n\n  VAttrList geoinfo = VGetGeoInfo(list);\n  VImage *src = (VImage *) VCalloc(nslices,sizeof(VImage));\n  i = ntimesteps = nrows = ncols = 0;\n  for (VFirstAttr (list, & posn); VAttrExists (& posn); VNextAttr (& posn)) {\n    if (VGetAttrRepn (& posn) != VImageRepn) continue;\n    VGetAttrValue (& posn, NULL,VImageRepn, & src[i]);\n    /* if (VPixelRepn(src[i]) != VShortRepn) continue; */\n    if (VImageNBands(src[i]) > ntimesteps) ntimesteps = VImageNBands(src[i]);\n    if (VImageNRows(src[i])  > nrows)  nrows = VImageNRows(src[i]);\n    if (VImageNColumns(src[i]) > ncols) ncols = VImageNColumns(src[i]);\n    i++;\n  }\n  fprintf(stderr,\" nslices: %d, nrows: %d, ncols: %d,  ntimesteps: %d\\n\",nslices,nrows,ncols,ntimesteps);\n\n\n  /* read repetition time */\n  double tr = 0;\n  if (VGetAttr (VImageAttrList (src[0]), \"repetition_time\", NULL,\n\t\tVDoubleRepn, (VPointer) & tr) != VAttrFound) {\n    VError(\" attribute 'repetition_time' missing\");\n  }\n  tr /= 1000.0;\n  double experiment_duration = tr * (double)ntimesteps;\n\n\n  /* read design file */\n  ReadDesign(designfile);\n  \n\n  /* select trial id */\n  int tid=0,j0=-1;\n  for (j=0; j<ntrials; j++) {\n    if (trial[j].id == cond_id && tid == trial_id) {\n      j0 = j;\n      break;\n    }\n    if (trial[j].id == cond_id) tid++;\n  }\n  if (j0 < 0) VError(\"trial not found\");\n  fprintf(stderr,\" trial onset: %f\\n\",trial[j0].onset);\n\n\n\n  /* adjust start time */\n  trial[j0].onset += start;\n  if (trial[j0].onset < 0) {\n    VWarning(\" negative onset, reset to zero\");\n    trial[j0].onset = 0;\n  }\n  if (trial[j0].onset + length >= experiment_duration) {\n    VWarning(\" experiment_duration exceeded\",experiment_duration);\n    length = experiment_duration - trial[j0].onset-0.5;\n    VWarning(\" parameter '-length' set to %f\\n\",length);\n  }\n  \n  int nt = (int)(length/temporal_resolution + 0.5);\n  fprintf(stderr,\" number of output timesteps: %d\\n\",nt);  \n\n\n  /* ini output data structs  */\n  VImage *dest = (VImage *) VCalloc(nslices, sizeof(VImage));\n  VAttrList out_list = VCreateAttrList();  \n  if (geoinfo != NULL) VSetGeoInfo(geoinfo,out_list);\n  for (slice=0; slice<nslices; slice++) {\n    dest[slice] = VCreateImage(nt,nrows,ncols,VPixelRepn(src[slice]));\n    VFillImage(dest[slice],VAllBands,0);\n    VCopyImageAttrs (src[slice], dest[slice]);\n    VAppendAttr(out_list,\"image\",NULL,VImageRepn,dest[slice]);\n  }\n\n  \n  /* spline interpolation  */\n  double tstep = temporal_resolution;\n  double *xx = (double *) VCalloc(ntimesteps,sizeof(double));\n  double *yy = (double *) VCalloc(ntimesteps,sizeof(double));\n \n  gsl_interp_accel *acc = gsl_interp_accel_alloc ();\n  gsl_spline *spline = gsl_spline_alloc (gsl_interp_cspline, ntimesteps);\n\n\n  for (slice=0; slice<nslices; slice++) {\n    for (row=0; row<nrows; row++) {\n      for (col=0; col<ncols; col++) {\n\n\tfor (k=0; k<ntimesteps; k++) {\n\t  xx[k] = tr*((double)k);\n\t  yy[k] = (double)VGetPixel(src[slice],k,row,col);\n\t}\n\tgsl_spline_init (spline, xx, yy, ntimesteps);\n\n\tk=0;\n\tfor (t=0; t<length; t += tstep) {\n\t  if (k >= nt) break;\n\t  double xi = trial[j].onset + t;\n\t  double yi = 0;\n\t  if (xi < experiment_duration && xi >= 0) {\n\t    if (gsl_spline_eval_e (spline,xi,acc,&yi) == GSL_EDOM) continue;\n\t  }\n\t  VSetPixel(dest[slice],k,row,col,yi);\n\t  k++;\n\t}\n      }\n    } \n  }\n\n\n  /* write to disk */\n  if (! VWriteFile (out_file, out_list)) exit (1);\n  fprintf (stderr, \"%s: done.\\n\", argv[0]);\n  exit(0);\n}\n", "meta": {"hexsha": "289e6fb4a614fe56693e715083c58df5bc9d5409", "size": 8488, "ext": "c", "lang": "C", "max_stars_repo_path": "src/ted/vcuttrials/vcuttrials.c", "max_stars_repo_name": "zrajna/lipsia", "max_stars_repo_head_hexsha": "8e7252653bd641df8f8d22ca5a9820507f154014", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 17.0, "max_stars_repo_stars_event_min_datetime": "2017-04-10T16:33:42.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T10:55:03.000Z", "max_issues_repo_path": "src/ted/vcuttrials/vcuttrials.c", "max_issues_repo_name": "zrajna/lipsia", "max_issues_repo_head_hexsha": "8e7252653bd641df8f8d22ca5a9820507f154014", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 7.0, "max_issues_repo_issues_event_min_datetime": "2019-11-12T15:47:56.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-16T13:42:05.000Z", "max_forks_repo_path": "src/ted/vcuttrials/vcuttrials.c", "max_forks_repo_name": "zrajna/lipsia", "max_forks_repo_head_hexsha": "8e7252653bd641df8f8d22ca5a9820507f154014", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 8.0, "max_forks_repo_forks_event_min_datetime": "2017-09-29T10:33:53.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-22T08:05:46.000Z", "avg_line_length": 29.3702422145, "max_line_length": 116, "alphanum_fraction": 0.6140433553, "num_tokens": 2678, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3960681662740416, "lm_q2_score": 0.03410042473069495, "lm_q1q2_score": 0.01350609269225233}}
{"text": "/*\n * CircularDB implementation for time series data.\n *\n * Copyright (c) 2007-2009 Powerset, Inc\n * Copyright (c) Dan Grillo, Manish Dubey, Dan Sully\n *\n * All rights reserved.\n */\n\n#include \"config.h\"\n\n#include <ctype.h>\n#include <errno.h>\n#include <fcntl.h>\n#include <float.h>\n#include <inttypes.h>\n#include <math.h>\n#include <stdbool.h>\n#include <stdio.h>\n#include <stdint.h>\n#include <stdlib.h>\n#include <string.h>\n#include <sys/types.h>\n#include <sys/stat.h>\n#include <time.h>\n#include <unistd.h>\n\n/* For the aggregation interface */\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_interp.h>\n#include <gsl/gsl_sort.h>\n#include <gsl/gsl_statistics.h>\n\n#include <circulardb_interface.h>\n\n/* Future win32 support */\n#ifndef O_BINARY\n#define O_BINARY 0\n#endif\n\n/* Save away errno so it doesn't get overwritten */\nint cdb_error(void) {\n    int cdb_error = errno;\n    return cdb_error;\n}\n\nstatic void _print_record(FILE *fh, cdb_time_t time, double value, const char *date_format) {\n\n    if (date_format == NULL || strcmp(date_format, \"\") == 0) {\n\n        fprintf(fh, \"%d %.8g\\n\", (int)(time), value);\n\n    } else {\n\n        char formatted[256];\n        time_t stime = (time_t)time;\n\n        strftime(formatted, sizeof(formatted), date_format, localtime(&stime));\n\n        fprintf(fh, \"%d [%s] %.8g\\n\", (int)(time), formatted, value);\n    }\n}\n\nstatic uint64_t _physical_record_for_logical_record(cdb_header_t *header, int64_t logical_record) {\n\n    uint64_t physical_record = 0;\n\n    /* -ve indicates nth record from the end\n       +ve indicates nth record from the beginning (zero based counting for\n          this case)\n\n       -3 = seek to 3rd record from the end\n        5 = seek to 6th record from the beginning\n        0 = seek to first record (start) from the beginning\n\n       change the request for -nth record (nth record from the end)\n       to a request for mth record from the beginning, where:\n\n       m = N + n (n is -ve)\n\n       N : total num of records. */\n\n    if (logical_record < 0) {\n        int64_t rec_num_from_start = header->num_records + logical_record;\n\n        /* if asking for records more than there are in the db, just give as many as we can */\n        logical_record = rec_num_from_start >= 0 ? rec_num_from_start : 0;\n    }\n\n    if (logical_record >= header->num_records) {\n#ifdef DEBUG\n        printf(\"Can't seek to record [%\"PRIu64\"] with only [%\"PRIu64\"] in db\\n\", logical_record, header->num_records);\n#endif\n        return 0;\n    }\n\n    /* DRK unclear behavior here. Looks like if I specify -N where N >\n       num_records, I get pointed to #0, but if I specify +N where N >\n       num_records, it's an error */\n\n    /* Nth logical record (from the beginning) maps to Mth physical record\n       in the file, where:\n\n       m = (n+s) % N\n\n       s = physical record that is 0th logical record\n       N = total number of records in the db.  */\n\n    physical_record = logical_record + header->start_record;\n\n    if (header->num_records > 0) {\n        physical_record = (physical_record % header->num_records);\n    }\n\n    return physical_record;\n}\n\nstatic int64_t _seek_to_logical_record(cdb_t *cdb, int64_t logical_record) {\n\n    uint64_t physical_record = _physical_record_for_logical_record(cdb->header, logical_record);\n    uint64_t offset = HEADER_SIZE + (physical_record * RECORD_SIZE);\n\n    if (lseek(cdb->fd, offset, SEEK_SET) != offset) {\n        return -1;\n    }\n\n    return physical_record;\n}\n\nstatic cdb_time_t _time_for_logical_record(cdb_t *cdb, int64_t logical_record) {\n\n    cdb_record_t record[RECORD_SIZE];\n    cdb_time_t time = 0;\n\n    /* skip over any record that has NULL time or bad time values\n       Such datapoints in cdb indicate a corrupted cdb. */\n    while (!time || time <= 0) {\n\n        if (_seek_to_logical_record(cdb, logical_record) < 0) {\n            time = 0;\n            break;\n        }\n\n        logical_record += 1;\n\n        if (read(cdb->fd, &record, RECORD_SIZE) < 0) {\n            time = 0;\n            break;\n        }\n\n        time = record->time;\n    }\n\n    return time;\n}\n\n/* note - if no exact match, will return a record with a time greater than the requested value */\nstatic int64_t _logical_record_for_time(cdb_t *cdb, cdb_time_t req_time, int64_t start_logical_record, int64_t end_logical_record) {\n\n    bool first_time = false;\n    cdb_time_t start_time, next_time, center_time;\n    int64_t delta, center_logical_record, next_logical_record;\n\n    uint64_t num_recs = cdb->header->num_records;\n\n    /* for the very first time find start and end */\n    if (start_logical_record == 0 && end_logical_record == 0) {\n\n        start_logical_record = 0;\n        end_logical_record   = num_recs - 1;\n\n        first_time = true;\n    }\n\n    /* if no particular time was requested, just return the first one. */\n    if (req_time == 0) {\n        return start_logical_record;\n    }\n\n    /* if there are only 2 or 1 records in the search space, return the last record */\n    if (end_logical_record - start_logical_record <= 1) {\n        return end_logical_record;\n    }\n\n    start_time = _time_for_logical_record(cdb, start_logical_record);\n\n    /* if requested time is less than start_time, start_time is the best we can do. */\n    if (req_time <= start_time) {\n        return start_logical_record;\n    }\n\n    /* don't go out of bounds */\n    if (start_logical_record + 1 >= num_recs) {\n        return start_logical_record;\n    }\n\n    next_logical_record = start_logical_record;\n    next_time = start_time;\n\n    /* if _seek_to_logical_record encounters bad data it fabricates and\n       returns next good value. Try to get the *real* next rec. */\n    while ((next_time - start_time) == 0) {\n\n        next_logical_record += 1;\n\n        next_time = _time_for_logical_record(cdb, next_logical_record);\n\n        if (next_logical_record >= num_recs) {\n            break;\n        }\n    }\n\n    delta = next_time - start_time;\n\n    /* delta = 0 means that _seek_to_logical_record fabricated data on the fly */\n    if (delta == 0) {\n        return start_logical_record;\n    /* if we have wrapped over, or if the requested time is in the range of start and next, return start */\n    } else if (delta < 0) {\n        return start_logical_record;\n    } else if (req_time <= next_time) {\n        return next_logical_record;\n    }\n\n    /* for the very first binary search pivot point, take an aggressive guess to make search converge faster */\n    if (first_time) {\n        center_logical_record = (req_time - start_time) / (next_time - start_time) - 1;\n    } else {\n        center_logical_record = start_logical_record + (end_logical_record - start_logical_record) / 2;\n    }\n\n    if (num_recs > 0) {\n        center_logical_record = (center_logical_record % num_recs);\n    }\n\n    center_time = _time_for_logical_record(cdb, center_logical_record);\n\n    if (req_time >= center_time) {\n        start_logical_record = center_logical_record;\n    } else {\n        end_logical_record = center_logical_record;\n    }\n\n    return _logical_record_for_time(cdb, req_time, start_logical_record, end_logical_record);\n}\n\nbool _cdb_is_writable(cdb_t *cdb) {\n\n    /* We can't check for the O_RDONLY bit being because its defined value is zero.\n     * i.e. there are no bits set to look for. We therefore assume\n     * O_RDONLY if neither O_WRONLY nor O_RDWR are set. */\n    if (cdb->flags & O_RDWR) {\n        return true;\n    }\n\n    return false;\n}\n\nint cdb_read_header(cdb_t *cdb) {\n    struct stat st;\n\n    /* If the header has already been read from backing store do not read again */\n    if (cdb->synced == true) {\n        return CDB_SUCCESS;\n    }\n\n    if (cdb_open(cdb) != 0) {\n        return cdb_error();\n    }\n\n    if (pread(cdb->fd, cdb->header, HEADER_SIZE, 0) != HEADER_SIZE) {\n        return cdb_error();\n    }\n\n    if (strncmp(cdb->header->token, CDB_TOKEN, sizeof(CDB_TOKEN)) != 0) {\n        return CDB_EBADTOK;\n    }\n\n    if (strncmp(cdb->header->version, CDB_VERSION, sizeof(CDB_VERSION)) != 0) {\n        return CDB_EBADVER;\n    }\n\n    cdb->synced = true;\n\n    /* Calculate the number of records */\n    if (fstat(cdb->fd, &st) == 0) {\n        cdb->header->num_records = (st.st_size - HEADER_SIZE) / RECORD_SIZE;\n    } else {\n        cdb->header->num_records = 0;\n    }\n\n    return CDB_SUCCESS;\n}\n\nint cdb_write_header(cdb_t *cdb) {\n\n    if (cdb->synced) {\n        return CDB_SUCCESS;\n    }\n\n    if (_cdb_is_writable(cdb) == false) {\n        return CDB_ERDONLY;\n    }\n\n    cdb->synced = false;\n\n    if (cdb_open(cdb) > 0) {\n        return cdb_error();\n    }\n\n    if (pwrite(cdb->fd, cdb->header, HEADER_SIZE, 0) != HEADER_SIZE) {\n        return cdb_error();\n    }\n\n    cdb->synced = true;\n\n    return CDB_SUCCESS;\n}\n\nvoid cdb_print_header(cdb_t * cdb) {\n\n    printf(\"version: [%s]\\n\", cdb->header->version);\n    printf(\"name: [%s]\\n\", cdb->header->name);\n    printf(\"desc: [%s]\\n\", cdb->header->desc);\n    printf(\"units: [%s]\\n\", cdb->header->units);\n\n    if (cdb->header->type == CDB_TYPE_COUNTER) {\n        printf(\"type: [COUNTER]\\n\");\n    }\n\n    if (cdb->header->type == CDB_TYPE_GAUGE) {\n        printf(\"type: [GAUGE]\\n\");\n    }\n\n    printf(\"min_value: [%g]\\n\", cdb->header->min_value);\n    printf(\"max_value: [%g]\\n\", cdb->header->max_value);\n    printf(\"max_records: [%\"PRIu64\"]\\n\", cdb->header->max_records);\n    printf(\"num_records: [%\"PRIu64\"]\\n\", cdb->header->num_records);\n    printf(\"start_record: [%\"PRIu64\"]\\n\", cdb->header->start_record);\n}\n\nint cdb_write_records(cdb_t *cdb, cdb_record_t *records, uint64_t len, uint64_t *num_recs) {\n\n    /* read old header if it exists.\n       write a header out, since the db may not have existed.\n    */\n    uint64_t i   = 0;\n    uint64_t j   = 0;\n    off_t offset = 0;\n    *num_recs    = 0;\n\n    if (cdb_read_header(cdb) != CDB_SUCCESS) {\n        return cdb_error();\n    }\n\n    if (_cdb_is_writable(cdb) == false) {\n        return CDB_ERDONLY;\n    }\n\n    if (cdb->header->max_records <= 0) {\n        return CDB_EINVMAX;\n    }\n\n    /* Logic for writes:\n    cdb is 5 records.\n        try to write 7 records\n        len = 7\n        len + 0 > 5\n        j = (7 + 0) - 5\n        j = 2\n        i = 7 - 2\n        i = 5\n\n        need to write j records at offset: HEADER_SIZE + (cdb->header->start_record * RECORD_SIZE)\n        index into records is i\n\n        need to write i records at offset: HEADER_SIZE + (cdb->header->num_records * RECORD_SIZE)\n        index into records is 0;\n    */\n\n    /* Calculate our indicies into the records array. */\n    if (len + cdb->header->num_records >= cdb->header->max_records) {\n        j = (len + cdb->header->num_records) - cdb->header->max_records;\n        i = (len - j);\n    } else {\n        i = len;\n    }\n\n    /* If we need to wrap around */\n    if (j > 0) {\n\n        offset = HEADER_SIZE + (cdb->header->start_record * RECORD_SIZE);\n\n        cdb->header->start_record += j;\n        cdb->header->start_record %= cdb->header->max_records;\n\n        if (pwrite(cdb->fd, &records[i], (RECORD_SIZE * j), offset) != (RECORD_SIZE * j)) {\n            return cdb_error();\n        }\n\n        cdb->synced = false;\n\n        /* start_record is no longer 0, so update the header */\n        if (cdb_write_header(cdb) != CDB_SUCCESS) {\n            return cdb_error();\n        }\n    }\n\n    /* Normal case */\n    offset = HEADER_SIZE + (cdb->header->num_records * RECORD_SIZE);\n    cdb->header->num_records += i;\n\n    if (pwrite(cdb->fd, &records[0], (RECORD_SIZE * i), offset) != (RECORD_SIZE * i)) {\n        return cdb_error();\n    }\n\n    *num_recs += len;\n\n#ifdef DEBUG\n    printf(\"write_records: wrote [%\"PRIu64\"] records\\n\", *num_recs);\n#endif\n\n    return CDB_SUCCESS;\n}\n\nbool cdb_write_record(cdb_t *cdb, cdb_time_t time, double value) {\n\n    cdb_record_t record[RECORD_SIZE];\n    uint64_t num_recs = 0;\n\n    record->time  = time;\n    record->value = value;\n\n    if (cdb_write_records(cdb, record, 1, &num_recs) != CDB_SUCCESS) {\n        return false;\n    }\n\n    return true;\n}\n\nint cdb_update_records(cdb_t *cdb, cdb_record_t *records, uint64_t len, uint64_t *num_recs) {\n\n    int ret    = CDB_SUCCESS;\n    *num_recs  = 0;\n    uint64_t i = 0;\n\n    if (cdb_read_header(cdb) != CDB_SUCCESS) {\n        return cdb_error();\n    }\n\n    if (_cdb_is_writable(cdb) == false) {\n        return CDB_ERDONLY;\n    }\n\n#ifdef DEBUG\n    printf(\"in update_records with [%\"PRIu64\"] num_recs\\n\", cdb->header->num_records);\n#endif\n\n    for (i = 0; i < len; i++) {\n\n        cdb_time_t time = records[i].time;\n        cdb_time_t rtime;\n        uint64_t lrec;\n\n        lrec = _logical_record_for_time(cdb, time, 0, 0);\n\n        if (lrec >= 1) {\n            lrec -= 1;\n            /* DRK things like this are extremely confusing. some logical\n               functions are zero based? some are one? or you're trying to back up? */\n        }\n\n        rtime = _time_for_logical_record(cdb, lrec);\n\n        while (rtime < time && lrec < cdb->header->num_records - 1) {\n\n            /* DRK is this true? or is the condition (lrec - start_lrec) <\n               num_recs -- seems you can't wrap here (i.e. what if the initial\n               lrec was num_recs - 1) */\n\n            lrec += 1;\n            rtime = _time_for_logical_record(cdb, lrec);\n        }\n\n#ifdef DEBUG\n        printf(\"update_records: value: lrec [%\"PRIu64\"] time [%d] rtime [%d]\\n\", lrec, (int)time, (int)rtime);\n#endif\n\n        while (time == rtime && lrec < cdb->header->num_records - 1) {\n\n            _seek_to_logical_record(cdb, lrec);\n\n            if (write(cdb->fd, &records[0], RECORD_SIZE) != RECORD_SIZE) {\n                ret = cdb_error();\n                break;\n            }\n\n            lrec += 1;\n\n            rtime = _time_for_logical_record(cdb, lrec);\n        }\n    }\n\n    if (ret == CDB_SUCCESS) {\n\n        if (i > 0) {\n            cdb->synced = false;\n            *num_recs = i;\n        }\n\n        if (cdb_write_header(cdb) != CDB_SUCCESS) {\n            ret = cdb_error();\n        }\n    }\n\n    return ret;\n}\n\nbool cdb_update_record(cdb_t *cdb, cdb_time_t time, double value) {\n\n    cdb_record_t record[RECORD_SIZE];\n    uint64_t num_recs = 0;\n\n    record->time  = time;\n    record->value = value;\n\n    if (cdb_update_records(cdb, record, 1, &num_recs) != 0) {\n        return false;\n    }\n\n    return true;\n}\n\nint cdb_discard_records_in_time_range(cdb_t *cdb, cdb_request_t *request, uint64_t *num_recs) {\n\n    uint64_t i = 0;\n    int64_t lrec;\n    off_t offset = RECORD_SIZE;\n    *num_recs = 0;\n\n    if (cdb_read_header(cdb) != CDB_SUCCESS) {\n        return cdb_error();\n    }\n\n    if (_cdb_is_writable(cdb) == false) {\n        return CDB_ERDONLY;\n    }\n\n    lrec = _logical_record_for_time(cdb, request->start, 0, 0);\n\n    if (lrec >= 1) {\n        lrec -= 1;\n    }\n\n    for (i = lrec; i < cdb->header->num_records; i++) {\n\n        cdb_time_t rtime = _time_for_logical_record(cdb, i);\n\n        if (rtime >= request->start && rtime <= request->end) {\n\n            cdb_record_t record[RECORD_SIZE];\n\n            record->time  = rtime;\n            record->value = CDB_NAN;\n\n            if (pwrite(cdb->fd, &record, RECORD_SIZE, offset) != RECORD_SIZE) {\n                return cdb_error();\n            }\n\n            *num_recs += 1;\n        }\n    }\n\n    if (*num_recs > 0) {\n        cdb->synced = false;\n    }\n\n    if (cdb_write_header(cdb) != CDB_SUCCESS) {\n        return cdb_error();\n    }\n\n    return CDB_SUCCESS;\n}\n\nstatic int _compute_scale_factor_and_num_records(cdb_t *cdb, int64_t *num_records, int32_t *factor) {\n\n    if (cdb->header->type == CDB_TYPE_COUNTER) {\n        if (*num_records != 0) {\n\n            if (*num_records > 0) {\n                *num_records += 1;\n            } else {\n                *num_records -= 1;\n            }\n        }\n    }\n\n    if (strlen(cdb->header->units) > 0) {\n\n        int32_t multiplier = 1;\n        char *frequency;\n\n        if ((frequency = calloc(strlen(cdb->header->units), sizeof(char))) == NULL) {\n            return CDB_ENOMEM;\n        }\n\n        if ((sscanf(cdb->header->units, \"per %d %s\", &multiplier, frequency) == 2) ||\n            (sscanf(cdb->header->units, \"per %s\", frequency) == 1) ||\n            (sscanf(cdb->header->units, \"%*s per %s\", frequency) == 1)) {\n\n            if (strcmp(frequency, \"min\") == 0) {\n                *factor = 60;\n            } else if (strcmp(frequency, \"hour\") == 0) {\n                *factor = 60 * 60;\n            } else if (strcmp(frequency, \"sec\") == 0 || strcmp(frequency, \"second\") == 0) {\n                *factor = 1;\n            } else if (strcmp(frequency, \"day\") == 0) {\n                *factor = 60 * 60 * 24;\n            } else if (strcmp(frequency, \"week\") == 0) {\n                *factor = 60 * 60 * 24 * 7;\n            } else if (strcmp(frequency, \"month\") == 0) {\n                *factor = 60 * 60 * 24 * 30;\n            } else if (strcmp(frequency, \"quarter\") == 0) {\n                *factor = 60 * 60 * 24 * 90;\n            } else if (strcmp(frequency, \"year\") == 0) {\n                *factor = 60 * 60 * 24 * 365;\n            }\n\n            if (*factor != 0) {\n                *factor *= multiplier;\n            }\n        }\n\n        free(frequency);\n    }\n\n    return CDB_SUCCESS;\n}\n\n/* Statistics code\n * Make only one call to reading for a particular time range and compute all our stats\n */\nvoid _compute_statistics(cdb_range_t *range, uint64_t *num_recs, cdb_record_t *records) {\n\n    uint64_t i     = 0;\n    uint64_t valid = 0;\n    double sum     = 0.0;\n    double *values = calloc(*num_recs, sizeof(double));\n\n    for (i = 0; i < *num_recs; i++) {\n\n        if (!isnan(records[i].value)) {\n\n            sum += values[valid] = records[i].value;\n            valid++;\n        }\n    }\n\n    range->num_recs = valid;\n    range->mean     = gsl_stats_mean(values, 1, valid);\n    range->max      = gsl_stats_max(values, 1, valid);\n    range->min      = gsl_stats_min(values, 1, valid);\n    range->sum      = sum;\n    range->stddev   = gsl_stats_sd(values, 1, valid);\n    range->absdev   = gsl_stats_absdev(values, 1, valid);\n\n    /* The rest need sorted data */\n    gsl_sort(values, 1, valid);\n\n    range->median   = gsl_stats_median_from_sorted_data(values, 1, valid);\n    range->pct95th  = gsl_stats_quantile_from_sorted_data(values, 1, valid, 0.95);\n    range->pct75th  = gsl_stats_quantile_from_sorted_data(values, 1, valid, 0.75);\n    range->pct50th  = gsl_stats_quantile_from_sorted_data(values, 1, valid, 0.50);\n    range->pct25th  = gsl_stats_quantile_from_sorted_data(values, 1, valid, 0.25);\n\n    /* MAD must come last because it alters the values array\n     * http://en.wikipedia.org/wiki/Median_absolute_deviation */\n    for (i = 0; i < valid; i++) {\n        values[i] = fabs(values[i] - range->median);\n\n        if (values[i] < 0.0) {\n            values[i] *= -1.0;\n        }\n    }\n\n    /* Final sort is required MAD */\n    gsl_sort(values, 1, valid);\n    range->mad = gsl_stats_median_from_sorted_data(values, 1, valid);\n\n    free(values);\n}\n\ndouble cdb_get_statistic(cdb_range_t *range, cdb_statistics_enum_t type) {\n\n    switch (type) {\n        case CDB_MEDIAN:\n            return range->median;\n        case CDB_MAD:\n            return range->mad;\n        case CDB_95TH:\n            return range->pct95th;\n        case CDB_75TH:\n            return range->pct75th;\n        case CDB_50TH:\n            return range->pct50th;\n        case CDB_25TH:\n            return range->pct25th;\n        case CDB_MEAN:\n            return range->mean;\n        case CDB_SUM:\n            return range->sum;\n        case CDB_MAX:\n            return range->max;\n        case CDB_MIN:\n            return range->min;\n        case CDB_STDDEV:\n            return range->stddev;\n        case CDB_ABSDEV:\n            return range->absdev;\n        default:\n            fprintf(stderr, \"aggregate_using_function_for_records() function: [%d] not supported\\n\", type);\n            return CDB_FAILURE;\n    }\n}\n\nstatic int _cdb_read_records(cdb_t *cdb, cdb_request_t *request, uint64_t *num_recs, cdb_record_t **records) {\n\n    int64_t first_requested_logical_record;\n    int64_t last_requested_logical_record;\n    uint64_t last_requested_physical_record;\n    int64_t seek_physical_record;\n\n    cdb_record_t *buffer = NULL;\n\n    if (cdb_read_header(cdb) != CDB_SUCCESS) {\n        return cdb_error();\n    }\n\n    if (request->start != 0 && request->end != 0 && request->end < request->start) {\n        return CDB_ETMRANGE;\n    }\n\n    if (cdb->header == NULL || cdb->synced == false) {\n        return CDB_ESANITY;\n    }\n\n    /* bail out if there are no records */\n    if (cdb->header->num_records <= 0) {\n        return CDB_ENORECS;\n    }\n\n    /*\n      get the number of requested records:\n\n      -ve indicates n records from the beginning\n      +ve indicates n records off of the end.\n      0 or undef means the whole thing.\n\n      switch the meaning of -ve/+ve to be more array like\n    */\n    if (request->count != 0) {\n        request->count = -request->count;\n    }\n\n#ifdef DEBUG\n    printf(\"read_records start: [%ld]\\n\", request->start);\n    printf(\"read_records end: [%ld]\\n\", request->end);\n    printf(\"read_records num_requested: [%\"PRIu64\"]\\n\", request->count);\n#endif\n\n    if (request->count != 0 && request->count < 0 && request->start == 0) {\n        /* if reading only few records from the end, just set -ve offset to seek to */\n        first_requested_logical_record = request->count;\n\n    } else {\n        /* compute which record to start reading from the beginning, based on start time specified. */\n        first_requested_logical_record = _logical_record_for_time(cdb, request->start, 0, 0);\n    }\n\n    /* if end is not defined, read all the records or only read uptill the specified record. */\n    if (request->end == 0) {\n\n        last_requested_logical_record = cdb->header->num_records - 1;\n\n    } else {\n\n        last_requested_logical_record = _logical_record_for_time(cdb, request->end, 0, 0);\n\n        /* this can return something > end, check for that */\n        if (_time_for_logical_record(cdb, last_requested_logical_record) > request->end) {\n            last_requested_logical_record -= 1;\n        }\n    }\n\n    last_requested_physical_record = (last_requested_logical_record + cdb->header->start_record) % cdb->header->num_records;\n\n    /* After _seek_to_logical_record(), we're at the offset to read from. */\n    seek_physical_record = _seek_to_logical_record(cdb, first_requested_logical_record);\n\n    if (last_requested_physical_record >= seek_physical_record) {\n\n        uint64_t nrec = (last_requested_physical_record - seek_physical_record + 1);\n        uint64_t rlen = RECORD_SIZE * nrec;\n\n        if ((buffer = calloc(1, rlen)) == NULL) {\n            free(buffer);\n            return CDB_ENOMEM;\n        }\n\n        if (read(cdb->fd, buffer, rlen) != rlen) {\n            free(buffer);\n            return cdb_error();\n        }\n\n        *num_recs = nrec;\n\n    } else {\n\n        /* We've wrapped around the end of the file */\n        uint64_t nrec1 = (cdb->header->num_records - seek_physical_record);\n        uint64_t nrec2 = (last_requested_physical_record + 1);\n\n        uint64_t rlen1 = RECORD_SIZE * nrec1;\n        uint64_t rlen2 = RECORD_SIZE * nrec2;\n\n        if ((buffer = calloc(1, rlen1 + rlen2)) == NULL) {\n            free(buffer);\n            return CDB_ENOMEM;\n        }\n\n        /* Read at the offset set by _seek_to_logical_record() */\n        if (read(cdb->fd, buffer, rlen1) != rlen1) {\n            free(buffer);\n            return cdb_error();\n        }\n\n        /* And then the wrap around portion past the header. */\n        if (pread(cdb->fd, &buffer[nrec1], rlen2, HEADER_SIZE) != rlen2) {\n            free(buffer);\n            return cdb_error();\n        }\n\n        *num_recs = nrec1 + nrec2;\n    }\n\n    /* Deal with cooking the output */\n    if (request->cooked) {\n\n        bool check_min_max = true;\n        int32_t factor = 0;\n        uint64_t i = 0;\n        uint64_t cooked_recs = 0;\n        double prev_value = 0.0;\n        cdb_time_t prev_date = 0;\n        cdb_record_t *crecords;\n\n        if ((crecords = calloc(*num_recs, RECORD_SIZE)) == NULL) {\n            free(crecords);\n            free(buffer);\n            return CDB_ENOMEM;\n        }\n\n        if (_compute_scale_factor_and_num_records(cdb, &request->count, &factor)) {\n            free(crecords);\n            free(buffer);\n            return cdb_error();\n        }\n\n        if (cdb->header->min_value == 0 && cdb->header->max_value == 0) {\n            check_min_max = false;\n        }\n\n        for (i = 0; i < *num_recs; i++) {\n\n            cdb_time_t date = buffer[i].time;\n            double value    = buffer[i].value;\n\n            if (cdb->header->type == CDB_TYPE_COUNTER) {\n                double new_value = value;\n                value = CDB_NAN;\n\n                if (!isnan(prev_value) && !isnan(new_value)) {\n\n                    double val_delta = new_value - prev_value;\n\n                    if (val_delta >= 0) {\n                        value = val_delta;\n                    }\n                }\n\n                prev_value = new_value;\n            }\n\n            if (factor != 0 && cdb->header->type == CDB_TYPE_COUNTER) {\n\n                /* Skip the first entry, since it's absolute and is needed\n                 * to calculate the second */\n                if (prev_date == 0) {\n                    prev_date = date;\n                    continue;\n                }\n\n                cdb_time_t time_delta = date - prev_date;\n\n                if (time_delta > 0 && !isnan(value)) {\n                    value = factor * (value / time_delta);\n                }\n\n                prev_date = date;\n            }\n\n            /* Check for min/max boundaries */\n            /* Should this be done on write instead of read? */\n            if (check_min_max && !isnan(value)) {\n                if (value > cdb->header->max_value || value < cdb->header->min_value) {\n                    value = CDB_NAN;\n                }\n            }\n\n            /* Copy the munged data to our new array, since we might skip\n             * elements. Also keep in mind mmap for the future */\n            crecords[cooked_recs].time  = date;\n            crecords[cooked_recs].value = value;\n            cooked_recs += 1;\n        }\n\n        /* Now swap our cooked records for the buffer, so we can slice it as needed. */\n        free(buffer);\n        buffer = crecords;\n        *num_recs = cooked_recs;\n    }\n\n    /* If we've been requested to average the records & timestamps */\n    if (request->step > 1) {\n\n        cdb_record_t *arecords;\n        uint32_t step      = request->step;\n        uint64_t step_recs = 0;\n        uint64_t leftover  = (*num_recs % step);\n        uint64_t walkend   = (*num_recs - leftover);\n        uint64_t i = 0;\n\n        if ((arecords = calloc(((*num_recs / step) + leftover), RECORD_SIZE)) == NULL) {\n            free(arecords);\n            free(buffer);\n            return CDB_ENOMEM;\n        }\n\n        /* Walk our list of cooked records, jumping ahead by the given step.\n           For each set of records within that step, we want to get the average\n           for those records and place them into a new array.\n         */\n        for (i = 0; i < walkend; i += step) {\n\n            uint64_t j = 0;\n            double xi[step];\n            double yi[step];\n\n            for (j = 0; j < step; j++) {\n\n                /* No NaNs on average - they cause bogus graphs. Is there a\n                 * better value than 0 to use here? */\n                if (isnan(buffer[i+j].value)) {\n                    buffer[i+j].value = 0;\n                }\n\n                xi[j] = (double)buffer[i+j].time;\n                yi[j] = buffer[i+j].value;\n            }\n\n            arecords[step_recs].time  = (cdb_time_t)gsl_stats_mean(xi, 1, step);\n            arecords[step_recs].value = gsl_stats_mean(yi, 1, step);\n            step_recs += 1;\n        }\n\n        /* Now collect from the last step point to the end & average. */\n        if (leftover > 0) {\n            uint64_t leftover_start = *num_recs - leftover;\n\n            uint64_t j = 0;\n            double xi[leftover];\n            double yi[leftover];\n\n            for (i = leftover_start; i < *num_recs; i++) {\n\n                /* No NaNs on average - they cause bogus graphs. Is there a\n                 * better value than 0 to use here? */\n                if (isnan(buffer[i].value)) {\n                    buffer[i].value = 0;\n                }\n\n                xi[j] = (double)buffer[i].time;\n                yi[j] = buffer[i].value;\n                j++;\n            }\n\n            arecords[step_recs].time  = (cdb_time_t)gsl_stats_mean(xi, 1, j);\n            arecords[step_recs].value = gsl_stats_mean(yi, 1, j);\n            step_recs += 1;\n        }\n\n        free(buffer);\n        buffer = arecords;\n        *num_recs = step_recs;\n    }\n\n    /* now pull out the number of requested records if asked */\n    if (request->count != 0 && *num_recs >= abs(request->count)) {\n\n        uint64_t start_index = 0;\n\n        if (request->count <= 0) {\n            start_index = *num_recs - abs(request->count);\n        }\n\n        *num_recs = abs(request->count);\n\n        if ((*records  = calloc(*num_recs, RECORD_SIZE)) == NULL) {\n            free(buffer);\n            return CDB_ENOMEM;\n        }\n\n        memcpy(*records, &buffer[start_index], RECORD_SIZE * *num_recs);\n\n        free(buffer);\n\n    } else {\n\n        *records = buffer;\n    }\n\n    return CDB_SUCCESS;\n}\n\nint cdb_read_records(cdb_t *cdb, cdb_request_t *request,\n    uint64_t *num_recs, cdb_record_t **records, cdb_range_t *range) {\n\n    int ret   = CDB_SUCCESS;\n\n    ret = _cdb_read_records(cdb, request, num_recs, records);\n\n    if (ret == CDB_SUCCESS) {\n\n        if (*num_recs > 0) {\n            range->start_time = request->start;\n            range->end_time   = request->end;\n\n            _compute_statistics(range, num_recs, *records);\n        }\n    }\n\n    return ret;\n}\n\nvoid cdb_print_records(cdb_t *cdb, cdb_request_t *request, FILE *fh, const char *date_format) {\n\n    uint64_t i = 0;\n    uint64_t num_recs = 0;\n\n    cdb_record_t *records = NULL;\n\n    if (_cdb_read_records(cdb, request, &num_recs, &records) == CDB_SUCCESS) {\n\n        for (i = 0; i < num_recs; i++) {\n\n            _print_record(fh, records[i].time, records[i].value, date_format);\n        }\n    }\n\n    free(records);\n}\n\nvoid cdb_print(cdb_t *cdb) {\n\n    const char *date_format = \"%Y-%m-%d %H:%M:%S\";\n    cdb_request_t request;\n\n    request.start  = 0;\n    request.end    = 0;\n    request.count  = 0;\n    request.step   = 0;\n    request.cooked = false;\n\n    printf(\"============== Header ================\\n\");\n\n    if (cdb_read_header(cdb) == CDB_SUCCESS) {\n        cdb_print_header(cdb);\n    }\n\n    if (cdb->header->type == CDB_TYPE_COUNTER) {\n\n        printf(\"============= Raw Counter Records =============\\n\");\n        cdb_print_records(cdb, &request, stdout, date_format);\n        printf(\"============== End Raw Counter Records ==============\\n\");\n\n        printf(\"============== Cooked Records ================\\n\");\n\n    } else {\n        printf(\"============== Records ================\\n\");\n    }\n\n    request.cooked = true;\n    cdb_print_records(cdb, &request, stdout, date_format);\n\n    printf(\"============== End ================\\n\");\n}\n\n/* Take in an array of cdbs */\nint cdb_read_aggregate_records(cdb_t **cdbs, int num_cdbs, cdb_request_t *request,\n    uint64_t *driver_num_recs, cdb_record_t **records, cdb_range_t *range) {\n\n    uint64_t i = 0;\n    int ret    = CDB_SUCCESS;\n    cdb_record_t *driver_records = NULL;\n    *driver_num_recs = 0;\n\n    if (cdbs[0] == NULL) {\n        return CDB_ESANITY;\n    }\n\n    /* The first cdb is the driver */\n    ret = _cdb_read_records(cdbs[0], request, driver_num_recs, &driver_records);\n\n    if (ret != CDB_SUCCESS) {\n        fprintf(stderr, \"Bailed on: %s\\n\", cdbs[0]->filename);\n        free(driver_records);\n        return ret;\n    }\n\n    if ((*records = calloc(*driver_num_recs, RECORD_SIZE)) == NULL) {\n        free(driver_records);\n        return CDB_ENOMEM;\n    }\n\n    if (*driver_num_recs <= 1) {\n        free(driver_records);\n        return CDB_EINTERPD;\n    }\n\n    double *driver_x_values   = calloc(*driver_num_recs, sizeof(double));\n    double *driver_y_values   = calloc(*driver_num_recs, sizeof(double));\n    double *follower_x_values = calloc(*driver_num_recs, sizeof(double));\n    double *follower_y_values = calloc(*driver_num_recs, sizeof(double));\n\n    for (i = 0; i < *driver_num_recs; i++) {\n        (*records)[i].time  = driver_x_values[i] = driver_records[i].time;\n        (*records)[i].value = driver_y_values[i] = driver_records[i].value;\n    }\n\n    /* initialize and allocate the gsl objects  */\n    gsl_interp_accel *accel = gsl_interp_accel_alloc();\n    gsl_interp *interp = gsl_interp_alloc(gsl_interp_linear, *driver_num_recs);\n\n    /* Allows 0.0 to be returned as a valid yi */\n    gsl_set_error_handler_off();\n\n    gsl_interp_init(interp, driver_x_values, driver_y_values, *driver_num_recs);\n\n    for (i = 1; i < num_cdbs; i++) {\n\n        uint64_t j = 0;\n        uint64_t follower_num_recs = 0;\n\n        cdb_record_t *follower_records = NULL;\n\n        ret = _cdb_read_records(cdbs[i], request, &follower_num_recs, &follower_records);\n\n        /* Just bail, free all allocations below and let the error bubble up */\n        if (ret == CDB_SUCCESS && follower_num_recs != 0) {\n\n            for (j = 0; j < *driver_num_recs; j++) {\n\n                /* Check for out of bounds */\n                if (j >= follower_num_recs) {\n                    break;\n                }\n\n                follower_x_values[j] = follower_records[j].time;\n                follower_y_values[j] = follower_records[j].value;\n            }\n\n            for (j = 0; j < *driver_num_recs; j++) {\n\n                double yi = gsl_interp_eval(interp, follower_x_values, follower_y_values, driver_x_values[j], accel);\n\n                if (isnormal(yi)) {\n                    (*records)[j].value += yi;\n                }\n            }\n        }\n\n        free(follower_records);\n\n        if (ret != CDB_SUCCESS) {\n            break;\n        }\n    }\n\n    if (ret == CDB_SUCCESS && *driver_num_recs > 0) {\n        /* Compute all the statistics for this range */\n        range->start_time = request->start;\n        range->end_time   = request->end;\n\n        _compute_statistics(range, driver_num_recs, *records);\n    }\n\n    free(driver_x_values);\n    free(driver_y_values);\n    free(follower_x_values);\n    free(follower_y_values);\n\n    gsl_interp_free(interp);\n    gsl_interp_accel_free(accel);\n    free(driver_records);\n\n    return ret;\n}\n\nvoid cdb_print_aggregate_records(cdb_t **cdbs, int32_t num_cdbs, cdb_request_t *request, FILE *fh, const char *date_format) {\n\n    uint64_t i = 0;\n    uint64_t num_recs = 0;\n\n    cdb_record_t *records = NULL;\n    cdb_range_t *range = calloc(1, sizeof(cdb_range_t));\n\n    cdb_read_aggregate_records(cdbs, num_cdbs, request, &num_recs, &records, range);\n\n    for (i = 0; i < num_recs; i++) {\n\n        _print_record(fh, records[i].time, records[i].value, date_format);\n    }\n\n    free(range);\n    free(records);\n}\n\nvoid cdb_generate_header(cdb_t *cdb, char* name, char* desc, uint64_t max_records, int32_t type,\n    char* units, uint64_t min_value, uint64_t max_value) {\n\n    if (max_records == 0) {\n        max_records = CDB_DEFAULT_RECORDS;\n    }\n\n    if (type == 0) {\n        cdb->header->type = CDB_DEFAULT_DATA_TYPE;\n    }\n\n    if (units == NULL || (strcmp(units, \"\") == 0)) {\n        units = (char*)CDB_DEFAULT_DATA_UNIT;\n    }\n\n    if (desc == NULL) {\n        desc = (char*)\"\";\n    }\n\n    memset(cdb->header->name, 0, sizeof(cdb->header->name));\n    memset(cdb->header->desc, 0, sizeof(cdb->header->desc));\n    memset(cdb->header->units, 0, sizeof(cdb->header->units));\n    memset(cdb->header->version, 0, sizeof(cdb->header->version));\n    memset(cdb->header->token, 0, sizeof(cdb->header->token));\n\n    strncpy(cdb->header->name, name, sizeof(cdb->header->name));\n    strncpy(cdb->header->desc, desc, sizeof(cdb->header->desc));\n    strncpy(cdb->header->units, units, sizeof(cdb->header->units));\n    strncpy(cdb->header->version, CDB_VERSION, sizeof(cdb->header->version));\n    strncpy(cdb->header->token, CDB_TOKEN, sizeof(cdb->header->token));\n\n    cdb->header->type         = type;\n    cdb->header->max_records  = max_records;\n    cdb->header->min_value    = min_value;\n    cdb->header->max_value    = max_value;\n    cdb->header->num_records  = 0;\n    cdb->header->start_record = 0;\n}\n\ncdb_t* cdb_new(void) {\n\n    cdb_t *cdb  = calloc(1, sizeof(cdb_t));\n    cdb->header = calloc(1, HEADER_SIZE);\n\n    cdb->fd = -1;\n    cdb->synced = false;\n    cdb->flags = -1;\n    cdb->mode = -1;\n\n    return cdb;\n}\n\ncdb_request_t cdb_new_request(void) {\n    cdb_request_t request;\n    memset (&request, 0, sizeof (request));\n    request.start  = 0;\n    request.end    = 0;\n    request.count  = 0;\n    request.cooked = true;\n    request.step   = 0;\n    return request;\n}\n\nint cdb_open(cdb_t *cdb) {\n\n    if (cdb->fd >= 0) {\n        return CDB_SUCCESS;\n    }\n\n    /* Default flags if none were set */\n    if (cdb->flags == -1) {\n        cdb->flags = O_RDONLY|O_BINARY;\n    }\n\n    /* A cdb can't be write only - we need to read the header */\n    if (cdb->flags & O_WRONLY) {\n        cdb->flags = O_RDWR;\n    }\n\n    if (cdb->mode == -1) {\n        cdb->mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH;\n    }\n\n    cdb->fd = open(cdb->filename, cdb->flags, cdb->mode);\n\n    if (cdb->fd < 0) {\n        return cdb_error();\n    }\n\n    return CDB_SUCCESS;\n}\n\nint cdb_close(cdb_t *cdb) {\n\n    if (cdb != NULL) {\n\n        if (cdb->fd > 0) {\n            if (close(cdb->fd) != 0) {\n                return cdb_error();\n            }\n            cdb->fd = -1;\n        }\n    }\n\n    return CDB_SUCCESS;\n}\n\nint cdb_free(cdb_t *cdb) {\n    int ret = CDB_SUCCESS;\n\n    if (cdb != NULL) {\n\n        if (cdb->header != NULL) {\n            ret = cdb_close(cdb);\n            free(cdb->header);\n            cdb->header = NULL;\n        }\n\n        free(cdb);\n        cdb = NULL;\n    }\n\n    return ret;\n}\n\n/* -*- Mode: C; tab-width: 4 -*- */\n/* vim: set tabstop=4 expandtab shiftwidth=4: */\n", "meta": {"hexsha": "fba1152dd4938c8f72aea83aea7fba0d1f84902e", "size": 38051, "ext": "c", "lang": "C", "max_stars_repo_path": "src/circulardb.c", "max_stars_repo_name": "dsully/circulardb", "max_stars_repo_head_hexsha": "8191d65e18324e5c2e7481de8ed3281ab197d205", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 5.0, "max_stars_repo_stars_event_min_datetime": "2015-12-24T12:59:03.000Z", "max_stars_repo_stars_event_max_datetime": "2016-11-25T03:35:03.000Z", "max_issues_repo_path": "src/circulardb.c", "max_issues_repo_name": "dsully/circulardb", "max_issues_repo_head_hexsha": "8191d65e18324e5c2e7481de8ed3281ab197d205", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2020-05-09T08:28:27.000Z", "max_issues_repo_issues_event_max_datetime": "2020-05-09T08:28:27.000Z", "max_forks_repo_path": "src/circulardb.c", "max_forks_repo_name": "dsully/circulardb", "max_forks_repo_head_hexsha": "8191d65e18324e5c2e7481de8ed3281ab197d205", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.8761904762, "max_line_length": 132, "alphanum_fraction": 0.5749651783, "num_tokens": 10329, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.5, "lm_q2_score": 0.026759283088424575, "lm_q1q2_score": 0.013379641544212287}}
{"text": "/* ode-initval/control.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n */\n\n/* Author:  G. Jungman */\n\n#include <config.h>\n#include <stdlib.h>\n#include <gsl/gsl_math.h>\n#include <gsl/gsl_errno.h>\n#include \"gsl_odeiv.h\"\n\ngsl_odeiv_control *\ngsl_odeiv_control_alloc(const gsl_odeiv_control_type * T)\n{\n  gsl_odeiv_control * c = \n    (gsl_odeiv_control *) malloc(sizeof(gsl_odeiv_control));\n\n  if(c == 0) \n    {\n      GSL_ERROR_NULL (\"failed to allocate space for control struct\", \n                      GSL_ENOMEM);\n    };\n\n  c->type = T;\n  c->state = c->type->alloc();\n\n  if (c->state == 0)\n    {\n      free (c);\t\t/* exception in constructor, avoid memory leak */\n\n      GSL_ERROR_NULL (\"failed to allocate space for control state\", \n                      GSL_ENOMEM);\n    };\n\n  return c;\n}\n\nint\ngsl_odeiv_control_init(gsl_odeiv_control * c, \n                       double eps_abs, double eps_rel, \n                       double a_y, double a_dydt)\n{\n  return c->type->init (c->state, eps_abs, eps_rel, a_y, a_dydt);\n}\n\nvoid\ngsl_odeiv_control_free(gsl_odeiv_control * c)\n{\n  c->type->free(c->state);\n  free(c);\n}\n\nconst char *\ngsl_odeiv_control_name(const gsl_odeiv_control * c)\n{\n  return c->type->name;\n}\n\nint\ngsl_odeiv_control_hadjust (gsl_odeiv_control * c, gsl_odeiv_step * s, const double y0[], const double yerr[], const double dydt[], double * h)\n{\n  return c->type->hadjust(c->state, s->dimension, s->type->order(s->state),\n                          y0, yerr, dydt, h);\n}\n", "meta": {"hexsha": "1b3a132b69ab613e85f36b542772ad6955991d95", "size": 2202, "ext": "c", "lang": "C", "max_stars_repo_path": "code/em/treba/gsl-1.0/ode-initval/control.c", "max_stars_repo_name": "ICML14MoMCompare/spectral-learn", "max_stars_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "code/em/treba/gsl-1.0/ode-initval/control.c", "max_issues_repo_name": "ICML14MoMCompare/spectral-learn", "max_issues_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/em/treba/gsl-1.0/ode-initval/control.c", "max_forks_repo_name": "ICML14MoMCompare/spectral-learn", "max_forks_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2015-10-02T01:32:59.000Z", "max_forks_repo_forks_event_max_datetime": "2015-10-02T01:32:59.000Z", "avg_line_length": 27.1851851852, "max_line_length": 142, "alphanum_fraction": 0.6634877384, "num_tokens": 615, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4416730056646256, "lm_q2_score": 0.02976009545188317, "lm_q1q2_score": 0.013144230807099394}}
{"text": "// Copyright (c) 2017, Lawrence Livermore National Security, LLC. Produced at\n// the Lawrence Livermore National Laboratory. LLNL-CODE-734707. All Rights\n// reserved. See files LICENSE and NOTICE for details.\n//\n// This file is part of CEED, a collection of benchmarks, miniapps, software\n// libraries and APIs for efficient high-order finite element and spectral\n// element discretizations for exascale applications. For more information and\n// source code availability see http://github.com/ceed.\n//\n// The CEED research is supported by the Exascale Computing Project 17-SC-20-SC,\n// a collaborative effort of two U.S. Department of Energy organizations (Office\n// of Science and the National Nuclear Security Administration) responsible for\n// the planning and preparation of a capable exascale ecosystem, including\n// software, applications, hardware, advanced system engineering and early\n// testbed platforms, in support of the nation's exascale computing imperative.\n\n#ifndef setup_h\n#define setup_h\n\n#include <stdbool.h>\n#include <string.h>\n#include <petsc.h>\n#include <petscdmplex.h>\n#include <petscfe.h>\n#include <ceed.h>\n#include \"qfunctions/bps/common.h\"\n#include \"qfunctions/bps/bp1.h\"\n#include \"qfunctions/bps/bp2.h\"\n#include \"qfunctions/bps/bp3.h\"\n#include \"qfunctions/bps/bp4.h\"\n\n// -----------------------------------------------------------------------------\n// PETSc Operator Structs\n// -----------------------------------------------------------------------------\n\n// Data for PETSc Matshell\ntypedef struct UserO_ *UserO;\nstruct UserO_ {\n  MPI_Comm comm;\n  DM dm;\n  Vec Xloc, Yloc, diag;\n  CeedVector xceed, yceed;\n  CeedOperator op;\n  Ceed ceed;\n};\n\n// Data for PETSc Interp/Restrict Matshells\ntypedef struct UserIR_ *UserIR;\nstruct UserIR_ {\n  MPI_Comm comm;\n  DM dmc, dmf;\n  Vec Xloc, Yloc, mult;\n  CeedVector ceedvecc, ceedvecf;\n  CeedOperator op;\n  Ceed ceed;\n};\n\n// -----------------------------------------------------------------------------\n// libCEED Data Struct\n// -----------------------------------------------------------------------------\n\n// libCEED data struct for level\ntypedef struct CeedData_ *CeedData;\nstruct CeedData_ {\n  Ceed ceed;\n  CeedBasis basisx, basisu, basisctof;\n  CeedElemRestriction Erestrictx, Erestrictu, Erestrictxi, Erestrictui,\n                      Erestrictqdi;\n  CeedQFunction qf_apply;\n  CeedOperator op_apply, op_restrict, op_interp;\n  CeedVector qdata, xceed, yceed;\n};\n\n// -----------------------------------------------------------------------------\n// Command Line Options\n// -----------------------------------------------------------------------------\n\n// Coarsening options\ntypedef enum {\n  COARSEN_UNIFORM = 0, COARSEN_LOGARITHMIC = 1\n} coarsenType;\nstatic const char *const coarsenTypes [] = {\"uniform\",\"logarithmic\",\n                                            \"coarsenType\",\"COARSEN\",0\n                                           };\n\n// -----------------------------------------------------------------------------\n// Boundary Conditions\n// -----------------------------------------------------------------------------\n\n// Diff boundary condition function\nPetscErrorCode BCsDiff(PetscInt dim, PetscReal time, const PetscReal x[],\n                       PetscInt ncompu, PetscScalar *u, void *ctx) {\n  // *INDENT-OFF*\n  #ifndef M_PI\n  #define M_PI    3.14159265358979323846\n  #endif\n  // *INDENT-ON*\n  const CeedScalar c[3] = { 0, 1., 2. };\n  const CeedScalar k[3] = { 1., 2., 3. };\n\n  PetscFunctionBeginUser;\n\n  for (PetscInt i = 0; i < ncompu; i++)\n    u[i] = sin(M_PI*(c[0] + k[0]*x[0])) *\n           sin(M_PI*(c[1] + k[1]*x[1])) *\n           sin(M_PI*(c[2] + k[2]*x[2]));\n\n  PetscFunctionReturn(0);\n}\n\n// Mass boundary condition function\nPetscErrorCode BCsMass(PetscInt dim, PetscReal time, const PetscReal x[],\n                       PetscInt ncompu, PetscScalar *u, void *ctx) {\n  PetscFunctionBeginUser;\n\n  for (PetscInt i = 0; i < ncompu; i++)\n    u[i] = PetscSqrtScalar(PetscSqr(x[0]) + PetscSqr(x[1]) +\n                           PetscSqr(x[2]));\n\n  PetscFunctionReturn(0);\n}\n\n// Create BC label\nstatic PetscErrorCode CreateBCLabel(DM dm, const char name[]) {\n  int ierr;\n  DMLabel label;\n\n  PetscFunctionBeginUser;\n\n  ierr = DMCreateLabel(dm, name); CHKERRQ(ierr);\n  ierr = DMGetLabel(dm, name, &label); CHKERRQ(ierr);\n  ierr = DMPlexMarkBoundaryFaces(dm, 1, label); CHKERRQ(ierr);\n  ierr = DMPlexLabelComplete(dm, label); CHKERRQ(ierr);\n\n  PetscFunctionReturn(0);\n}\n\n// -----------------------------------------------------------------------------\n// BP Option Data\n// -----------------------------------------------------------------------------\n\n// BP options\ntypedef enum {\n  CEED_BP1 = 0, CEED_BP2 = 1, CEED_BP3 = 2,\n  CEED_BP4 = 3, CEED_BP5 = 4, CEED_BP6 = 5\n} bpType;\nstatic const char *const bpTypes[] = {\"bp1\",\"bp2\",\"bp3\",\"bp4\",\"bp5\",\"bp6\",\n                                      \"bpType\",\"CEED_BP\",0\n                                     };\n\n// BP specific data\ntypedef struct {\n  CeedInt ncompu, qdatasize, qextra;\n  CeedQFunctionUser setupgeo, setuprhs, apply, error;\n  const char *setupgeofname, *setuprhsfname, *applyfname, *errorfname;\n  CeedEvalMode inmode, outmode;\n  CeedQuadMode qmode;\n  PetscBool enforce_bc;\n  PetscErrorCode (*bcs_func)(PetscInt, PetscReal, const PetscReal *,\n                             PetscInt, PetscScalar *, void *);\n} bpData;\n\nbpData bpOptions[6] = {\n  [CEED_BP1] = {\n    .ncompu = 1,\n    .qdatasize = 1,\n    .qextra = 1,\n    .setupgeo = SetupMassGeo,\n    .setuprhs = SetupMassRhs,\n    .apply = Mass,\n    .error = Error,\n    .setupgeofname = SetupMassGeo_loc,\n    .setuprhsfname = SetupMassRhs_loc,\n    .applyfname = Mass_loc,\n    .errorfname = Error_loc,\n    .inmode = CEED_EVAL_INTERP,\n    .outmode = CEED_EVAL_INTERP,\n    .qmode = CEED_GAUSS,\n    .enforce_bc = false,\n    .bcs_func = BCsMass\n  },\n  [CEED_BP2] = {\n    .ncompu = 3,\n    .qdatasize = 1,\n    .qextra = 1,\n    .setupgeo = SetupMassGeo,\n    .setuprhs = SetupMassRhs3,\n    .apply = Mass3,\n    .error = Error3,\n    .setupgeofname = SetupMassGeo_loc,\n    .setuprhsfname = SetupMassRhs3_loc,\n    .applyfname = Mass3_loc,\n    .errorfname = Error3_loc,\n    .inmode = CEED_EVAL_INTERP,\n    .outmode = CEED_EVAL_INTERP,\n    .qmode = CEED_GAUSS,\n    .enforce_bc = false,\n    .bcs_func = BCsMass\n  },\n  [CEED_BP3] = {\n    .ncompu = 1,\n    .qdatasize = 6,\n    .qextra = 1,\n    .setupgeo = SetupDiffGeo,\n    .setuprhs = SetupDiffRhs,\n    .apply = Diff,\n    .error = Error,\n    .setupgeofname = SetupDiffGeo_loc,\n    .setuprhsfname = SetupDiffRhs_loc,\n    .applyfname = Diff_loc,\n    .errorfname = Error_loc,\n    .inmode = CEED_EVAL_GRAD,\n    .outmode = CEED_EVAL_GRAD,\n    .qmode = CEED_GAUSS,\n    .enforce_bc = true,\n    .bcs_func = BCsDiff\n  },\n  [CEED_BP4] = {\n    .ncompu = 3,\n    .qdatasize = 6,\n    .qextra = 1,\n    .setupgeo = SetupDiffGeo,\n    .setuprhs = SetupDiffRhs3,\n    .apply = Diff3,\n    .error = Error3,\n    .setupgeofname = SetupDiffGeo_loc,\n    .setuprhsfname = SetupDiffRhs3_loc,\n    .applyfname = Diff_loc,\n    .errorfname = Error3_loc,\n    .inmode = CEED_EVAL_GRAD,\n    .outmode = CEED_EVAL_GRAD,\n    .qmode = CEED_GAUSS,\n    .enforce_bc = true,\n    .bcs_func = BCsDiff\n  },\n  [CEED_BP5] = {\n    .ncompu = 1,\n    .qdatasize = 6,\n    .qextra = 0,\n    .setupgeo = SetupDiffGeo,\n    .setuprhs = SetupDiffRhs,\n    .apply = Diff,\n    .error = Error,\n    .setupgeofname = SetupDiffGeo_loc,\n    .setuprhsfname = SetupDiffRhs_loc,\n    .applyfname = Diff_loc,\n    .errorfname = Error_loc,\n    .inmode = CEED_EVAL_GRAD,\n    .outmode = CEED_EVAL_GRAD,\n    .qmode = CEED_GAUSS_LOBATTO,\n    .enforce_bc = true,\n    .bcs_func = BCsDiff\n  },\n  [CEED_BP6] = {\n    .ncompu = 3,\n    .qdatasize = 6,\n    .qextra = 0,\n    .setupgeo = SetupDiffGeo,\n    .setuprhs = SetupDiffRhs3,\n    .apply = Diff3,\n    .error = Error3,\n    .setupgeofname = SetupDiffGeo_loc,\n    .setuprhsfname = SetupDiffRhs3_loc,\n    .applyfname = Diff_loc,\n    .errorfname = Error3_loc,\n    .inmode = CEED_EVAL_GRAD,\n    .outmode = CEED_EVAL_GRAD,\n    .qmode = CEED_GAUSS_LOBATTO,\n    .enforce_bc = true,\n    .bcs_func = BCsDiff\n  }\n};\n\n// -----------------------------------------------------------------------------\n// PETSc FE Boilerplate\n// -----------------------------------------------------------------------------\n\n// Create FE by degree\nstatic int PetscFECreateByDegree(DM dm, PetscInt dim, PetscInt Nc,\n                                 PetscBool isSimplex, const char prefix[],\n                                 PetscInt order, PetscFE *fem) {\n  PetscQuadrature q, fq;\n  DM              K;\n  PetscSpace      P;\n  PetscDualSpace  Q;\n  PetscInt        quadPointsPerEdge;\n  PetscBool       tensor = isSimplex ? PETSC_FALSE : PETSC_TRUE;\n  PetscErrorCode  ierr;\n\n  PetscFunctionBeginUser;\n  /* Create space */\n  ierr = PetscSpaceCreate(PetscObjectComm((PetscObject) dm), &P); CHKERRQ(ierr);\n  ierr = PetscObjectSetOptionsPrefix((PetscObject) P, prefix); CHKERRQ(ierr);\n  ierr = PetscSpacePolynomialSetTensor(P, tensor); CHKERRQ(ierr);\n  ierr = PetscSpaceSetFromOptions(P); CHKERRQ(ierr);\n  ierr = PetscSpaceSetNumComponents(P, Nc); CHKERRQ(ierr);\n  ierr = PetscSpaceSetNumVariables(P, dim); CHKERRQ(ierr);\n  ierr = PetscSpaceSetDegree(P, order, order); CHKERRQ(ierr);\n  ierr = PetscSpaceSetUp(P); CHKERRQ(ierr);\n  ierr = PetscSpacePolynomialGetTensor(P, &tensor); CHKERRQ(ierr);\n  /* Create dual space */\n  ierr = PetscDualSpaceCreate(PetscObjectComm((PetscObject) dm), &Q);\n  CHKERRQ(ierr);\n  ierr = PetscDualSpaceSetType(Q,PETSCDUALSPACELAGRANGE); CHKERRQ(ierr);\n  ierr = PetscObjectSetOptionsPrefix((PetscObject) Q, prefix); CHKERRQ(ierr);\n  ierr = PetscDualSpaceCreateReferenceCell(Q, dim, isSimplex, &K); CHKERRQ(ierr);\n  ierr = PetscDualSpaceSetDM(Q, K); CHKERRQ(ierr);\n  ierr = DMDestroy(&K); CHKERRQ(ierr);\n  ierr = PetscDualSpaceSetNumComponents(Q, Nc); CHKERRQ(ierr);\n  ierr = PetscDualSpaceSetOrder(Q, order); CHKERRQ(ierr);\n  ierr = PetscDualSpaceLagrangeSetTensor(Q, tensor); CHKERRQ(ierr);\n  ierr = PetscDualSpaceSetFromOptions(Q); CHKERRQ(ierr);\n  ierr = PetscDualSpaceSetUp(Q); CHKERRQ(ierr);\n  /* Create element */\n  ierr = PetscFECreate(PetscObjectComm((PetscObject) dm), fem); CHKERRQ(ierr);\n  ierr = PetscObjectSetOptionsPrefix((PetscObject) *fem, prefix); CHKERRQ(ierr);\n  ierr = PetscFESetFromOptions(*fem); CHKERRQ(ierr);\n  ierr = PetscFESetBasisSpace(*fem, P); CHKERRQ(ierr);\n  ierr = PetscFESetDualSpace(*fem, Q); CHKERRQ(ierr);\n  ierr = PetscFESetNumComponents(*fem, Nc); CHKERRQ(ierr);\n  ierr = PetscFESetUp(*fem); CHKERRQ(ierr);\n  ierr = PetscSpaceDestroy(&P); CHKERRQ(ierr);\n  ierr = PetscDualSpaceDestroy(&Q); CHKERRQ(ierr);\n  /* Create quadrature */\n  quadPointsPerEdge = PetscMax(order + 1,1);\n  if (isSimplex) {\n    ierr = PetscDTGaussJacobiQuadrature(dim,   1, quadPointsPerEdge, -1.0, 1.0,\n                                        &q); CHKERRQ(ierr);\n    ierr = PetscDTGaussJacobiQuadrature(dim-1, 1, quadPointsPerEdge, -1.0, 1.0,\n                                        &fq); CHKERRQ(ierr);\n  } else {\n    ierr = PetscDTGaussTensorQuadrature(dim,   1, quadPointsPerEdge, -1.0, 1.0,\n                                        &q); CHKERRQ(ierr);\n    ierr = PetscDTGaussTensorQuadrature(dim-1, 1, quadPointsPerEdge, -1.0, 1.0,\n                                        &fq); CHKERRQ(ierr);\n  }\n  ierr = PetscFESetQuadrature(*fem, q); CHKERRQ(ierr);\n  ierr = PetscFESetFaceQuadrature(*fem, fq); CHKERRQ(ierr);\n  ierr = PetscQuadratureDestroy(&q); CHKERRQ(ierr);\n  ierr = PetscQuadratureDestroy(&fq); CHKERRQ(ierr);\n\n  PetscFunctionReturn(0);\n}\n\n// -----------------------------------------------------------------------------\n// PETSc Setup for Level\n// -----------------------------------------------------------------------------\n\n// This function sets up a DM for a given degree\nstatic int SetupDMByDegree(DM dm, PetscInt degree, PetscInt ncompu,\n                           bpType bpChoice) {\n  PetscInt ierr, dim, marker_ids[1] = {1};\n  PetscFE fe;\n\n  PetscFunctionBeginUser;\n\n  // Setup FE\n  ierr = DMGetDimension(dm, &dim); CHKERRQ(ierr);\n  ierr = PetscFECreateByDegree(dm, dim, ncompu, PETSC_FALSE, NULL, degree, &fe);\n  CHKERRQ(ierr);\n  ierr = DMSetFromOptions(dm); CHKERRQ(ierr);\n  ierr = DMAddField(dm, NULL, (PetscObject)fe); CHKERRQ(ierr);\n\n  // Setup DM\n  ierr = DMCreateDS(dm); CHKERRQ(ierr);\n  if (bpOptions[bpChoice].enforce_bc) {\n    PetscBool hasLabel;\n    DMHasLabel(dm, \"marker\", &hasLabel);\n    if (!hasLabel) {CreateBCLabel(dm, \"marker\");}\n    ierr = DMAddBoundary(dm, DM_BC_ESSENTIAL, \"wall\", \"marker\", 0, 0, NULL,\n                         (void(*)(void))bpOptions[bpChoice].bcs_func,\n                         1, marker_ids, NULL);\n    CHKERRQ(ierr);\n  }\n  ierr = DMPlexSetClosurePermutationTensor(dm, PETSC_DETERMINE, NULL);\n  CHKERRQ(ierr);\n  ierr = PetscFEDestroy(&fe); CHKERRQ(ierr);\n\n  PetscFunctionReturn(0);\n}\n\n// -----------------------------------------------------------------------------\n// libCEED Setup for Level\n// -----------------------------------------------------------------------------\n\n// Destroy libCEED operator objects\nstatic PetscErrorCode CeedDataDestroy(CeedInt i, CeedData data) {\n  PetscInt ierr;\n\n  CeedVectorDestroy(&data->qdata);\n  CeedVectorDestroy(&data->xceed);\n  CeedVectorDestroy(&data->yceed);\n  CeedBasisDestroy(&data->basisx);\n  CeedBasisDestroy(&data->basisu);\n  CeedElemRestrictionDestroy(&data->Erestrictu);\n  CeedElemRestrictionDestroy(&data->Erestrictx);\n  CeedElemRestrictionDestroy(&data->Erestrictui);\n  CeedElemRestrictionDestroy(&data->Erestrictxi);\n  CeedElemRestrictionDestroy(&data->Erestrictqdi);\n  CeedQFunctionDestroy(&data->qf_apply);\n  CeedOperatorDestroy(&data->op_apply);\n  if (i > 0) {\n    CeedOperatorDestroy(&data->op_interp);\n    CeedBasisDestroy(&data->basisctof);\n    CeedOperatorDestroy(&data->op_restrict);\n  }\n  ierr = PetscFree(data); CHKERRQ(ierr);\n\n  PetscFunctionReturn(0);\n}\n\n// Get CEED restriction data from DMPlex\nstatic int CreateRestrictionPlex(Ceed ceed, CeedInt P, CeedInt ncomp,\n                                 CeedElemRestriction *Erestrict, DM dm) {\n  PetscInt ierr;\n  PetscInt c, cStart, cEnd, nelem, nnodes, *erestrict, eoffset;\n  PetscSection section;\n  Vec Uloc;\n\n  PetscFunctionBeginUser;\n\n  // Get Nelem\n  ierr = DMGetSection(dm, &section); CHKERRQ(ierr);\n  ierr = DMPlexGetHeightStratum(dm, 0, &cStart,& cEnd); CHKERRQ(ierr);\n  nelem = cEnd - cStart;\n\n  // Get indices\n  ierr = PetscMalloc1(nelem*P*P*P, &erestrict); CHKERRQ(ierr);\n  for (c=cStart, eoffset=0; c<cEnd; c++) {\n    PetscInt numindices, *indices, i;\n    ierr = DMPlexGetClosureIndices(dm, section, section, c, &numindices,\n                                   &indices, NULL); CHKERRQ(ierr);\n    for (i=0; i<numindices; i+=ncomp) {\n      for (PetscInt j=0; j<ncomp; j++) {\n        if (indices[i+j] != indices[i] + (PetscInt)(copysign(j, indices[i])))\n          SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_INCOMP,\n                   \"Cell %D closure indices not interlaced\", c);\n      }\n      // Essential boundary conditions are encoded as -(loc+1)\n      PetscInt loc = indices[i] >= 0 ? indices[i] : -(indices[i] + 1);\n      erestrict[eoffset++] = loc/ncomp;\n    }\n    ierr = DMPlexRestoreClosureIndices(dm, section, section, c, &numindices,\n                                       &indices, NULL); CHKERRQ(ierr);\n  }\n\n  // Setup CEED restriction\n  ierr = DMGetLocalVector(dm, &Uloc); CHKERRQ(ierr);\n  ierr = VecGetLocalSize(Uloc, &nnodes); CHKERRQ(ierr);\n\n  ierr = DMRestoreLocalVector(dm, &Uloc); CHKERRQ(ierr);\n  CeedElemRestrictionCreate(ceed, nelem, P*P*P, nnodes/ncomp, ncomp,\n                            CEED_MEM_HOST, CEED_COPY_VALUES, erestrict,\n                            Erestrict);\n  ierr = PetscFree(erestrict); CHKERRQ(ierr);\n\n  PetscFunctionReturn(0);\n}\n\n// Set up libCEED for a given degree\nstatic int SetupLibceedByDegree(DM dm, Ceed ceed, CeedInt degree, CeedInt dim,\n                                CeedInt qextra, PetscInt ncompu, PetscInt gsize,\n                                PetscInt xlsize, bpType bpChoice, CeedData data,\n                                PetscBool setup_rhs, CeedVector rhsceed,\n                                CeedVector *target) {\n  int ierr;\n  DM dmcoord;\n  PetscSection section;\n  Vec coords;\n  const PetscScalar *coordArray;\n  CeedBasis basisx, basisu;\n  CeedElemRestriction Erestrictx, Erestrictu, Erestrictxi,\n                      Erestrictui, Erestrictqdi;\n  CeedQFunction qf_setupgeo, qf_apply;\n  CeedOperator op_setupgeo, op_apply;\n  CeedVector xcoord, qdata, xceed, yceed;\n  CeedInt qdatasize = bpOptions[bpChoice].qdatasize, ncompx = dim, P, Q,\n          cStart, cEnd, nelem;\n\n  // CEED bases\n  P = degree + 1;\n  Q = P + qextra;\n  CeedBasisCreateTensorH1Lagrange(ceed, dim, ncompu, P, Q,\n                                  bpOptions[bpChoice].qmode, &basisu);\n  CeedBasisCreateTensorH1Lagrange(ceed, dim, ncompx, 2, Q,\n                                  bpOptions[bpChoice].qmode, &basisx);\n\n  // CEED restrictions\n  ierr = DMGetCoordinateDM(dm, &dmcoord); CHKERRQ(ierr);\n  ierr = DMPlexSetClosurePermutationTensor(dmcoord, PETSC_DETERMINE, NULL);\n  CHKERRQ(ierr);\n\n  CreateRestrictionPlex(ceed, 2, ncompx, &Erestrictx, dmcoord);\n  CreateRestrictionPlex(ceed, P, ncompu, &Erestrictu, dm);\n\n  ierr = DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd); CHKERRQ(ierr);\n  nelem = cEnd - cStart;\n\n  CeedElemRestrictionCreateIdentity(ceed, nelem, Q*Q*Q, nelem*Q*Q*Q, ncompu,\n                                    &Erestrictui); CHKERRQ(ierr);\n  CeedElemRestrictionCreateIdentity(ceed, nelem, Q*Q*Q, nelem*Q*Q*Q,\n                                    qdatasize, &Erestrictqdi); CHKERRQ(ierr);\n  CeedElemRestrictionCreateIdentity(ceed, nelem, Q*Q*Q, nelem*Q*Q*Q, ncompx,\n                                    &Erestrictxi); CHKERRQ(ierr);\n\n  // Element coordinates\n  ierr = DMGetCoordinatesLocal(dm, &coords); CHKERRQ(ierr);\n  ierr = VecGetArrayRead(coords, &coordArray); CHKERRQ(ierr);\n  ierr = DMGetSection(dmcoord, &section); CHKERRQ(ierr);\n\n  CeedElemRestrictionCreateVector(Erestrictx, &xcoord, NULL);\n  CeedVectorSetArray(xcoord, CEED_MEM_HOST, CEED_COPY_VALUES,\n                     (PetscScalar *)coordArray);\n  ierr = VecRestoreArrayRead(coords, &coordArray); CHKERRQ(ierr);\n\n  // Create the persistent vectors that will be needed in setup and apply\n  CeedInt nqpts;\n  CeedBasisGetNumQuadraturePoints(basisu, &nqpts);\n  CeedVectorCreate(ceed, qdatasize*nelem*nqpts, &qdata);\n  CeedVectorCreate(ceed, xlsize, &xceed);\n  CeedVectorCreate(ceed, xlsize, &yceed);\n\n  // Create the Q-function that builds the operator (i.e. computes its\n  // quadrature data) and set its context data\n  CeedQFunctionCreateInterior(ceed, 1, bpOptions[bpChoice].setupgeo,\n                              bpOptions[bpChoice].setupgeofname, &qf_setupgeo);\n  CeedQFunctionAddInput(qf_setupgeo, \"dx\", ncompx*dim, CEED_EVAL_GRAD);\n  CeedQFunctionAddInput(qf_setupgeo, \"weight\", 1, CEED_EVAL_WEIGHT);\n  CeedQFunctionAddOutput(qf_setupgeo, \"qdata\", qdatasize, CEED_EVAL_NONE);\n\n  // Set up PDE operator\n  CeedInt inscale = bpOptions[bpChoice].inmode==CEED_EVAL_GRAD ? dim : 1;\n  CeedInt outscale = bpOptions[bpChoice].outmode==CEED_EVAL_GRAD ? dim : 1;\n  CeedQFunctionCreateInterior(ceed, 1, bpOptions[bpChoice].apply,\n                              bpOptions[bpChoice].applyfname, &qf_apply);\n  CeedQFunctionAddInput(qf_apply, \"u\", ncompu*inscale,\n                        bpOptions[bpChoice].inmode);\n  CeedQFunctionAddInput(qf_apply, \"qdata\", qdatasize, CEED_EVAL_NONE);\n  CeedQFunctionAddOutput(qf_apply, \"v\", ncompu*outscale,\n                         bpOptions[bpChoice].outmode);\n\n  // Create the operator that builds the quadrature data for the operator\n  CeedOperatorCreate(ceed, qf_setupgeo, CEED_QFUNCTION_NONE,\n                     CEED_QFUNCTION_NONE, &op_setupgeo);\n  CeedOperatorSetField(op_setupgeo, \"dx\", Erestrictx, CEED_TRANSPOSE,\n                       basisx, CEED_VECTOR_ACTIVE);\n  CeedOperatorSetField(op_setupgeo, \"weight\", Erestrictxi, CEED_NOTRANSPOSE,\n                       basisx, CEED_VECTOR_NONE);\n  CeedOperatorSetField(op_setupgeo, \"qdata\", Erestrictqdi, CEED_NOTRANSPOSE,\n                       CEED_BASIS_COLLOCATED, CEED_VECTOR_ACTIVE);\n\n  // Create the operator\n  CeedOperatorCreate(ceed, qf_apply, CEED_QFUNCTION_NONE, CEED_QFUNCTION_NONE,\n                     &op_apply);\n  CeedOperatorSetField(op_apply, \"u\", Erestrictu, CEED_TRANSPOSE,\n                       basisu, CEED_VECTOR_ACTIVE);\n  CeedOperatorSetField(op_apply, \"qdata\", Erestrictqdi, CEED_NOTRANSPOSE,\n                       CEED_BASIS_COLLOCATED, qdata);\n  CeedOperatorSetField(op_apply, \"v\", Erestrictu, CEED_TRANSPOSE,\n                       basisu, CEED_VECTOR_ACTIVE);\n\n  // Setup qdata\n  CeedOperatorApply(op_setupgeo, xcoord, qdata, CEED_REQUEST_IMMEDIATE);\n\n  // Set up RHS if needed\n  if (setup_rhs) {\n    CeedQFunction qf_setuprhs;\n    CeedOperator op_setuprhs;\n    CeedVectorCreate(ceed, nelem*nqpts*ncompu, target);\n\n    // Create the q-function that sets up the RHS and true solution\n    CeedQFunctionCreateInterior(ceed, 1, bpOptions[bpChoice].setuprhs,\n                                bpOptions[bpChoice].setuprhsfname, &qf_setuprhs);\n    CeedQFunctionAddInput(qf_setuprhs, \"x\", dim, CEED_EVAL_INTERP);\n    CeedQFunctionAddInput(qf_setuprhs, \"dx\", ncompx*dim, CEED_EVAL_GRAD);\n    CeedQFunctionAddInput(qf_setuprhs, \"weight\", 1, CEED_EVAL_WEIGHT);\n    CeedQFunctionAddOutput(qf_setuprhs, \"true_soln\", ncompu, CEED_EVAL_NONE);\n    CeedQFunctionAddOutput(qf_setuprhs, \"rhs\", ncompu, CEED_EVAL_INTERP);\n\n    // Create the operator that builds the RHS and true solution\n    CeedOperatorCreate(ceed, qf_setuprhs, CEED_QFUNCTION_NONE,\n                       CEED_QFUNCTION_NONE, &op_setuprhs);\n    CeedOperatorSetField(op_setuprhs, \"x\", Erestrictx, CEED_TRANSPOSE,\n                         basisx, CEED_VECTOR_ACTIVE);\n    CeedOperatorSetField(op_setuprhs, \"dx\", Erestrictx, CEED_TRANSPOSE,\n                         basisx, CEED_VECTOR_ACTIVE);\n    CeedOperatorSetField(op_setuprhs, \"weight\", Erestrictxi, CEED_NOTRANSPOSE,\n                         basisx, CEED_VECTOR_NONE);\n    CeedOperatorSetField(op_setuprhs, \"true_soln\", Erestrictui, CEED_NOTRANSPOSE,\n                         CEED_BASIS_COLLOCATED, *target);\n    CeedOperatorSetField(op_setuprhs, \"rhs\", Erestrictu, CEED_TRANSPOSE,\n                         basisu, CEED_VECTOR_ACTIVE);\n\n    // Setup RHS and target\n    CeedOperatorApply(op_setuprhs, xcoord, rhsceed, CEED_REQUEST_IMMEDIATE);\n    CeedVectorSyncArray(rhsceed, CEED_MEM_HOST);\n\n    // Cleanup\n    CeedQFunctionDestroy(&qf_setuprhs);\n    CeedOperatorDestroy(&op_setuprhs);\n  }\n\n  // Cleanup\n  CeedQFunctionDestroy(&qf_setupgeo);\n  CeedOperatorDestroy(&op_setupgeo);\n  CeedVectorDestroy(&xcoord);\n\n  // Save libCEED data required for level\n  data->basisx = basisx; data->basisu = basisu;\n  data->Erestrictx = Erestrictx;\n  data->Erestrictu = Erestrictu;\n  data->Erestrictxi = Erestrictxi;\n  data->Erestrictui = Erestrictui;\n  data->Erestrictqdi = Erestrictqdi;\n  data->qf_apply = qf_apply;\n  data->op_apply = op_apply;\n  data->qdata = qdata;\n  data->xceed = xceed;\n  data->yceed = yceed;\n\n  PetscFunctionReturn(0);\n}\n\n#ifdef multigrid\n// Setup libCEED level transfer operator objects\nstatic PetscErrorCode CeedLevelTransferSetup(Ceed ceed, CeedInt numlevels,\n    CeedInt ncompu, bpType bpChoice, CeedData *data, CeedInt *leveldegrees,\n    CeedQFunction qf_restrict, CeedQFunction qf_prolong) {\n  // Return early if numlevels=1\n  if (numlevels==1)\n    PetscFunctionReturn(0);\n\n  // Set up each level\n  for (CeedInt i=1; i<numlevels; i++) {\n    // P coarse and P fine\n    CeedInt Pc = leveldegrees[i-1] + 1;\n    CeedInt Pf = leveldegrees[i] + 1;\n\n    // Restriction - Fine to corse\n    CeedBasis basisctof;\n    CeedOperator op_restrict;\n\n    // Basis\n    CeedBasisCreateTensorH1Lagrange(ceed, 3, ncompu, Pc, Pf,\n                                    CEED_GAUSS_LOBATTO, &basisctof);\n\n    // Create the restriction operator\n    CeedOperatorCreate(ceed, qf_restrict, CEED_QFUNCTION_NONE,\n                       CEED_QFUNCTION_NONE, &op_restrict);\n    CeedOperatorSetField(op_restrict, \"input\", data[i]->Erestrictu,\n                         CEED_NOTRANSPOSE, CEED_BASIS_COLLOCATED,\n                         CEED_VECTOR_ACTIVE);\n    CeedOperatorSetField(op_restrict, \"output\", data[i-1]->Erestrictu,\n                         CEED_TRANSPOSE, basisctof, CEED_VECTOR_ACTIVE);\n\n    // Save libCEED data required for level\n    data[i]->basisctof = basisctof;\n    data[i]->op_restrict = op_restrict;\n\n    // Interpolation - Corse to fine\n    CeedOperator op_interp;\n\n    // Create the prolongation operator\n    CeedOperatorCreate(ceed, qf_prolong, CEED_QFUNCTION_NONE,\n                       CEED_QFUNCTION_NONE, &op_interp);\n    CeedOperatorSetField(op_interp, \"input\", data[i-1]->Erestrictu,\n                         CEED_NOTRANSPOSE, basisctof, CEED_VECTOR_ACTIVE);\n    CeedOperatorSetField(op_interp, \"output\", data[i]->Erestrictu,\n                         CEED_TRANSPOSE, CEED_BASIS_COLLOCATED,\n                         CEED_VECTOR_ACTIVE);\n\n    // Save libCEED data required for level\n    data[i]->op_interp = op_interp;\n  }\n\n  PetscFunctionReturn(0);\n}\n#endif\n\n// -----------------------------------------------------------------------------\n// Mat Shell Functions\n// -----------------------------------------------------------------------------\n\n#ifdef multigrid\n// This function returns the computed diagonal of the operator\nstatic PetscErrorCode MatGetDiag(Mat A, Vec D) {\n  PetscErrorCode ierr;\n  UserO user;\n\n  PetscFunctionBeginUser;\n  ierr = MatShellGetContext(A, &user); CHKERRQ(ierr);\n\n  ierr = VecCopy(user->diag, D); CHKERRQ(ierr);\n\n  PetscFunctionReturn(0);\n}\n#endif\n\n// This function uses libCEED to compute the action of the Laplacian with\n// Dirichlet boundary conditions\nstatic PetscErrorCode MatMult_Ceed(Mat A, Vec X, Vec Y) {\n  PetscErrorCode ierr;\n  UserO user;\n  PetscScalar *x, *y;\n\n  PetscFunctionBeginUser;\n  ierr = MatShellGetContext(A, &user); CHKERRQ(ierr);\n\n  // Global-to-local\n  ierr = DMGlobalToLocalBegin(user->dm, X, INSERT_VALUES, user->Xloc);\n  CHKERRQ(ierr);\n  ierr = DMGlobalToLocalEnd(user->dm, X, INSERT_VALUES, user->Xloc);\n  CHKERRQ(ierr);\n  ierr = VecZeroEntries(user->Yloc); CHKERRQ(ierr);\n\n  // Setup CEED vectors\n  ierr = VecGetArrayRead(user->Xloc, (const PetscScalar **)&x); CHKERRQ(ierr);\n  ierr = VecGetArray(user->Yloc, &y); CHKERRQ(ierr);\n  CeedVectorSetArray(user->xceed, CEED_MEM_HOST, CEED_USE_POINTER, x);\n  CeedVectorSetArray(user->yceed, CEED_MEM_HOST, CEED_USE_POINTER, y);\n\n  // Apply CEED operator\n  CeedOperatorApply(user->op, user->xceed, user->yceed, CEED_REQUEST_IMMEDIATE);\n  CeedVectorSyncArray(user->yceed, CEED_MEM_HOST);\n\n  // Restore PETSc vectors\n  ierr = VecRestoreArrayRead(user->Xloc, (const PetscScalar **)&x);\n  CHKERRQ(ierr);\n  ierr = VecRestoreArray(user->Yloc, &y); CHKERRQ(ierr);\n\n  // Local-to-global\n  ierr = VecZeroEntries(Y); CHKERRQ(ierr);\n  ierr = DMLocalToGlobalBegin(user->dm, user->Yloc, ADD_VALUES, Y);\n  CHKERRQ(ierr);\n  ierr = DMLocalToGlobalEnd(user->dm, user->Yloc, ADD_VALUES, Y);\n  CHKERRQ(ierr);\n\n  PetscFunctionReturn(0);\n}\n\n#ifdef multigrid\n// This function uses libCEED to compute the action of the interp operator\nstatic PetscErrorCode MatMult_Interp(Mat A, Vec X, Vec Y) {\n  PetscErrorCode ierr;\n  UserIR user;\n  PetscScalar *x, *y;\n\n  PetscFunctionBeginUser;\n  ierr = MatShellGetContext(A, &user); CHKERRQ(ierr);\n\n  // Global-to-local\n  ierr = VecZeroEntries(user->Xloc); CHKERRQ(ierr);\n  ierr = DMGlobalToLocalBegin(user->dmc, X, INSERT_VALUES, user->Xloc);\n  CHKERRQ(ierr);\n  ierr = DMGlobalToLocalEnd(user->dmc, X, INSERT_VALUES, user->Xloc);\n  CHKERRQ(ierr);\n  ierr = VecZeroEntries(user->Yloc); CHKERRQ(ierr);\n\n  // Setup CEED vectors\n  ierr = VecGetArrayRead(user->Xloc, (const PetscScalar **)&x); CHKERRQ(ierr);\n  ierr = VecGetArray(user->Yloc, &y); CHKERRQ(ierr);\n  CeedVectorSetArray(user->ceedvecc, CEED_MEM_HOST, CEED_USE_POINTER, x);\n  CeedVectorSetArray(user->ceedvecf, CEED_MEM_HOST, CEED_USE_POINTER, y);\n\n  // Apply CEED operator\n  CeedOperatorApply(user->op, user->ceedvecc, user->ceedvecf,\n                    CEED_REQUEST_IMMEDIATE);\n  CeedVectorSyncArray(user->ceedvecf, CEED_MEM_HOST);\n\n  // Restore PETSc vectors\n  ierr = VecRestoreArrayRead(user->Xloc, (const PetscScalar **)&x);\n  CHKERRQ(ierr);\n  ierr = VecRestoreArray(user->Yloc, &y); CHKERRQ(ierr);\n\n  // Multiplicity\n  ierr = VecPointwiseMult(user->Yloc, user->Yloc, user->mult);\n\n  // Local-to-global\n  ierr = VecZeroEntries(Y); CHKERRQ(ierr);\n  ierr = DMLocalToGlobalBegin(user->dmf, user->Yloc, ADD_VALUES, Y);\n  CHKERRQ(ierr);\n  ierr = DMLocalToGlobalEnd(user->dmf, user->Yloc, ADD_VALUES, Y);\n  CHKERRQ(ierr);\n\n  PetscFunctionReturn(0);\n}\n\n// This function uses libCEED to compute the action of the restriction operator\nstatic PetscErrorCode MatMult_Restrict(Mat A, Vec X, Vec Y) {\n  PetscErrorCode ierr;\n  UserIR user;\n  PetscScalar *x, *y;\n\n  PetscFunctionBeginUser;\n  ierr = MatShellGetContext(A, &user); CHKERRQ(ierr);\n\n  // Global-to-local\n  ierr = VecZeroEntries(user->Xloc); CHKERRQ(ierr);\n  ierr = DMGlobalToLocalBegin(user->dmf, X, INSERT_VALUES, user->Xloc);\n  CHKERRQ(ierr);\n  ierr = DMGlobalToLocalEnd(user->dmf, X, INSERT_VALUES, user->Xloc);\n  CHKERRQ(ierr);\n  ierr = VecZeroEntries(user->Yloc); CHKERRQ(ierr);\n\n  // Multiplicity\n  ierr = VecPointwiseMult(user->Xloc, user->Xloc, user->mult); CHKERRQ(ierr);\n\n  // Setup CEED vectors\n  ierr = VecGetArrayRead(user->Xloc, (const PetscScalar **)&x); CHKERRQ(ierr);\n  ierr = VecGetArray(user->Yloc, &y); CHKERRQ(ierr);\n  CeedVectorSetArray(user->ceedvecf, CEED_MEM_HOST, CEED_USE_POINTER, x);\n  CeedVectorSetArray(user->ceedvecc, CEED_MEM_HOST, CEED_USE_POINTER, y);\n\n  // Apply CEED operator\n  CeedOperatorApply(user->op, user->ceedvecf, user->ceedvecc,\n                    CEED_REQUEST_IMMEDIATE);\n  CeedVectorSyncArray(user->ceedvecc, CEED_MEM_HOST);\n\n  // Restore PETSc vectors\n  ierr = VecRestoreArrayRead(user->Xloc, (const PetscScalar **)&x);\n  CHKERRQ(ierr);\n  ierr = VecRestoreArray(user->Yloc, &y); CHKERRQ(ierr);\n\n  // Local-to-global\n  ierr = VecZeroEntries(Y); CHKERRQ(ierr);\n  ierr = DMLocalToGlobalBegin(user->dmc, user->Yloc, ADD_VALUES, Y);\n  CHKERRQ(ierr);\n  ierr = DMLocalToGlobalEnd(user->dmc, user->Yloc, ADD_VALUES, Y);\n  CHKERRQ(ierr);\n\n  PetscFunctionReturn(0);\n}\n#endif\n\n// This function calculates the error in the final solution\nstatic PetscErrorCode ComputeErrorMax(UserO user, CeedOperator op_error,\n                                      Vec X, CeedVector target,\n                                      PetscReal *maxerror) {\n  PetscErrorCode ierr;\n  PetscScalar *x;\n  CeedVector collocated_error;\n  CeedInt length;\n\n  PetscFunctionBeginUser;\n  CeedVectorGetLength(target, &length);\n  CeedVectorCreate(user->ceed, length, &collocated_error);\n\n  // Global-to-local\n  ierr = DMGlobalToLocal(user->dm, X, INSERT_VALUES, user->Xloc); CHKERRQ(ierr);\n\n  // Setup CEED vector\n  ierr = VecGetArrayRead(user->Xloc, (const PetscScalar **)&x); CHKERRQ(ierr);\n  CeedVectorSetArray(user->xceed, CEED_MEM_HOST, CEED_USE_POINTER, x);\n\n  // Apply CEED operator\n  CeedOperatorApply(op_error, user->xceed, collocated_error,\n                    CEED_REQUEST_IMMEDIATE);\n\n  // Restore PETSc vector\n  VecRestoreArrayRead(user->Xloc, (const PetscScalar **)&x); CHKERRQ(ierr);\n\n  // Reduce max error\n  *maxerror = 0;\n  const CeedScalar *e;\n  CeedVectorGetArrayRead(collocated_error, CEED_MEM_HOST, &e);\n  for (CeedInt i=0; i<length; i++) {\n    *maxerror = PetscMax(*maxerror, PetscAbsScalar(e[i]));\n  }\n  CeedVectorRestoreArrayRead(collocated_error, &e);\n  ierr = MPI_Allreduce(MPI_IN_PLACE, maxerror,\n                       1, MPIU_REAL, MPIU_MAX, user->comm); CHKERRQ(ierr);\n\n  // Cleanup\n  CeedVectorDestroy(&collocated_error);\n\n  PetscFunctionReturn(0);\n}\n#endif\n", "meta": {"hexsha": "36127a97868112b55da2ffa56101bf10a930253e", "size": 31804, "ext": "h", "lang": "C", "max_stars_repo_path": "examples/petsc/setup.h", "max_stars_repo_name": "jrwrigh/libCEED", "max_stars_repo_head_hexsha": "15e77cd9c9ad8c81f93cb17e681f4732bd8b573f", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "examples/petsc/setup.h", "max_issues_repo_name": "jrwrigh/libCEED", "max_issues_repo_head_hexsha": "15e77cd9c9ad8c81f93cb17e681f4732bd8b573f", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "examples/petsc/setup.h", "max_forks_repo_name": "jrwrigh/libCEED", "max_forks_repo_head_hexsha": "15e77cd9c9ad8c81f93cb17e681f4732bd8b573f", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.1820250284, "max_line_length": 81, "alphanum_fraction": 0.6447302226, "num_tokens": 8957, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.30074557894124154, "lm_q2_score": 0.04208772911713975, "lm_q1q2_score": 0.012657698459656343}}
{"text": "/* Function in common for mlfit1, mlfitN, etc ...\n */\n\n#include <stdlib.h>\n#include <stdio.h>\n#include <assert.h>\n#include <stdint.h>\n#include <gsl/gsl_math.h>\n#include <gsl/gsl_sort.h>\n#include <gsl/gsl_statistics.h>\n\n\n#include \"mlfit.h\"\n#include \"blit3.h\"\n\n#ifndef verbose\n#define verbose 0\n#endif\n\ndouble estimateNphot(double *V, size_t Vm)\n  // V is a Vm x Vm matrix\n  // The number of photons locally as sum(V-min(V))\n{\n  double s = 0;\n  double minV = INFINITY;\n\n  for(size_t kk=0; kk<Vm*Vm; kk++)\n    s+=V[kk];\n\n  for(size_t kk=0; kk<Vm*Vm; kk++)\n    minV = GSL_MIN(V[kk], minV);\n\n  s = s-minV*Vm*Vm;\n\n  //printf(\"estimateNphot: %f\\n\", s);\n  return s;\n}\n\nint double_cmp(const void * a, const void * b)\n{\n  if (*(const double*)a > *(const double*)b) {\n    return 1;\n  } else {\n    if (*(const double*)a < *(const double*)b) { \n      return -1;\n    } else { \n    return 0;\n  }\n}\n}\n\ndouble estimateBGV(double *V, size_t Vm, size_t Vn, size_t Vp, double * D)\n  // estimate the background level in V [VmxVnxVp] around the point D\n  // (x,y,z)\n{\n\n  int32_t radius = 7;\n  double * ePixels = malloc(sizeof(double)*6*(2*radius+1)*(2*radius+1)); // a few more than we need\n\n  int32_t x = nearbyint(D[0]);\n  int32_t y = nearbyint(D[1]);\n  int32_t z = nearbyint(D[2]);\n\n  // Loop over the box, and copy the edge pixels to ePixels\n  size_t nPixels = 0;\n  for(int32_t zz = z-radius; zz<=z+radius; zz++)\n    for(int32_t yy = y-radius; yy<=y+radius; yy++)\n     for(int32_t xx = x-radius; xx<=x+radius; xx++)\n       if((abs(zz-z)+abs(yy-y)+abs(xx-x)) == radius)\n         if(xx>=0 && yy>=0 && zz>=0 && xx< (int32_t) Vm && yy<(int32_t) Vn && zz<(int32_t) Vp)\n           ePixels[nPixels++] = V[xx + yy*Vm + zz*Vm*Vn];\n\n#if verbose > 0\n  printf(\"%lu ePixels\\n\", nPixels);\n#endif\n\n  double median = 0;\n  if(nPixels>0)\n  {\n  qsort(ePixels, nPixels, sizeof(double),  double_cmp);\n  gsl_sort(ePixels, 1, nPixels);\n  median = gsl_stats_median_from_sorted_data(ePixels, 1, nPixels);\n  //median = (double) nPixels;\n#if verbose > 0\n  printf(\"Median: %f\\n\", median);\n#endif \n  }\n  else\n  { median = 0;}\n\n  free(ePixels);\n  return(median);\n  //return((double) q);\n}\n\ndouble estimateBG(double *V, size_t Vm)\n  // Estimate the background level as the median of the edge pixels\n{\n\n  size_t nEdge = 4*Vm-4;\n  double * ePixels = malloc(nEdge*sizeof(double));\n\n  size_t pos = 0;\n  for(uint32_t kk = 0; kk<Vm; kk++, pos++) // Left\n    ePixels[pos] = V[kk];\n  for(uint32_t kk = 0; kk<Vm; kk++, pos++) // Right\n    ePixels[pos] = V[kk+(Vm-1)*Vm];\n  for(uint32_t kk = 1; kk<Vm-1; kk++, pos++) // Top\n    ePixels[pos] = V[Vm*kk];\n  for(uint32_t kk = 1; kk<Vm-1; kk++, pos++) // Bottom\n    ePixels[pos] = (double) V[Vm-1+Vm*kk];\n\n  assert(pos == 4*Vm-4);\n\n  if(0) {\n    for(uint32_t kk = 0; kk<nEdge; kk++)\n      printf(\"%2d :%f\\n\", kk, ePixels[kk]);\n    printf(\"\\n\");\n  }\n\n//  qsort(ePixels, nEdge, sizeof(double),  double_cmp);\n\n  if(0) {\n    for(uint32_t kk = 0; kk<nEdge; kk++)\n      printf(\"%2d %f\\n\", kk, ePixels[kk]);\n    printf(\"\\n\");\n  }\n\n  gsl_sort(ePixels, 1, nEdge);\n  double median = gsl_stats_median_from_sorted_data(ePixels, 1, nEdge);\n  // double mean = gsl_stats_mean(ePixels, 1, nEdge);\n#if verbose > 0\n  printf(\"Median: %f\\n\", median);\n#endif \n  free(ePixels);\n  return(median);\n}\n\nint getZLine(double *W, size_t Ws,\n    double * V, size_t Vm, size_t Vn, size_t Vp,\n    double *D)\n  /* Copy a line from V into W.\n   * The line will be D[x, y, z-hWs:z+hWs]\n   * where hWs = (Ws-1)/2 and D = [x,y,z]\n   *\n   * returns 1 on failure (i.e. line is out of bounds)\n   * returns 0 if ok.\n   *\n   * See also: getRegion\n   */\n{\n\n  int64_t x = nearbyint(D[0]);\n  int64_t y = nearbyint(D[1]);\n  int64_t z = nearbyint(D[2]);\n\n  size_t Ws2 = (Ws-1)/2;\n\n  if(z+Ws2 >= Vp)\n    return 1;\n  if(z<(int64_t) Ws2)\n    return 1;\n\n  size_t pos = 0;\n  for(size_t zz = z-Ws2; zz<=z+Ws2; zz++)\n  {\n    W[pos++] = V[x + y*Vm + zz*Vm*Vn];\n  }\n  return 0;\n}\n\nint getRegion(double * W, size_t Ws,\n    double * V, size_t Vm, size_t Vn, size_t Vp,\n    double * D)\n  // Get a 2D region for constant z or returns 0 if out of bounds\n  // Vm, Vn, Vp is the centre of the region.\n{  \n  size_t Ws2 = (Ws-1)/2;\n  size_t pos = 0;\n\n  int64_t x = nearbyint(D[0]);\n  int64_t y = nearbyint(D[1]);\n  int64_t z = nearbyint(D[2]);\n\n#if verbose > 0\n  printf(\"getRegion round(D): (%lu %lu %lu)\\n\", x, y, z);\n  printf(\"getRegion size(V)   (%lu %lu %lu)\\n\", Vm, Vn, Vp);\n#endif\n\n  if(x-(int64_t) Ws2 < 0)\n    return 1;\n  if(y-(int64_t) Ws2 < 0)\n    return 1;\n  if(x+(uint64_t) Ws2  >= Vm)\n    return 1;\n  if(y+(uint64_t) Ws2  >= Vn)\n    return 1;\n  if(z<0)\n    return 1;\n  if((size_t) z>=Vp)\n    return 1;\n\n#if verbose > 1\n  printf(\"Region valid\\n\");\n  printf(\"%lu %lu %lu\\n\", Vm, Vn, Vp);\n#endif\n \n  uint32_t zz = z;\n  for(uint32_t yy = y-Ws2; yy<=y+Ws2; yy++) {\n    for(uint32_t xx = x-Ws2; xx<=x+Ws2; xx++) {\n      assert(xx<Vm); assert(yy<Vn); assert(zz<Vp);\n    // printf(\"x %lu y %lu z %lu\\n\", x, y, z);\n \n      W[pos++] = V[xx + yy*Vm + zz*Vm*Vn];\n    }\n  }\n  //  showRegion(W, Ws);\n return 0;\n}\n\nvoid showRegion(double * W, size_t Ws)\n  // Dump some quadratic region to the terminal\n{\nprintf(\"Show region ...\\n\");\n  for(size_t xx = 0 ; xx<Ws; xx++) {\n    for(size_t yy = 0; yy<Ws; yy++) {\n      printf(\"%f \", W[yy*Ws+xx]);\n    }\n    printf(\"\\n\");\n  }\n}\n", "meta": {"hexsha": "68a323a1257bc8ab3dd17fd52ea28697203355d0", "size": 5292, "ext": "c", "lang": "C", "max_stars_repo_path": "common/mex/mlfit.c", "max_stars_repo_name": "elgw/dotter", "max_stars_repo_head_hexsha": "8fe0ab3610ff5473bccbac169795a0d1b72c1938", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-12-15T08:20:13.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-15T08:20:13.000Z", "max_issues_repo_path": "common/mex/mlfit.c", "max_issues_repo_name": "elgw/dotter", "max_issues_repo_head_hexsha": "8fe0ab3610ff5473bccbac169795a0d1b72c1938", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "common/mex/mlfit.c", "max_forks_repo_name": "elgw/dotter", "max_forks_repo_head_hexsha": "8fe0ab3610ff5473bccbac169795a0d1b72c1938", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 22.8103448276, "max_line_length": 99, "alphanum_fraction": 0.5801209373, "num_tokens": 1949, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.45713673161914675, "lm_q2_score": 0.02758528142736254, "lm_q1q2_score": 0.012610245392498864}}
{"text": "///\n/// @file\n///\n/// @author Mirko Myllykoski (mirkom@cs.umu.se), Umeå University\n///\n/// @internal LICENSE\n///\n/// Copyright (c) 2019-2020, Umeå Universitet\n///\n/// Redistribution and use in source and binary forms, with or without\n/// modification, are permitted provided that the following conditions are met:\n///\n/// 1. Redistributions of source code must retain the above copyright notice,\n///    this list of conditions and the following disclaimer.\n///\n/// 2. Redistributions in binary form must reproduce the above copyright notice,\n///    this list of conditions and the following disclaimer in the documentation\n///    and/or other materials provided with the distribution.\n///\n/// 3. Neither the name of the copyright holder nor the names of its\n///    contributors may be used to endorse or promote products derived from this\n///    software without specific prior written permission.\n///\n/// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n/// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n/// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n/// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n/// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n/// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n/// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n/// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n/// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n/// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n/// POSSIBILITY OF SUCH DAMAGE.\n///\n\n#include <starneig_test_config.h>\n#include <starneig/configuration.h>\n#include \"solvers.h\"\n#include \"../common/common.h\"\n#include \"../common/parse.h\"\n#include \"../common/local_pencil.h\"\n#ifdef STARNEIG_ENABLE_MPI\n#include \"../common/starneig_pencil.h\"\n#endif\n#include \"../common/threads.h\"\n#include <starneig/starneig.h>\n#include <stdlib.h>\n#include <stdio.h>\n#include <string.h>\n#include <cblas.h>\n#include <omp.h>\n\n#ifdef MAGMA_FOUND\n#include <cuda_runtime_api.h>\n#include <cuda.h>\n#include <magma_auxiliary.h>\n#include <magma_d.h>\n#endif\n\nstatic hook_solver_state_t lapack_prepare(\n    int argc, char * const *argv, struct hook_data_env *env)\n{\n    return (hook_solver_state_t) env->data;\n}\n\nstatic int lapack_finalize(hook_solver_state_t state, struct hook_data_env *env)\n{\n    return 0;\n}\n\nstatic int lapack_run(hook_solver_state_t state)\n{\n    pencil_t data = (pencil_t) state;\n\n    extern void dgehrd_(\n        int const *,    // the order of the matrix A\n        int const *,    // left bound\n        int const *,    // right bound\n        double *,       // input/output matrix\n        int const *,    // input/output matrix leading dimension\n        double *,       // tau (scalar factors)\n        double *,       // work space\n        int const *,    // work space size\n        int *);         // info\n\n    extern void dormhr_(\n        char const *,   // side\n        char const *,   // transpose\n        int const *,    // row count\n        int const *,    // column count\n        int const *,    // left bound\n        int const *,    // right bound\n        double const *, // elementary reflectors\n        int const *,    // elementary reflector leading dimension\n        double const *, // scalar factors (tau)\n        double *,       // input/output matrix\n        int const *,    // input/output matrix leading dimension\n        double *,       // work space\n        int const *,    // work space size\n        int *);         // info\n\n    extern void dgeqrf_(int const *, int const *, double *, int const *,\n        double *, double *, int const *, int *);\n\n    extern void dormqr_(char const *, char const *, int const *, int const *,\n        int const *, double const *, int const *, double const *, double *,\n        int const *, double*, const int *, int *);\n\n    extern void dgghd3_(char const *, char const *, int const *, int const *,\n        int const *, double *, int const *, double *, int const *, double *,\n        int const *, double *, int const *, double *, int const *, int *);\n\n    int n = LOCAL_MATRIX_N(data->mat_a);\n    double *A = LOCAL_MATRIX_PTR(data->mat_a);\n    int ldA = LOCAL_MATRIX_LD(data->mat_a);\n    double *Q = LOCAL_MATRIX_PTR(data->mat_q);\n    int ldQ = LOCAL_MATRIX_LD(data->mat_q);\n\n    double *B = NULL;\n    int ldB = 0;\n    double *Z = NULL;\n    int ldZ = 0;\n\n    double *tau = NULL;\n    double *work = NULL;\n    int info, ilo = 1, ihi = n;\n\n    threads_set_mode(THREADS_MODE_LAPACK);\n\n    if (data->mat_b != NULL) {\n        B = LOCAL_MATRIX_PTR(data->mat_b);\n        ldB = LOCAL_MATRIX_LD(data->mat_b);\n        Z = LOCAL_MATRIX_PTR(data->mat_z);\n        ldZ = LOCAL_MATRIX_LD(data->mat_z);\n\n        //\n        // allocate workspace\n        //\n\n        int lwork = 0;\n\n        {\n            int _lwork = -1;\n            double dlwork;\n\n            dgeqrf_(&n, &n, B, &ldB, tau, &dlwork, &_lwork, &info);\n            if (info != 0)\n                goto cleanup;\n\n            lwork = MAX(lwork, dlwork);\n        }\n\n        {\n            int _lwork = -1;\n            double dlwork;\n\n            dormqr_(\"L\", \"T\", &n, &n, &n,\n                B, &ldB, tau, A, &ldA, &dlwork, &_lwork, &info);\n            if (info != 0)\n                goto cleanup;\n\n            lwork = MAX(lwork, dlwork);\n        }\n\n        {\n            int _lwork = -1;\n            double dlwork;\n\n            dormqr_(\"R\", \"N\", &n, &n, &n,\n                B, &ldB, tau, Q, &ldQ, &dlwork, &_lwork, &info);\n            if (info != 0)\n                goto cleanup;\n\n            lwork = MAX(lwork, dlwork);\n        }\n\n        {\n            int _lwork = -1;\n            double dlwork;\n\n            dgghd3_(\"V\", \"V\", &n, &ilo, &ihi,\n                A, &ldA, B, &ldB, Q, &ldQ, Z, &ldZ, &dlwork, &_lwork, &info);\n            if (info != 0)\n                goto cleanup;\n\n            lwork = MAX(lwork, dlwork);\n        }\n\n        tau = malloc(n*sizeof(double));\n        work = malloc(lwork*sizeof(double));\n\n        //\n        // reduce\n        //\n\n        // form B = ~Q * R\n        dgeqrf_(&n, &n, B, &ldB, tau, work, &lwork, &info);\n        if (info != 0)\n            goto cleanup;\n\n        // A <- ~Q^T * A\n        dormqr_(\"L\", \"T\", &n, &n, &n, B, &ldB, tau, A, &ldA, work, &lwork,\n            &info);\n        if (info != 0)\n            goto cleanup;\n\n        // Q <- Q * ~Q\n        dormqr_(\"R\", \"N\", &n, &n, &n, B, &ldB, tau, Q, &ldQ, work, &lwork,\n            &info);\n        if (info != 0)\n            goto cleanup;\n\n        // clean B (B <- R)\n        for (int i = 0; i < n; i++)\n            for (int j = i+1; j < n; j++)\n                B[(size_t)i*ldB+j] = 0.0;\n\n        // reduce (A,B) to Hessenberg-triangular form\n        dgghd3_(\"V\", \"V\", &n, &ilo, &ihi,\n            A, &ldA, B, &ldB, Q, &ldQ, Z, &ldZ, work, &lwork, &info);\n        if (info != 0)\n            goto cleanup;\n    }\n    else {\n\n        int lwork = -1;\n        double dlwork;\n\n        // request optimal work space size\n        dgehrd_(&n, &ilo, &ihi, A, &ldA,\n            tau, &dlwork, &lwork, &info);\n\n        if (info != 0)\n            goto cleanup;\n\n        lwork = dlwork;\n        work = malloc(lwork*sizeof(double));\n        tau = malloc(n*sizeof(double));\n\n        // reduce\n        dgehrd_(&n, &ilo, &ihi, A, &ldA,\n            tau, work, &lwork, &info);\n\n        if (info != 0)\n            goto cleanup;\n\n        free(work);\n        work = NULL;\n\n        // request optimal work space size\n        lwork = -1;\n        dormhr_(\"Right\", \"No transpose\", &n, &n, &ilo, &ihi, A, &ldA, tau,\n            Q, &ldQ, &dlwork, &lwork, &info);\n\n        if (info != 0)\n            goto cleanup;\n\n        lwork = dlwork;\n        work = malloc(lwork*sizeof(double));\n\n        // form Q\n        dormhr_(\"Right\", \"No transpose\", &n, &n, &ilo, &ihi, A, &ldA, tau,\n            Q, &ldQ, work, &lwork, &info);\n\n        if (info != 0)\n            goto cleanup;\n\n        for (int i = 0; i < n; i++)\n            for (int j = i+2; j < n; j++)\n                A[i*ldA+j] = 0.0;\n    }\n\ncleanup:\n\n    threads_set_mode(THREADS_MODE_DEFAULT);\n\n    free(work);\n    free(tau);\n    return info;\n}\n\nconst struct hook_solver hessenberg_lapack_solver = {\n    .name = \"lapack\",\n    .desc = \"LAPACK's dgehrd/dgghrd subroutine\",\n    .formats = (hook_data_format_t[]) { HOOK_DATA_FORMAT_PENCIL_LOCAL, 0 },\n    .prepare = &lapack_prepare,\n    .finalize = &lapack_finalize,\n    .run = &lapack_run\n};\n\n////////////////////////////////////////////////////////////////////////////////\n////////////////////////////////////////////////////////////////////////////////\n////////////////////////////////////////////////////////////////////////////////\n\n#if defined(PDGEHRD_FOUND) && defined(PDORMHR_FOUND) && defined(PDLASET_FOUND)\n\nstatic hook_solver_state_t scalapack_prepare(\n    int argc, char * const *argv, struct hook_data_env *env)\n{\n    return env;\n}\n\nstatic int scalapack_finalize(\n    hook_solver_state_t state, struct hook_data_env *env)\n{\n    return 0;\n}\n\nstatic int has_valid_descr(\n    int matrix_size, int section_size, const starneig_blacs_descr_t *descr)\n{\n    if (descr->m != matrix_size || descr->n != matrix_size)\n        return 0;\n    if (descr->sm != section_size || descr->sn != section_size)\n        return 0;\n    return 1;\n}\n\nstatic int scalapack_run(hook_solver_state_t state)\n{\n    extern void pdgehrd_(int const *, int const *, int const *, double *,\n        int const *, int const *, const starneig_blacs_descr_t *, double *,\n        double *, int const *, int *);\n\n    extern void pdormhr_(char const *, char const *, int const *, int const *,\n        int const *, int const *, double *, int const *, int const *,\n        const starneig_blacs_descr_t *, double *, double *, int const *,\n        int const *, const starneig_blacs_descr_t *, double *, int const *,\n        int *);\n\n    extern void pdlaset_(char const *, int const *, int const *,\n        double const *, double const *, double *, int const *, int const *,\n        const starneig_blacs_descr_t *);\n\n    threads_set_mode(THREADS_MODE_SCALAPACK);\n\n    struct hook_data_env *env = state;\n    pencil_t pencil = (pencil_t) env->data;\n\n    if (pencil->mat_a == NULL) {\n        fprintf(stderr, \"Missing matrix A.\\n\");\n        return -1;\n    }\n\n    if (pencil->mat_b != NULL) {\n        fprintf(stderr, \"Solver does not support generalized cases.\\n\");\n        return -1;\n    }\n\n    int n = STARNEIG_MATRIX_N(pencil->mat_a);\n    int sn = STARNEIG_MATRIX_BN(pencil->mat_a);\n\n    starneig_distr_t distr = STARNEIG_MATRIX_DISTR(pencil->mat_a);\n    starneig_blacs_context_t context = starneig_distr_to_blacs_context(distr);\n\n    starneig_blacs_descr_t desc_a, desc_q;\n    double *local_a, *local_q;\n    STARNEIG_BLACS_MATRIX_DESCR_LOCAL(\n        pencil->mat_a, context, &desc_a, (void **)&local_a);\n    STARNEIG_BLACS_MATRIX_DESCR_LOCAL(\n        pencil->mat_q, context, &desc_q, (void **)&local_q);\n\n    if (!has_valid_descr(n, sn, &desc_a)) {\n        fprintf(stderr, \"Matrix A has invalid dimensions.\\n\");\n        return -1;\n    }\n\n    if (pencil->mat_q != NULL && !has_valid_descr(n, sn, &desc_q)) {\n        fprintf(stderr, \"Matrix Q has invalid dimension.\\n\");\n        return -1;\n    }\n\n    int ilo = 1, ihi = n, ia = 1, ja = 1, ic = 1, jc = 1, lwork, info;\n    double *work = NULL, *tau = NULL, _work;\n\n    lwork = -1;\n    pdgehrd_(&n, &ilo, &ihi, NULL, &ia, &ja, &desc_a, NULL,\n        &_work, &lwork, &info);\n\n    if (info)\n        goto cleanup;\n\n    lwork = _work;\n    work = malloc(lwork*sizeof(double));\n    tau = malloc(n*sizeof(double));\n\n    pdgehrd_(&n, &ilo, &ihi, local_a, &ia, &ja, &desc_a, tau,\n        work, &lwork, &info);\n\n    if (info)\n        goto cleanup;\n\n    lwork = -1;\n    pdormhr_(\"Right\", \"No transpose\", &n, &n, &ilo, &ihi, NULL,\n        &ia, &ja, &desc_a, NULL, NULL, &ic, &jc,\n        &desc_q, &_work, &lwork, &info);\n\n    if (info)\n        goto cleanup;\n\n    free(work);\n    lwork = _work;\n    work = malloc(lwork*sizeof(double));\n\n    pdormhr_(\"Right\", \"No transpose\", &n, &n, &ilo, &ihi, local_a,\n        &ia, &ja, &desc_a, tau, local_q, &ic, &jc,\n        &desc_q, work, &lwork, &info);\n\n    {\n        int nm1 = n-2, one = 1, three = 3;\n        double dzero = 0.0;\n        pdlaset_(\"Lower\", &nm1, &nm1, &dzero, &dzero, local_a, &three,\n            &one, &desc_a);\n    }\n\ncleanup:\n\n    threads_set_mode(THREADS_MODE_DEFAULT);\n    starneig_blacs_gridexit(context);\n\n    free(work);\n    free(tau);\n\n    return info;\n}\n\nconst struct hook_solver hessenberg_scalapack_solver = {\n    .name = \"scalapack\",\n    .desc = \"pdgehrd subroutine from scaLAPACK\",\n    .formats = (hook_data_format_t[]) {\n#ifdef STARNEIG_ENABLE_BLACS\n        HOOK_DATA_FORMAT_PENCIL_BLACS,\n#endif\n        0 },\n    .prepare = &scalapack_prepare,\n    .finalize = &scalapack_finalize,\n    .run = &scalapack_run\n};\n\n#endif // PDGEHRD_FOUND\n\n////////////////////////////////////////////////////////////////////////////////\n////////////////////////////////////////////////////////////////////////////////\n////////////////////////////////////////////////////////////////////////////////\n\nstruct starpu_state {\n    int argc;\n    char * const *argv;\n    struct hook_data_env *env;\n};\n\nstatic void starpu_print_usage(int argc, char * const *argv)\n{\n    printf(\n        \"  --cores [default,(num)} -- Number of CPU cores\\n\"\n        \"  --gpus [default,(num)} -- Number of GPUS\\n\"\n        \"  --tile-size [default,(num)] -- tile size\\n\"\n        \"  --panel-width [default,(num)] -- Panel width\\n\"\n    );\n}\n\nstatic int starpu_check_args(int argc, char * const *argv, int *argr)\n{\n    struct multiarg_t arg_cores = read_multiarg(\n        \"--cores\", argc, argv, argr, \"default\", NULL);\n    struct multiarg_t arg_gpus = read_multiarg(\n        \"--gpus\", argc, argv, argr, \"default\", NULL);\n    struct multiarg_t tile_size = read_multiarg(\n        \"--tile-size\", argc, argv, argr, \"default\", NULL);\n    struct multiarg_t panel_width = read_multiarg(\n        \"--panel-width\", argc, argv, argr, \"default\", NULL);\n\n    if (arg_cores.type == MULTIARG_INVALID)\n        return -1;\n\n    if (arg_gpus.type == MULTIARG_INVALID)\n        return -1;\n\n    if (tile_size.type == MULTIARG_INVALID ||\n    (tile_size.type == MULTIARG_INT && tile_size.int_value < 1)) {\n        fprintf(stderr, \"Invalid tile size.\\n\");\n        return -1;\n    }\n\n    if (panel_width.type == MULTIARG_INVALID ||\n    (panel_width.type == MULTIARG_INT && panel_width.int_value < 1)) {\n        fprintf(stderr, \"Invalid panel width.\\n\");\n        return -1;\n    }\n\n    return 0;\n}\n\nstatic void starpu_print_args(int argc, char * const *argv)\n{\n    print_multiarg(\"--cores\", argc, argv, \"default\", NULL);\n    print_multiarg(\"--gpus\", argc, argv, \"default\", NULL);\n    print_multiarg(\"--tile-size\", argc, argv, \"default\", NULL);\n    print_multiarg(\"--panel-width\", argc, argv, \"default\", NULL);\n}\n\nstatic hook_solver_state_t starpu_prepare(\n    int argc, char * const *argv, struct hook_data_env *env)\n{\n    struct starpu_state *state = malloc(sizeof(struct starpu_state));\n\n    state->argc = argc;\n    state->argv = argv;\n    state->env = env;\n\n    struct multiarg_t arg_cores = read_multiarg(\n        \"--cores\", argc, argv, NULL, \"default\", NULL);\n    struct multiarg_t arg_gpus = read_multiarg(\n        \"--gpus\", argc, argv, NULL, \"default\", NULL);\n\n    int cores = STARNEIG_USE_ALL;\n    if (arg_cores.type == MULTIARG_INT)\n        cores = arg_cores.int_value;\n\n    int gpus = STARNEIG_USE_ALL;\n    if (arg_gpus.type == MULTIARG_INT)\n        gpus = arg_gpus.int_value;\n\n#ifdef STARNEIG_ENABLE_MPI\n    if (env->format == HOOK_DATA_FORMAT_PENCIL_STARNEIG ||\n    env->format == HOOK_DATA_FORMAT_PENCIL_BLACS)\n        starneig_node_init(cores, gpus, STARNEIG_FAST_DM);\n    else\n#endif\n        starneig_node_init(\n            cores, gpus, STARNEIG_HINT_SM | STARNEIG_AWAKE_WORKERS);\n\n    return state;\n}\n\nstatic int starpu_finalize(hook_solver_state_t state, struct hook_data_env *env)\n{\n    if (state == NULL)\n        return 0;\n\n    starneig_node_finalize();\n\n    free(state);\n    return 0;\n}\n\nstatic int starpu_run(hook_solver_state_t state)\n{\n    int argc = ((struct starpu_state *) state)->argc;\n    char * const *argv = ((struct starpu_state *) state)->argv;\n    struct hook_data_env *env = ((struct starpu_state *) state)->env;\n\n    struct starneig_hessenberg_conf conf;\n    starneig_hessenberg_init_conf(&conf);\n\n    struct multiarg_t tile_size = read_multiarg(\n        \"--tile-size\", argc, argv, NULL, \"default\", NULL);\n    struct multiarg_t panel_width = read_multiarg(\n        \"--panel-width\", argc, argv, NULL, \"default\", NULL);\n\n    if (tile_size.type == MULTIARG_INT)\n        conf.tile_size = tile_size.int_value;\n    if (panel_width.type == MULTIARG_INT)\n        conf.panel_width = panel_width.int_value;\n\n    int ret = 0;\n\n    if (env->format == HOOK_DATA_FORMAT_PENCIL_LOCAL) {\n        pencil_t pencil = (pencil_t) env->data;\n        if (pencil->mat_b != NULL) {\n            ret = starneig_GEP_SM_HessenbergTriangular(\n                LOCAL_MATRIX_N(pencil->mat_a),\n                LOCAL_MATRIX_PTR(pencil->mat_a), LOCAL_MATRIX_LD(pencil->mat_a),\n                LOCAL_MATRIX_PTR(pencil->mat_b), LOCAL_MATRIX_LD(pencil->mat_b),\n                LOCAL_MATRIX_PTR(pencil->mat_q), LOCAL_MATRIX_LD(pencil->mat_q),\n                LOCAL_MATRIX_PTR(pencil->mat_z), LOCAL_MATRIX_LD(pencil->mat_z)\n            );\n        }\n        else {\n            ret = starneig_SEP_SM_Hessenberg_expert(&conf,\n                LOCAL_MATRIX_N(pencil->mat_a), 0, LOCAL_MATRIX_N(pencil->mat_a),\n                LOCAL_MATRIX_PTR(pencil->mat_a), LOCAL_MATRIX_LD(pencil->mat_a),\n                LOCAL_MATRIX_PTR(pencil->mat_q), LOCAL_MATRIX_LD(pencil->mat_q)\n            );\n        }\n    }\n#ifdef STARNEIG_ENABLE_MPI\n    if (env->format == HOOK_DATA_FORMAT_PENCIL_BLACS) {\n        pencil_t pencil = (pencil_t) env->data;\n        if (pencil->mat_b != NULL) {\n#ifdef STARNEIG_GEP_DM_HESSENBERGTRIANGULAR\n            ret = starneig_GEP_DM_HessenbergTriangular(\n                STARNEIG_MATRIX_HANDLE(pencil->mat_a),\n                STARNEIG_MATRIX_HANDLE(pencil->mat_b),\n                STARNEIG_MATRIX_HANDLE(pencil->mat_q),\n                STARNEIG_MATRIX_HANDLE(pencil->mat_z));\n#else\n            fprintf(stderr,\n                \"Solver does not support generalized cases in distributed \"\n                \"memory.\\n\");\n            return -1;\n#endif\n        }\n        else {\n            ret = starneig_SEP_DM_Hessenberg(\n                STARNEIG_MATRIX_HANDLE(pencil->mat_a),\n                STARNEIG_MATRIX_HANDLE(pencil->mat_q));\n        }\n    }\n#endif\n\n    return ret;\n}\n\nconst struct hook_solver hessenberg_starpu_solver = {\n    .name = \"starneig\",\n    .desc = \"StarPU based subroutine\",\n    .formats = (hook_data_format_t[]) {\n        HOOK_DATA_FORMAT_PENCIL_LOCAL,\n#ifdef STARNEIG_ENABLE_BLACS\n        HOOK_DATA_FORMAT_PENCIL_BLACS,\n#endif\n        0 },\n    .print_usage = &starpu_print_usage,\n    .print_args = &starpu_print_args,\n    .check_args = &starpu_check_args,\n    .prepare = &starpu_prepare,\n    .finalize = &starpu_finalize,\n    .run = &starpu_run\n};\n\n////////////////////////////////////////////////////////////////////////////////\n////////////////////////////////////////////////////////////////////////////////\n////////////////////////////////////////////////////////////////////////////////\n\nstatic void starpu_simple_print_usage(int argc, char * const *argv)\n{\n    printf(\n        \"  --cores [default,(num)} -- Number of CPU cores\\n\"\n        \"  --gpus [default,(num)} -- Number of GPUS\\n\"\n    );\n}\n\nstatic void starpu_simple_print_args(int argc, char * const *argv)\n{\n    print_multiarg(\"--cores\", argc, argv, \"default\", NULL);\n    print_multiarg(\"--gpus\", argc, argv, \"default\", NULL);\n}\n\nstatic int starpu_simple_check_args(int argc, char * const *argv, int *argr)\n{\n    struct multiarg_t arg_cores = read_multiarg(\n        \"--cores\", argc, argv, argr, \"default\", NULL);\n    struct multiarg_t arg_gpus = read_multiarg(\n        \"--gpus\", argc, argv, argr, \"default\", NULL);\n\n    if (arg_cores.type == MULTIARG_INVALID)\n        return -1;\n\n    if (arg_gpus.type == MULTIARG_INVALID)\n        return -1;\n\n    return 0;\n}\n\nstatic hook_solver_state_t starpu_simple_prepare(\n    int argc, char * const *argv, struct hook_data_env *env)\n{\n    struct starpu_state *state = malloc(sizeof(struct starpu_state));\n\n    state->argc = argc;\n    state->argv = argv;\n    state->env = env;\n\n    struct multiarg_t arg_cores = read_multiarg(\n        \"--cores\", argc, argv, NULL, \"default\", NULL);\n    struct multiarg_t arg_gpus = read_multiarg(\n        \"--gpus\", argc, argv, NULL, \"default\", NULL);\n\n    int cores = STARNEIG_USE_ALL;\n    if (arg_cores.type == MULTIARG_INT)\n        cores = arg_cores.int_value;\n\n    int gpus = STARNEIG_USE_ALL;\n    if (arg_gpus.type == MULTIARG_INT)\n        gpus = arg_gpus.int_value;\n\n#ifdef STARNEIG_ENABLE_MPI\n    if (env->format == HOOK_DATA_FORMAT_PENCIL_STARNEIG ||\n    env->format == HOOK_DATA_FORMAT_PENCIL_BLACS)\n        starneig_node_init(cores, gpus, STARNEIG_FAST_DM);\n    else\n#endif\n        starneig_node_init(\n            cores, gpus, STARNEIG_HINT_SM | STARNEIG_AWAKE_WORKERS);\n\n    return state;\n}\n\nstatic int starpu_simple_finalize(\n    hook_solver_state_t state, struct hook_data_env *env)\n{\n    if (state == NULL)\n        return 0;\n\n    starneig_node_finalize();\n\n    free(state);\n    return 0;\n}\n\nstatic int starpu_simple_run(hook_solver_state_t state)\n{\n    struct hook_data_env *env = ((struct starpu_state *) state)->env;\n\n    int ret = 0;\n\n    if (env->format == HOOK_DATA_FORMAT_PENCIL_LOCAL) {\n        pencil_t pencil = (pencil_t) env->data;\n\n        if (pencil->mat_b != NULL) {\n            ret = starneig_GEP_SM_HessenbergTriangular(\n                LOCAL_MATRIX_N(pencil->mat_a),\n                LOCAL_MATRIX_PTR(pencil->mat_a), LOCAL_MATRIX_LD(pencil->mat_a),\n                LOCAL_MATRIX_PTR(pencil->mat_b), LOCAL_MATRIX_LD(pencil->mat_b),\n                LOCAL_MATRIX_PTR(pencil->mat_q), LOCAL_MATRIX_LD(pencil->mat_q),\n                LOCAL_MATRIX_PTR(pencil->mat_z), LOCAL_MATRIX_LD(pencil->mat_z)\n            );\n        }\n        else {\n            ret = starneig_SEP_SM_Hessenberg(LOCAL_MATRIX_N(pencil->mat_a),\n                LOCAL_MATRIX_PTR(pencil->mat_a), LOCAL_MATRIX_LD(pencil->mat_a),\n                LOCAL_MATRIX_PTR(pencil->mat_q), LOCAL_MATRIX_LD(pencil->mat_q)\n            );\n        }\n    }\n#ifdef STARNEIG_ENABLE_MPI\n    if (env->format == HOOK_DATA_FORMAT_PENCIL_BLACS) {\n        pencil_t pencil = (pencil_t) env->data;\n\n        if (pencil->mat_b != NULL) {\n#ifdef STARNEIG_GEP_DM_HESSENBERGTRIANGULAR\n            ret = starneig_GEP_DM_HessenbergTriangular(\n                STARNEIG_MATRIX_HANDLE(pencil->mat_a),\n                STARNEIG_MATRIX_HANDLE(pencil->mat_b),\n                STARNEIG_MATRIX_HANDLE(pencil->mat_q),\n                STARNEIG_MATRIX_HANDLE(pencil->mat_z));\n#else\n            fprintf(stderr,\n                \"Solver does not support distributed memory in generalized \"\n                \"cases.\\n\");\n            return -1;\n#endif\n        }\n        else {\n            ret = starneig_SEP_DM_Hessenberg(\n                STARNEIG_MATRIX_HANDLE(pencil->mat_a),\n                STARNEIG_MATRIX_HANDLE(pencil->mat_q));\n        }\n    }\n#endif\n\n    return ret;\n}\n\nconst struct hook_solver hessenberg_starpu_simple_solver = {\n    .name = \"starneig-simple\",\n    .desc = \"StarPU based subroutine (simplified interface)\",\n    .formats = (hook_data_format_t[]) {\n        HOOK_DATA_FORMAT_PENCIL_LOCAL,\n#ifdef STARNEIG_ENABLE_BLACS\n        HOOK_DATA_FORMAT_PENCIL_BLACS,\n#endif\n        0 },\n    .print_usage = &starpu_simple_print_usage,\n    .print_args = &starpu_simple_print_args,\n    .check_args = &starpu_simple_check_args,\n    .prepare = &starpu_simple_prepare,\n    .finalize = &starpu_simple_finalize,\n    .run = &starpu_simple_run\n};\n\n////////////////////////////////////////////////////////////////////////////////\n////////////////////////////////////////////////////////////////////////////////\n////////////////////////////////////////////////////////////////////////////////\n\n#ifdef MAGMA_FOUND\n\nstatic hook_solver_state_t magma_dgehrd_prepare(\n    int argc, char * const *argv, struct hook_data_env *env)\n{\n    if (magma_init() != MAGMA_SUCCESS)\n        return NULL;\n    return (hook_solver_state_t) env->data;\n}\n\nstatic int magma_dgehrd_finalize(\n    hook_solver_state_t state, struct hook_data_env *env)\n{\n    magma_finalize();\n    return 0;\n}\n\nstatic int magma_dgehrd_run(hook_solver_state_t state)\n{\n    pencil_t data = (pencil_t) state;\n\n    int n = LOCAL_MATRIX_N(data->mat_a);\n    double *A = LOCAL_MATRIX_PTR(data->mat_a);\n    double *Q = LOCAL_MATRIX_PTR(data->mat_q);\n    int ldA = LOCAL_MATRIX_LD(data->mat_a);\n    int ldQ = LOCAL_MATRIX_LD(data->mat_q);\n\n    int info;\n\n    double *tau = NULL;\n    double *work = NULL;\n    double *dT = NULL;\n\n    threads_set_mode(THREADS_MODE_LAPACK);\n\n    // request optimal work space size\n    double _work;\n    magma_dgehrd(n, 1, n, A, ldA, tau, &_work, -1, dT, &info);\n\n    if (info != 0)\n        goto finalize;\n\n    tau = malloc(LOCAL_MATRIX_N(data->mat_a)*sizeof(double));\n\n    int lwork = _work;\n    work = malloc(lwork*sizeof(double));\n\n    int nb = magma_get_dgehrd_nb(LOCAL_MATRIX_N(data->mat_a));\n    cudaMalloc((void**)&dT, nb*n*sizeof(double));\n\n    // reduce\n    magma_dgehrd(n, 1, n, A, ldA, tau, work, lwork, dT, &info);\n\n    if (info != 0)\n        goto finalize;\n\n    free(work);\n    work = NULL;\n\n    // copy A -> Q\n    for (int i = 0; i < n; i++)\n        memcpy(Q+i*ldQ, A+i*ldA, n*sizeof(double));\n\n    // form Q\n    magma_dorghr(n, 1, n, Q, ldQ, tau, dT, nb, &info);\n\n    if (info != 0)\n        goto finalize;\n\n    // zero entries below the first sub-diagonal\n    for (int i = 0; i < n-1; i++)\n        memset(A+i*ldA+i+2, 0, (n-i-2)*sizeof(double));\n\nfinalize:\n\n    threads_set_mode(THREADS_MODE_DEFAULT);\n\n    cudaFree(dT);\n    free(work);\n    free(tau);\n    return info;\n}\n\nconst struct hook_solver hessenberg_magma_solver = {\n    .name = \"magma\",\n    .desc = \"MAGMA's dgehrd subroutine\",\n    .formats = (hook_data_format_t[]) { HOOK_DATA_FORMAT_PENCIL_LOCAL, 0 },\n    .prepare = &magma_dgehrd_prepare,\n    .finalize = &magma_dgehrd_finalize,\n    .run = &magma_dgehrd_run\n};\n\n#endif // MAGMA_FOUND\n", "meta": {"hexsha": "8dcf72c5c84ccd3cd71dceb35667771ed635a65f", "size": 26422, "ext": "c", "lang": "C", "max_stars_repo_path": "test/hessenberg/solvers.c", "max_stars_repo_name": "NLAFET/StarNEig", "max_stars_repo_head_hexsha": "d47ed4dfbcdaec52e44f0b02d14a6e0cde64d286", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 12.0, "max_stars_repo_stars_event_min_datetime": "2019-04-28T17:13:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-24T12:30:19.000Z", "max_issues_repo_path": "test/hessenberg/solvers.c", "max_issues_repo_name": "NLAFET/StarNEig", "max_issues_repo_head_hexsha": "d47ed4dfbcdaec52e44f0b02d14a6e0cde64d286", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "test/hessenberg/solvers.c", "max_forks_repo_name": "NLAFET/StarNEig", "max_forks_repo_head_hexsha": "d47ed4dfbcdaec52e44f0b02d14a6e0cde64d286", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2019-04-30T12:14:12.000Z", "max_forks_repo_forks_event_max_datetime": "2020-04-14T09:41:23.000Z", "avg_line_length": 29.9909194098, "max_line_length": 80, "alphanum_fraction": 0.581787904, "num_tokens": 6968, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4378234991142019, "lm_q2_score": 0.028436031089369332, "lm_q1q2_score": 0.01244996263246791}}
{"text": "/*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*\n**                                                                                  **\n** This file forms part of the Underworld geophysics modelling application.         **\n**                                                                                  **\n** For full license and copyright information, please refer to the LICENSE.md file  **\n** located at the project root, or contact the authors.                             **\n**                                                                                  **\n**~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*/\n#include <mpi.h>\n#include <StGermain/StGermain.h>\n#include <StgDomain/StgDomain.h>\n#include <StgFEM/StgFEM.h>\n#include \"types.h\"\n#include <petsc.h>\n#include <petscvec.h>\n#include <petscmat.h>\n#include <petscksp.h>\n#include <petscpc.h>\n#include <petscsnes.h>\n#include <petscis.h>\n#include <petscviewer.h>\n#include <petscsys.h>\n#include <petscversion.h>\n\n#if ( (PETSC_VERSION_MAJOR >= 3) && (PETSC_VERSION_MINOR >=3) )\n  #if (PETSC_VERSION_MINOR >=6)\n     #include \"petsc/private/kspimpl.h\"\n  #else\n     #include \"petsc-private/kspimpl.h\"   /*I \"petscksp.h\" I*/\n  #endif\n#else\n  #include \"private/kspimpl.h\"   /*I \"petscksp.h\" I*/\n#endif\n\n//#include \"ksptypes.h\"\n#include \"ksp-register.h\"\n#include \"StokesBlockKSPInterface.h\"\n\n#include <stdio.h>\n#include <stdlib.h>\n#include <assert.h>\n#include <string.h>\n\n/* Macro for checking number integrity - i.e. checks if number is infinite or \"not a number\" */\n#define SBKSP_isGoodNumber( number ) ( (! isnan( number ) ) && ( ! isinf( number ) ) )\n#define SBKSP_GetPetscMatrix( matrix ) ( (Mat)(matrix) )\n#define SBKSP_GetPetscVector( vector ) ( (Vec)(vector) )\n#define SBKSP_GetPetscKSP( solver ) ( (KSP)(solver)  )\nPetscErrorCode _BlockSolve( void* solver, void* _stokesSLE );\n\nconst Type StokesBlockKSPInterface_Type = \"StokesBlockKSPInterface\";\n\nvoid* _StokesBlockKSPInterface_DefaultNew( Name name ) {\n    SizeT                                              _sizeOfSelf = sizeof(StokesBlockKSPInterface);\n    Type                                                      type = StokesBlockKSPInterface_Type;\n    Stg_Class_DeleteFunction*                              _delete = _SLE_Solver_Delete;\n    Stg_Class_PrintFunction*                                _print = _SLE_Solver_Print;\n    Stg_Class_CopyFunction*                                  _copy = _SLE_Solver_Copy;\n    Stg_Component_BuildFunction*                            _build = _StokesBlockKSPInterface_Build;\n    Stg_Component_InitialiseFunction*                  _initialise = _StokesBlockKSPInterface_Initialise;\n    Stg_Component_ExecuteFunction*                        _execute = _SLE_Solver_Execute;\n    Stg_Component_DestroyFunction*                        _destroy = _SLE_Solver_Destroy;\n    SLE_Solver_GetResidualFunc*                       _getResidual = NULL;\n    Stg_Component_DefaultConstructorFunction*  _defaultConstructor = _StokesBlockKSPInterface_DefaultNew;\n    Stg_Component_ConstructFunction*                    _construct = _StokesBlockKSPInterface_AssignFromXML;\n    SLE_Solver_SolverSetupFunction*                   _solverSetup = _StokesBlockKSPInterface_SolverSetup;\n    SLE_Solver_SolveFunction*                               _solve = _StokesBlockKSPInterface_Solve;\n\n    AllocationType  nameAllocationType = NON_GLOBAL /* default value NON_GLOBAL */;\n    return (void*) _StokesBlockKSPInterface_New( STOKESBLOCKKSPINTERFACE_PASSARGS );\n}\n\n\n/* Creation implementation / Virtual constructor */\n/* Set up function pointers */\nStokesBlockKSPInterface* _StokesBlockKSPInterface_New( STOKESBLOCKKSPINTERFACE_DEFARGS )\n{\n    StokesBlockKSPInterface* self;\n    /* Allocate memory */\n    assert( _sizeOfSelf >= sizeof(StokesBlockKSPInterface) );\n\n    self = (StokesBlockKSPInterface*) _SLE_Solver_New( SLE_SOLVER_PASSARGS );\n\n    /* Virtual info */\n    return self;\n}\n\nvoid _StokesBlockKSPInterface_Init(\n\t\tStokesBlockKSPInterface*      self,\n\t\tStiffnessMatrix*   preconditioner,\n\t\tStokes_SLE *       st_sle,\n\t\tPETScMGSolver *    mg,\n        Name   filename,\n        char * string,\n\t\tStiffnessMatrix*  k2StiffMat,\n\t\tStiffnessMatrix*  mStiffMat,\n\t\tForceVector*\t  f2ForceVec,\n\t\tForceVector*\t  jForceVec,\n\t\tdouble            penaltyNumber,\n\t\tdouble            hFactor,\n\t\tStiffnessMatrix*  vmStiffMat,\n\t\tForceVector*\t  vmForceVec  )\n{\n\tself->preconditioner = preconditioner;\n\tself->st_sle = st_sle;\n\tself->mg     = mg;\n    self->optionsFile = filename;\n    self->optionsString = string;\n\tself->k2StiffMat = k2StiffMat;\n\tself->f2ForceVec = f2ForceVec;\n\tself->penaltyNumber = penaltyNumber;\n\tself->hFactor       = hFactor;\n\tself->mStiffMat = mStiffMat;\n\tself->jForceVec = jForceVec;\n\tself->vmStiffMat = vmStiffMat;\n\tself->vmForceVec = vmForceVec;\n\t/* add the vecs and matrices to the Base SLE class's dynamic lists, so they can be\n\tinitialised and built properly */\n\n\t/*\n\tif (k2StiffMat )\n\t    SystemLinearEquations_AddStiffnessMatrix( st_sle, k2StiffMat );\n\n\tif (f2ForceVec )\n\t    SystemLinearEquations_AddForceVector( st_sle, f2ForceVec );\n\n\tif (mStiffMat )\n\t    SystemLinearEquations_AddStiffnessMatrix( st_sle, mStiffMat );\n\n\tif (jForceVec )\n\t    SystemLinearEquations_AddForceVector( st_sle, jForceVec );\n\n\tif (vmStiffMat )\n\t    SystemLinearEquations_AddStiffnessMatrix( st_sle, vmStiffMat );\n\n\tif (vmForceVec )\n\t    SystemLinearEquations_AddForceVector( st_sle, vmForceVec );\n    */\n}\n\nvoid _StokesBlockKSPInterface_Build( void* solver, void* sle ) {/* it is the sle here being passed in*/\n\tStokesBlockKSPInterface*\tself  = (StokesBlockKSPInterface*)solver;\n\n\tStream_IndentBranch( StgFEM_Debug );\n\n\t/* Build Preconditioner */\n\tif ( self->preconditioner ) {\n\t\tStg_Component_Build( self->preconditioner, sle, False );\n\t\tSystemLinearEquations_AddStiffnessMatrix( self->st_sle, self->preconditioner );\n\n\t}\n\tif( self->mg ){\n\t    Stg_Component_Build( self->mg, sle, False );\n\t}\n\n\tStream_UnIndentBranch( StgFEM_Debug );\n}\n\nvoid _StokesBlockKSPInterface_AssignFromXML( void* solver, Stg_ComponentFactory* cf, void* data ) {\n\tStokesBlockKSPInterface* self         = (StokesBlockKSPInterface*) solver;\n\t//double                  tolerance;\n\t//Iteration_Index         maxUzawaIterations, minUzawaIterations;\n\tStiffnessMatrix*  preconditioner;\n\tStiffnessMatrix*  k2StiffMat;\n\tForceVector*\t  f2ForceVec;\n\tStiffnessMatrix*  mStiffMat;\n\tForceVector*\t  jForceVec;\n\tdouble            penaltyNumber;\n\tdouble            hFactor;\n\tStiffnessMatrix*  vmStiffMat;\n\tForceVector*\t  vmForceVec;\n\t//Bool                    useAbsoluteTolerance;\n\t//Bool                    monitor;\n\tStokes_SLE *            st_sle;\n\tPETScMGSolver *         mg;\n\t//Name                filename;\n\t//char* \t\t        string;\n\n\t_SLE_Solver_AssignFromXML( self, cf, data );\n\n\tpreconditioner = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)\"Preconditioner\", StiffnessMatrix, False, data  );\n\tst_sle  = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)\"stokesEqn\", Stokes_SLE, True, data  );\n\tmg      = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)\"mgSolver\", PETScMGSolver, False, data);\n\tk2StiffMat = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)\"2ndStressTensorMatrix\", StiffnessMatrix, False, data  );\n\tf2ForceVec = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)\"2ndForceVector\", ForceVector, False, data  );\n\tpenaltyNumber   = Stg_ComponentFactory_GetDouble( cf, self->name, (Dictionary_Entry_Key)\"penaltyNumber\", 0.0  );\n\thFactor         = Stg_ComponentFactory_GetDouble( cf, self->name, (Dictionary_Entry_Key)\"hFactor\", 0.0  );\n\tmStiffMat = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)\"MassMatrix\", StiffnessMatrix, False, data  );\n\tjForceVec = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)\"JunkForceVector\", ForceVector, False, data  );\n\tvmStiffMat = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)\"VelocityMassMatrix\", StiffnessMatrix, False, data  );\n\tvmForceVec = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)\"VMassForceVector\", ForceVector, False, data  );\n\n\t_StokesBlockKSPInterface_Init( self, preconditioner, st_sle, mg, NULL, NULL, k2StiffMat, mStiffMat,\n                                   f2ForceVec, jForceVec, penaltyNumber, hFactor, vmStiffMat, vmForceVec);\n\n}\n\nvoid _StokesBlockKSPInterface_Initialise( void* solver, void* data ) {\n\tStokesBlockKSPInterface* self = (StokesBlockKSPInterface*) solver;\n\tStokes_SLE*             sle  = (Stokes_SLE*)  self->st_sle;\n\n\t/* Initialise Parent */\n\t_SLE_Solver_Initialise( self, sle );\n\n\tKSPRegisterAllKSP(\"Solvers/KSPSolvers/src\");\n}\n\n/* SolverSetup */\n\nvoid _StokesBlockKSPInterface_SolverSetup( void* solver, void* stokesSLE ) {\n\tStokesBlockKSPInterface* self = (StokesBlockKSPInterface*) solver;\n\t//Stokes_SLE*             sle  = (Stokes_SLE*)             stokesSLE;\n\n \tJournal_DPrintf( self->debug, \"In %s:\\n\", __func__ );\n\tStream_IndentBranch( StgFEM_Debug );\n\n\tStream_UnIndentBranch( StgFEM_Debug );\n}\nvoid SBKSP_SetSolver( void* solver, void* stokesSLE ) {\n\tSLE_Solver* self = (SLE_Solver*) solver;\n\tStokes_SLE*              sle  = (Stokes_SLE*) stokesSLE;\n\n    sle->solver=self;\n\n}\nvoid SBKSP_SetPenalty( void* solver, double penalty ) {\n  StokesBlockKSPInterface* self = (StokesBlockKSPInterface*) solver;\n  self->penaltyNumber=penalty;\n}\n\nint SBKSP_GetPressureIts(void *solver){\n  StokesBlockKSPInterface* self = (StokesBlockKSPInterface*) solver;\n  return self->stats.pressure_its;\n}\n\n/***********************************************************************************************************/\n/***********************************************************************************************************/\n/***********************************************************************************************************/\n\nvoid SBKSP_GetStokesOperators(\n\t\tStokes_SLE *stokesSLE,\n\t\tMat *K,Mat *G,Mat *D,Mat *C,Mat *approxS,\n\t\tVec *f,Vec *h,Vec *u,Vec *p )\n{\n\n\t*K = *G = *D = *C = PETSC_NULL;\n\tif (stokesSLE->kStiffMat){      *K = SBKSP_GetPetscMatrix( stokesSLE->kStiffMat->matrix );     }\n\tif (stokesSLE->gStiffMat){      *G = SBKSP_GetPetscMatrix( stokesSLE->gStiffMat->matrix );     }\n\tif (stokesSLE->dStiffMat){      *D = SBKSP_GetPetscMatrix( stokesSLE->dStiffMat->matrix );     }\n\tif (stokesSLE->cStiffMat){      *C = SBKSP_GetPetscMatrix( stokesSLE->cStiffMat->matrix );     }\n\n\t/* preconditioner */\n\t*approxS = PETSC_NULL;\n\tif( ((StokesBlockKSPInterface*)stokesSLE->solver)->preconditioner ) {\n\t\tStiffnessMatrix *preconditioner;\n\n\t\tpreconditioner = ((StokesBlockKSPInterface*)stokesSLE->solver)->preconditioner;\n\t\t*approxS = SBKSP_GetPetscMatrix( preconditioner->matrix );\n\t}\n\n\t*f = *h = PETSC_NULL;\n\tif (stokesSLE->fForceVec){      *f = SBKSP_GetPetscVector( stokesSLE->fForceVec->vector );     }\n\tif (stokesSLE->hForceVec){      *h = SBKSP_GetPetscVector( stokesSLE->hForceVec->vector );     }\n\n\t*u = *p = PETSC_NULL;\n\tif (stokesSLE->uSolnVec){       *u = SBKSP_GetPetscVector( stokesSLE->uSolnVec->vector );      }\n\tif (stokesSLE->pSolnVec){       *p = SBKSP_GetPetscVector( stokesSLE->pSolnVec->vector );      }\n\n}\n/***********************************************************************************************************/\n/***********************************************************************************************************/\n/***********************************************************************************************************/\n/* Sets up Solver to be a custom ksp (KSP_BSSCR) solve by default: */\nvoid _StokesBlockKSPInterface_Solve( void* solver, void* _stokesSLE ) {\n  StokesBlockKSPInterface* self    = (StokesBlockKSPInterface*)solver;\n  PetscLogDouble flopsA,flopsB;\n  PetscTruth found, get_flops;\n\n  found = PETSC_FALSE;\n  get_flops = PETSC_FALSE;\n  PetscOptionsGetTruth( PETSC_NULL, \"-get_flops\", &get_flops, &found);\n  if(get_flops){\n    PetscGetFlops(&flopsA); }\n\n  _BlockSolve(solver, _stokesSLE);\n\n  if(get_flops){\n    PetscGetFlops(&flopsB);\n    self->stats.total_flops=(double)(flopsB-flopsA); }\n}\nPetscErrorCode _BlockSolve( void* solver, void* _stokesSLE ) {\n  Stokes_SLE*  stokesSLE  = (Stokes_SLE*)_stokesSLE;\n  StokesBlockKSPInterface* Solver    = (StokesBlockKSPInterface*)solver;\n\n  /* Create shortcuts to stuff needed on sle */\n  Mat       K;\n  Mat       G;\n  Mat       Gt;\n  Mat       D;\n  Mat       C;\n  Mat       approxS;\n  Vec       u;\n  Vec       p;\n  Vec       f;\n  Vec       h;\n  Mat stokes_P;\n  Mat stokes_A;\n  Vec stokes_x;\n  Vec stokes_b;\n  Mat a[2][2];\n  Vec x[2];\n  Vec b[2];\n  KSP stokes_ksp;\n  PC  stokes_pc;\n  PetscTruth sym,flg;\n  PetscErrorCode ierr;\n\n  PetscInt   N,n;\n\n  SBKSP_GetStokesOperators( stokesSLE, &K,&G,&D,&C, &approxS, &f,&h, &u,&p );\n\n  /* create Gt */\n  if( !D ) {\n    ierr = MatTranspose( G, MAT_INITIAL_MATRIX, &Gt);CHKERRQ(ierr);\n    sym = PETSC_TRUE;\n    Solver->DIsSym = sym;\n  }\n  else {\n    Gt = D;\n    sym = PETSC_FALSE;\n    Solver->DIsSym = sym;\n  }\n  flg=PETSC_FALSE;\n  PetscOptionsHasName(PETSC_NULL,\"-use_petsc_ksp\",&flg);\n  if (flg) {\n    if( !C ) {\n      /* Everything in this bracket, dependent on !C, is to build\n         a matrix with diagonals of 0 for C the previous comment ways\n\n      need a 'zero' matrix to keep fieldsplit happy in petsc? */\n      MatType mtype;\n      Vec V;\n      //MatGetSize( G, &M, &N );\n      VecGetSize(p, &N);\n      VecGetLocalSize( p, &n );\n      MatCreate( PetscObjectComm((PetscObject) K), &C );\n      MatSetSizes( C, PETSC_DECIDE ,PETSC_DECIDE, N, N );\n#if (((PETSC_VERSION_MAJOR==3) && (PETSC_VERSION_MINOR>=3)) || (PETSC_VERSION_MAJOR>3) )\n      MatSetUp(C);\n#endif\n      MatGetType( G, &mtype );\n      MatSetType( C, mtype );\n      MatGetVecs( G, &V, PETSC_NULL );\n      VecSet(V, 0.0);\n      //VecSet(h, 1.0);\n      ierr = VecAssemblyBegin( V );CHKERRQ(ierr);\n      ierr = VecAssemblyEnd  ( V );CHKERRQ(ierr);\n      ierr = MatDiagonalSet(C,V,INSERT_VALUES);CHKERRQ(ierr);\n      ierr = MatAssemblyBegin( C, MAT_FINAL_ASSEMBLY );CHKERRQ(ierr);\n      ierr = MatAssemblyEnd  ( C, MAT_FINAL_ASSEMBLY );CHKERRQ(ierr);\n    }\n  }\n  a[0][0]=K;  a[0][1]=G;\n  a[1][0]=Gt; a[1][1]=C;\n  ierr = MatCreateNest(PetscObjectComm((PetscObject) K), 2, NULL, 2, NULL, (Mat *)a, &stokes_A);CHKERRQ(ierr);\n  ierr = MatAssemblyBegin( stokes_A, MAT_FINAL_ASSEMBLY );CHKERRQ(ierr);\n  ierr = MatAssemblyEnd( stokes_A, MAT_FINAL_ASSEMBLY );CHKERRQ(ierr);\n\n\n\n  x[0]=u;\n  x[1]=p;\n  ierr = VecCreateNest(PetscObjectComm((PetscObject) u), 2, NULL, x, &stokes_x);CHKERRQ(ierr);\n  ierr = VecAssemblyBegin( stokes_x );CHKERRQ(ierr);\n  ierr = VecAssemblyEnd( stokes_x);CHKERRQ(ierr);\n\n  b[0]=f;\n  b[1]=h;\n  ierr = VecCreateNest(PetscObjectComm((PetscObject) f), 2, NULL, b, &stokes_b);CHKERRQ(ierr);\n  ierr = VecAssemblyBegin( stokes_b );CHKERRQ(ierr);\n  ierr = VecAssemblyEnd( stokes_b);CHKERRQ(ierr);\n\n  /* if( approxS ) { */\n  /*   a[0][0]=K;    a[0][1]=G; */\n  /*   a[1][0]=NULL; a[1][1]=approxS; */\n  /*   ierr = MatCreateNest(PetscObjectComm((PetscObject) K), 2, NULL, 2, NULL, (Mat *)a, &stokes_P);CHKERRQ(ierr); */\n  /*   ierr = MatAssemblyBegin( stokes_P, MAT_FINAL_ASSEMBLY );CHKERRQ(ierr); */\n  /*   ierr = MatAssemblyEnd( stokes_P, MAT_FINAL_ASSEMBLY );CHKERRQ(ierr); */\n  /* } */\n  /* else { */\n    stokes_P = stokes_A;\n  /* } */\n\n  /* probably should make a Destroy function for these two */\n  /* Update options from file and/or string here so we can change things on the fly */\n  //PetscOptionsInsertFile(PETSC_COMM_WORLD, Solver->optionsFile, PETSC_FALSE);\n  //PetscOptionsInsertString(Solver->optionsString);\n\n  ierr = KSPCreate( PETSC_COMM_WORLD, &stokes_ksp );CHKERRQ(ierr);\n  Stg_KSPSetOperators( stokes_ksp, stokes_A, stokes_P, SAME_NONZERO_PATTERN );\n  ierr = KSPSetType( stokes_ksp, \"bsscr\" );/* i.e. making this the default solver : calls KSPCreate_XXX */CHKERRQ(ierr);\n\n  ierr = KSPGetPC( stokes_ksp, &stokes_pc );CHKERRQ(ierr);\n  ierr = PCSetType( stokes_pc, PCNONE );CHKERRQ(ierr);\n  ierr = KSPSetInitialGuessNonzero( stokes_ksp, PETSC_TRUE );CHKERRQ(ierr);\n  ierr = KSPSetFromOptions( stokes_ksp );CHKERRQ(ierr);\n\n  /*\n    Doing this so the KSP Solver has access to the StgFEM Multigrid struct (PETScMGSolver).\n    As well as any custom stuff on the Stokes_SLE struct\n  */\n  if( stokes_ksp->data ){/* then ksp->data has been created in a KSpSetUp_XXX function */\n    /* testing for our KSP types that need the data that is on Solver... */\n    /* for the moment then, this function not completely agnostic about our KSPs */\n    //if(!strcmp(\"bsscr\",stokes_ksp->type_name)){/* if is bsscr then set up the data on the ksp */\n    flg=PETSC_FALSE;\n    PetscOptionsHasName(PETSC_NULL,\"-use_petsc_ksp\",&flg);\n    if (!flg) {\n      ((KSP_COMMON*)(stokes_ksp->data))->st_sle         = Solver->st_sle;\n      ((KSP_COMMON*)(stokes_ksp->data))->mg             = Solver->mg;\n      ((KSP_COMMON*)(stokes_ksp->data))->DIsSym         = Solver->DIsSym;\n      ((KSP_COMMON*)(stokes_ksp->data))->preconditioner = Solver->preconditioner;\n      ((KSP_COMMON*)(stokes_ksp->data))->solver         = Solver;\n    }\n  }\n\n  ierr = KSPSolve( stokes_ksp, stokes_b, stokes_x );CHKERRQ(ierr);\n\n  Stg_KSPDestroy(&stokes_ksp );\n  //if( ((StokesBlockKSPInterface*)stokesSLE->solver)->preconditioner )\n  if(stokes_P != stokes_A) { Stg_MatDestroy(&stokes_P ); }\n\n  Stg_MatDestroy(&stokes_A );\n\n  Stg_VecDestroy(&stokes_x);\n  Stg_VecDestroy(&stokes_b);\n\n  if(!D){ Stg_MatDestroy(&Gt); }\n  if(C && (stokesSLE->cStiffMat->matrix != C) ){ Stg_MatDestroy(&C); }\n\n  PetscFunctionReturn(0);\n}\n", "meta": {"hexsha": "034ddd5c2e7beb43fdcab74784dced52da333612", "size": 17674, "ext": "c", "lang": "C", "max_stars_repo_path": "underworld/libUnderworld/Solvers/KSPSolvers/src/StokesBlockKSPInterface.c", "max_stars_repo_name": "StuartRClark/mantle", "max_stars_repo_head_hexsha": "27acbbbb70b00870bebc4f98c69af8edaa4f8bc4", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2022-01-28T20:00:12.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-28T20:00:12.000Z", "max_issues_repo_path": "underworld/libUnderworld/Solvers/KSPSolvers/src/StokesBlockKSPInterface.c", "max_issues_repo_name": "StuartRClark/mantle", "max_issues_repo_head_hexsha": "27acbbbb70b00870bebc4f98c69af8edaa4f8bc4", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "underworld/libUnderworld/Solvers/KSPSolvers/src/StokesBlockKSPInterface.c", "max_forks_repo_name": "StuartRClark/mantle", "max_forks_repo_head_hexsha": "27acbbbb70b00870bebc4f98c69af8edaa4f8bc4", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.8961625282, "max_line_length": 146, "alphanum_fraction": 0.6415072989, "num_tokens": 5219, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.39233683016710835, "lm_q2_score": 0.031618767382710224, "lm_q1q2_score": 0.012405206968723687}}
{"text": "/* integration/workspace.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Brian Gough\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n */\n\n#include <config.h>\n#include <stdlib.h>\n#include <gsl/gsl_integration.h>\n#include <gsl/gsl_errno.h>\n\ngsl_integration_workspace *\ngsl_integration_workspace_alloc (const size_t n) \n{\n  gsl_integration_workspace * w ;\n  \n  if (n == 0)\n    {\n      GSL_ERROR_VAL (\"workspace length n must be positive integer\",\n\t\t\tGSL_EDOM, 0);\n    }\n\n  w = (gsl_integration_workspace *) \n    malloc (sizeof (gsl_integration_workspace));\n\n  if (w == 0)\n    {\n      GSL_ERROR_VAL (\"failed to allocate space for workspace struct\",\n\t\t\tGSL_ENOMEM, 0);\n    }\n\n  w->alist = (double *) malloc (n * sizeof (double));\n\n  if (w->alist == 0)\n    {\n      free (w);\t\t/* exception in constructor, avoid memory leak */\n\n      GSL_ERROR_VAL (\"failed to allocate space for alist ranges\",\n\t\t\tGSL_ENOMEM, 0);\n    }\n\n  w->blist = (double *) malloc (n * sizeof (double));\n\n  if (w->blist == 0)\n    {\n      free (w->alist);\n      free (w);\t\t/* exception in constructor, avoid memory leak */\n\n      GSL_ERROR_VAL (\"failed to allocate space for blist ranges\",\n\t\t\tGSL_ENOMEM, 0);\n    }\n\n  w->rlist = (double *) malloc (n * sizeof (double));\n\n  if (w->rlist == 0)\n    {\n      free (w->blist);\n      free (w->alist);\n      free (w);\t\t/* exception in constructor, avoid memory leak */\n\n      GSL_ERROR_VAL (\"failed to allocate space for rlist ranges\",\n\t\t\tGSL_ENOMEM, 0);\n    }\n\n\n  w->elist = (double *) malloc (n * sizeof (double));\n\n  if (w->elist == 0)\n    {\n      free (w->rlist);\n      free (w->blist);\n      free (w->alist);\n      free (w);\t\t/* exception in constructor, avoid memory leak */\n\n      GSL_ERROR_VAL (\"failed to allocate space for elist ranges\",\n\t\t\tGSL_ENOMEM, 0);\n    }\n\n  w->order = (size_t *) malloc (n * sizeof (size_t));\n\n  if (w->order == 0)\n    {\n      free (w->elist);\n      free (w->rlist);\n      free (w->blist);\n      free (w->alist);\n      free (w);\t\t/* exception in constructor, avoid memory leak */\n\n      GSL_ERROR_VAL (\"failed to allocate space for order ranges\",\n\t\t\tGSL_ENOMEM, 0);\n    }\n\n  w->level = (size_t *) malloc (n * sizeof (size_t));\n\n  if (w->level == 0)\n    {\n      free (w->order);\n      free (w->elist);\n      free (w->rlist);\n      free (w->blist);\n      free (w->alist);\n      free (w);\t\t/* exception in constructor, avoid memory leak */\n\n      GSL_ERROR_VAL (\"failed to allocate space for order ranges\",\n\t\t\tGSL_ENOMEM, 0);\n    }\n\n  w->size = 0 ;\n  w->limit = n ;\n  w->maximum_level = 0 ;\n  \n  return w ;\n}\n\nvoid\ngsl_integration_workspace_free (gsl_integration_workspace * w)\n{\n  free (w->level) ;\n  free (w->order) ;\n  free (w->elist) ;\n  free (w->rlist) ;\n  free (w->blist) ;\n  free (w->alist) ;\n  free (w) ;\n}\n\n/*\nsize_t \ngsl_integration_workspace_limit (gsl_integration_workspace * w) \n{\n  return w->limit ;\n}\n\n\nsize_t \ngsl_integration_workspace_size (gsl_integration_workspace * w) \n{\n  return w->size ;\n}\n*/\n", "meta": {"hexsha": "dcf8ee0bca416d0fb9c1cddd43e1bb6b75f64f27", "size": 3611, "ext": "c", "lang": "C", "max_stars_repo_path": "code/em/treba/gsl-1.0/integration/workspace.c", "max_stars_repo_name": "ICML14MoMCompare/spectral-learn", "max_stars_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "code/em/treba/gsl-1.0/integration/workspace.c", "max_issues_repo_name": "ICML14MoMCompare/spectral-learn", "max_issues_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/em/treba/gsl-1.0/integration/workspace.c", "max_forks_repo_name": "ICML14MoMCompare/spectral-learn", "max_forks_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2015-10-02T01:32:59.000Z", "max_forks_repo_forks_event_max_datetime": "2015-10-02T01:32:59.000Z", "avg_line_length": 23.4480519481, "max_line_length": 72, "alphanum_fraction": 0.6236499585, "num_tokens": 1024, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.28140560742914383, "lm_q2_score": 0.04401865127382215, "lm_q1q2_score": 0.012387095299921578}}
{"text": "#include <stdlib.h>\n\n#include <gsl/gsl_statistics_double.h>\n#include <hdf5.h>\n#include <hdf5_hl.h>\n\n#include \"qdm.h\"\n\nqdm_ijk *\nqdm_ijk_alloc(\n    size_t size1,\n    size_t size2,\n    size_t size3\n)\n{\n  qdm_ijk *t = malloc(sizeof(qdm_ijk));\n\n  t->size1 = size1;\n  t->size2 = size2;\n  t->size3 = size3;\n\n  t->data = malloc(sizeof(double) * size1 * size2 * size3);\n  t->owner = true;\n\n  return t;\n}\n\nqdm_ijk *\nqdm_ijk_calloc(\n    size_t size1,\n    size_t size2,\n    size_t size3\n)\n{\n  qdm_ijk *t = malloc(sizeof(qdm_ijk));\n\n  t->size1 = size1;\n  t->size2 = size2;\n  t->size3 = size3;\n\n  t->data = calloc(sizeof(double), size1 * size2 * size3);\n  t->owner = true;\n\n  return t;\n}\n\nvoid\nqdm_ijk_free(\n    qdm_ijk *t\n)\n{\n  if (t == NULL) {\n    return;\n  }\n\n  if (t->owner) {\n    free(t->data);\n  }\n\n  free(t);\n}\n\nqdm_ijk_view\nqdm_ijk_view_array(\n    double *base,\n    size_t size1,\n    size_t size2,\n    size_t size3\n)\n{\n  qdm_ijk_view v = {\n    .ijk = {\n      .size1 = size1,\n      .size2 = size2,\n      .size3 = size3,\n\n      .data = base,\n      .owner = false,\n    },\n  };\n\n  return v;\n}\n\ngsl_vector_view\nqdm_ijk_get_k(\n    qdm_ijk *t,\n    size_t i,\n    size_t j\n)\n{\n  return gsl_vector_view_array_with_stride(\n      &t->data[i * t->size2 + j],\n      t->size1 * t->size2,\n      t->size3\n  );\n}\n\ngsl_matrix_view\nqdm_ijk_get_ij(\n    qdm_ijk *t,\n    size_t k\n)\n{\n  return gsl_matrix_view_array(\n      &t->data[k * t->size1 * t->size2],\n      t->size1,\n      t->size2\n  );\n}\n\ndouble\nqdm_ijk_get(\n    qdm_ijk *t,\n    size_t i,\n    size_t j,\n    size_t k\n)\n{\n  gsl_matrix_view ij = qdm_ijk_get_ij(t, k);\n\n  return gsl_matrix_get(&ij.matrix, i, j);\n}\n\ngsl_matrix *\nqdm_ijk_cov(\n    qdm_ijk *t\n)\n{\n  size_t d = t->size1 * t->size2;\n  size_t dr = 0;\n\n  gsl_matrix *r = gsl_matrix_calloc(d, d);\n\n  for (size_t i0 = 0; i0 < t->size1; i0++) {\n    for (size_t j0 = 0; j0 < t->size2; j0++) {\n      gsl_vector_view k0 = qdm_ijk_get_k(t, i0, j0);\n\n      /* TODO: When we have time (and if it matters), this is symmetric and we\n       * don't need to do a bunch of these if we get a little clever about\n       * copying the mirror'd results.\n       */\n      for (size_t ip = 0; ip < t->size1; ip++) {\n        for (size_t jp = 0; jp < t->size2; jp++) {\n          gsl_vector_view kp = qdm_ijk_get_k(t, ip, jp);\n\n          double cov = gsl_stats_covariance(\n              k0.vector.data,\n              k0.vector.stride,\n              kp.vector.data,\n              kp.vector.stride,\n              kp.vector.size\n          );\n\n          gsl_matrix_set(r, dr, ip * t->size2 + jp, cov);\n        }\n      }\n\n      dr++;\n    }\n  }\n\n  return r;\n}\n\nint\nqdm_ijk_write(\n    hid_t id,\n    const char *name,\n    const qdm_ijk *t\n)\n{\n  int status = 0;\n\n  hid_t datatype  = -1;\n  hid_t dataspace = -1;\n  hid_t dataset   = -1;\n\n  if (t == NULL) {\n    goto cleanup;\n  }\n\n  datatype = H5Tcopy(H5T_NATIVE_DOUBLE);\n\n  status = H5Tset_order(datatype, H5T_ORDER_LE);\n  if (status != 0) {\n    goto cleanup;\n  }\n\n  hsize_t dims[3] = {\n    t->size3,\n    t->size1,\n    t->size2,\n  };\n  dataspace = H5Screate_simple(3, dims, NULL);\n  if (dataspace < 0) {\n    status = dataspace;\n    goto cleanup;\n  }\n\n  dataset = H5Dcreate(id, name, datatype, dataspace, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);\n  if (dataset < 0) {\n    status = dataset;\n    goto cleanup;\n  }\n\n  status = H5Dwrite(dataset, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, t->data);\n  if (status != 0) {\n    goto cleanup;\n  }\n\ncleanup: \n  if (dataset >= 0) {\n    H5Dclose(dataset);\n  }\n\n  if (dataspace >= 0) {\n    H5Sclose(dataspace);\n  }\n\n  if (datatype >= 0) {\n    H5Tclose(datatype);\n  }\n\n  H5Oflush(id);\n\n  return status;\n}\n\nint\nqdm_ijk_read(\n    hid_t id,\n    const char *name,\n    qdm_ijk **t\n)\n{\n  int status = 0;\n\n  int rank = 0;\n\n  status = H5LTget_dataset_ndims(id, name, &rank);\n  if (status < 0) {\n    return status;\n  }\n\n  if (rank != 3) {\n    return -1;\n  }\n\n  hsize_t dims[3];\n\n  status = H5LTget_dataset_info(id, name, dims, NULL, NULL);\n  if (status < 0) {\n    return status;\n  }\n\n  size_t size3 = dims[0];\n  size_t size1 = dims[1];\n  size_t size2 = dims[2];\n\n  qdm_ijk *tmp = qdm_ijk_alloc(size1, size2, size3);\n\n  status = H5LTread_dataset_double(id, name, tmp->data);\n  if (status < 0) {\n    qdm_ijk_free(tmp);\n\n    return status;\n  }\n\n  *t = tmp;\n\n  return status;\n}\n", "meta": {"hexsha": "3f9e3e8d99c929acdc462fcb93ce404dd8f69315", "size": 4305, "ext": "c", "lang": "C", "max_stars_repo_path": "src/ijk.c", "max_stars_repo_name": "calebcase/qdm", "max_stars_repo_head_hexsha": "2ee95bec6c8be64f69e231c78f2be5fce3509c67", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/ijk.c", "max_issues_repo_name": "calebcase/qdm", "max_issues_repo_head_hexsha": "2ee95bec6c8be64f69e231c78f2be5fce3509c67", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2020-03-06T18:09:06.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-22T20:22:53.000Z", "max_forks_repo_path": "src/ijk.c", "max_forks_repo_name": "calebcase/qdm", "max_forks_repo_head_hexsha": "2ee95bec6c8be64f69e231c78f2be5fce3509c67", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 15.7116788321, "max_line_length": 92, "alphanum_fraction": 0.5718931475, "num_tokens": 1501, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.33111973962899144, "lm_q2_score": 0.03732688921821231, "lm_q1q2_score": 0.012359669839094669}}
{"text": "//setzt constanten auf\n#define EXTERN_VARIABLES\n#include <stdio.h>\n#include <math.h>\n#include <gsl/gsl_sf_bessel.h>\n#include \"global.h\"\n#include \"utility.h\"\n#include \"steppmethods.h\"\n#include <gsl/gsl_cblas.h>\n#include <time.h>\n#include <sys/types.h>\n#include <sys/stat.h>\n#include <unistd.h>\n#include <omp.h>\n#include <gsl/gsl_rng.h>\n#include <gsl/gsl_randist.h>\n\n\n\nvoid Set_Target_Length(double * TARGET_LENGTH, double volfrac,  void (*Stepper_Method)(int N,  double  x[N/2] , double v[N/2], double a[N/2], double *t, \n\t\t\t\t\tvoid (*deriv) (double *y, double *ans, double t,int N)),\n\t\t\t\t\tvoid (*Poti_Handle) (double *y, double *ans, double t,int N))\n{\tint FLAG = 1;\n\t*TARGET_LENGTH = 0.0;\n\tif (Stepper_Method == VVerlet_Step_deriv)\n\t{  \n\t\t *TARGET_LENGTH = 0.0;\n\t\tprintf(\" No  Targets\\n\");\n\t\tFLAG = 0;\n\t}\n\t//if (Stepper_Method == VVerlet_Step_Target_Circle)\n\t//{\n\t//\t*TARGET_LENGTH = LATTICE_SPACING * sqrt(volfrac/ M_PI);\n\t//\tprintf(\" Targets set to hard circles\\n\");\n\t//} \n\n\tif (Stepper_Method == VVerlet_Step_hardsphere_reflect)\n\t{  \n\t\t *TARGET_LENGTH = LATTICE_SPACING * sqrt(volfrac/ M_PI);\n\t\tprintf(\" Targets set to hard circles\\n\");\n\t\tFLAG = 0;\n\t}\n\n\tif (Stepper_Method == VVerlet_Step_hardsphere_reflect_Kupf)\n\t{  \n\t\t *TARGET_LENGTH = LATTICE_SPACING * sqrt(volfrac/ M_PI);\n\t\tprintf(\" Targets set to hard circles Kupferman \\n\");\n\t\tFLAG = 0;\n\t}\n\n\tif (Stepper_Method == VVerlet_Step_hardsphere_reflect_all)\n\t{  \n\t\t *TARGET_LENGTH = LATTICE_SPACING * sqrt(volfrac/ M_PI);\n\t\tprintf(\" Targets set to hard circles, reflect ALL particles\\n\");\n\t\tFLAG = 0;\n\t}\n\n\tif (Stepper_Method == VVerlet_Step_deriv_Kupf)\n\t{  \n\t\t*TARGET_LENGTH = 0.0;\n\t\tprintf(\" No  Targets\\n, Kupfermann bath\");\n\t\tFLAG = 0;\n\t}\n\n\tif (Stepper_Method == VVerlet_Step_deriv_Box)\n\t{  \n\t\t //*TARGET_LENGTH = LATTICE_SPACING * sqrt(volfrac/ M_PI/5.0);\n\t\t//printf(\" Targets set to soft Yukawa circles in 3 per pore corner\\n\");\n\t\t*TARGET_LENGTH = 0;\n\t\tFLAG = 0;\n\t\tif (DIM > 1)\n\t\t{\n\t\t\tprintf(\"wrong Dimension, please switch to 1d\");\n\t\t\texit(1);\n\t\t}\n\t\tif (volfrac > 0.0)\n\t\t{\n\t\t\tprintf(\"no need for volume fractions >0 \\n\");\n\t\t\texit(1);\n\t\t}\n\t\tprintf(\"box set up with hard wall \\n\");\t\n\t}\n\tif(FLAG)\n\t{\n\t\tprintf(\"Kein bekannter Stepper in global, cannot set tarhet length!\\n\");\n\t\texit(1);\n\t}\n}\n\nvoid Constants(){\n// call to setup the bathh parameters and give rudimentary output for the run\n\tint i;\n\tOUTPUT_FLAG = 1; \n\tprintf (\"OSSZI = %d  DIM =%d  ORDER =%d  \\n\", OSSZI, DIM, ORDER);\n\tprintf (\"KBOLTZ = %e \\nTIME_STEPS =%f  \\nTIME_END =%f  \\n\", KBOLTZ, TIME_STEPS, TIME_END);\n\tfor(i=0;i<OSSZI;i++){\n\t\tcoupling[i] = 0.0;\n\t}\n\tfor(i=0;i<OSSZI;i++){\n\t\tommega[i] = 0.0;\n\t}\n\tfor(i=0;i<OSSZI;i++){\n\t\tmassq[i] = 1.0;\n\t}\n\tfor(i=0;i<ORDER;i++){\n\t\ty[i] = 1.0;\n\t}\n\tprintf(\"ALPHA = %1.2E  GAMMA = %1.2E  mass  = %1.2E \\n\", ALPHA, GAMMA, mass);\n\tprintf(\"NUMBER_TO_INF = %d  \\nTIME_ARRIVAL =%1.2E  \\n \", NUMBER_TO_INF, TIME_ARRIVAL);\n\tprintf(\"Startbedingungen = \"); \n\tprintf(\"%s\",LABEL); \n\tprintf(\"\\n\");\n\tif (!(OMMEGA_READ_BINARY))\n\t{\n\t\t// random Number Preparation for Taus GSL genrator\n\t\tgsl_rng * r;\n\t\tconst gsl_rng_type * T;\n\t\tgsl_rng_env_setup();\n\t\tT = gsl_rng_taus2;\n\t\tr = gsl_rng_alloc (T);\n\t\tgsl_rng_set(r, time(NULL)); // Seed with time\n\t\t// Random number end // \n\t    Ommega_Setup(r);\n\t    gsl_rng_free (r);\n\t}else\t// read in from ommega.dat\n\t{\n\t\tFILE *fp;\n\t\tfp = fopen(\"ommega.dat\", \"r\");\t\n\t\tfor (i=0;i<OSSZI;i++)\n\t\t{\n\t\t\tif (fscanf(fp, \"%lf\", &ommega[i]) != 1) \n\t\t\t{\n\t            printf(\"ERROT READING ommega.dat\");\n\t            break;\n        \t}\n\t\t}\n\t\tfclose(fp);\n\t\tprintf(\"read in ommega.dat\\n\");\n\t}\n\tif(VIRTUAL_FLAG) printf(\"Virtuelles Teilchen benutzt, ohne Badrückkopplung\");\n  \tGamma_Setup(coupling);\n\t\n  \tdouble ommega_max = ommega[cblas_idamax(OSSZI, ommega, 1)];\n  \tdouble coupling_max = coupling[cblas_idamax(OSSZI, coupling, 1)];\n  \tprintf(\"MAX coupling =  %1.2e\\n\",coupling_max);\n  \tif(!(MAXSTEPSIZE_BINARY))\n\t{\n  \t\tMAXSTEPSIZE = (2*M_PI/ommega[cblas_idamax(OSSZI, ommega, 1)] * MAXSTEPSIZEMULT);\n  \t\tprintf(\"MAXSTEPSIZE =  %1.2e set according to smallest period times %3.3e\\n\",MAXSTEPSIZE, MAXSTEPSIZEMULT);\n  \t}else\n  \t{\n  \t\tMAXSTEPSIZE = (MAXSTEPSIZEMULT / (double) OSSZI);\n  \t\tprintf(\"MAXSTEPSIZE =  %1.2e set according to OSSZInr times Stepsize dt = %3.3e\\n\",MAXSTEPSIZE, MAXSTEPSIZEMULT);\n  \t}\n  \tSum_Method =  SUMMATION_METHOD;\n  \tStepper_Method = STEPPER_METHOD;\n  \tPoti_Handle = POTI_HANDLE;\n\n  \tint m = ipow(NUMBER_TO_INF,DIM); int n = DIM;\n  \t// Setze Gitter auf auf globale Matrix POSITIONS\n\tPOSITIONS = (double **) malloc(m * sizeof(int *));\n\tPOSITIONS[0] = (double *) malloc(m* n * sizeof(int));\n\tfor (i=1; i<m; i++) POSITIONS[i] = POSITIONS[0] + n *i;\n\tvec_zero_i(lattice_position,DIM);\n\tprintf(\"lattice allocated, current lattice cell set to zero\\n\");\n\tTARGET_CONTACT = 0;\n\tOUTPUT_FLAG = 0; // subsequent setup calls should not display text\n\tprintf(\"Running on %d threads, optimally DIM = %d\\n\", THREADS, DIM);\n\n\t// set masses for chosen type of coupling\n\tif( !(KUPF_BINARY) )\n\t{\n\t\tfor (int osi = 0; osi < OSSZI; osi ++)\t\t\t\n\t\t{\n\t\t\tmassq[osi] \t\t= 1.0;\n\t\t}\n\t\tprintf(\"Set all masses équal\\n\");\n\t}else\n\t{\n\t\tfor (int osi = 0; osi < OSSZI; osi ++)\t\t\t\n\t\t{\n\t\t\tmassq[osi] \t\t= coupling[osi] / ommega[osi] / ommega[osi];\n\t\t\t\n\t\t}\n\t\tprintf(\"Set all masses according to k = m w^2l\\n\");\n\t}\n\t// Setup masses of bath for simpsons rule, split ends, odd and even parts\n\n\tif (SIMPSON_BINARY)\n\t{\n\t\tfor (int osi = 1; osi < OSSZI/2-1; osi ++)\n\t\t{\t\t\t\n\t\t\tmassq[osi * 2] \t\t*= 2.0/3.0;\n\t\t\tmassq[osi * 2 + 1] \t*= 4.0/3.0;\n\t\t}\n\t\tmassq[0] \t\t*= 1.0/3.0;;\n\t\tmassq[OSSZI-1] \t*= 1.0/3.0;\n\n\t\tif (KUPF_BINARY)\n\t\t{\n\t\t\tfor (int osi = 0; osi < OSSZI; osi ++)\t\t\t\n\t\t\t{\n\t\t\t\tcoupling[osi] = massq[osi] * ommega[osi] * ommega[osi];\n\t\t\t}\t\n\t\t}\n\t}\n}\n\n\n", "meta": {"hexsha": "9e0b2f1b28b55dfb5f230c3f1c6a212176b09067", "size": 5684, "ext": "c", "lang": "C", "max_stars_repo_path": "constants.c", "max_stars_repo_name": "nowottnm/KAC_ZWANZIG_SIM", "max_stars_repo_head_hexsha": "b8cacd50b7d307aeaa503b5a2f41cef4300f15a3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "constants.c", "max_issues_repo_name": "nowottnm/KAC_ZWANZIG_SIM", "max_issues_repo_head_hexsha": "b8cacd50b7d307aeaa503b5a2f41cef4300f15a3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "constants.c", "max_forks_repo_name": "nowottnm/KAC_ZWANZIG_SIM", "max_forks_repo_head_hexsha": "b8cacd50b7d307aeaa503b5a2f41cef4300f15a3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.0666666667, "max_line_length": 153, "alphanum_fraction": 0.6365235749, "num_tokens": 2059, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4610167793123159, "lm_q2_score": 0.026759282700350304, "lm_q1q2_score": 0.012336478327223269}}
{"text": "/* interpolation/gsl_interp.h\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004 Gerard Jungman\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Author:  G. Jungman\n */\n#ifndef __GSL_INTERP_H__\n#define __GSL_INTERP_H__\n#include <stdlib.h>\n#include <gsl/gsl_inline.h>\n#include <gsl/gsl_types.h>\n\n#undef __BEGIN_DECLS\n#undef __END_DECLS\n#ifdef __cplusplus\n# define __BEGIN_DECLS extern \"C\" {\n# define __END_DECLS }\n#else\n# define __BEGIN_DECLS /* empty */\n# define __END_DECLS /* empty */\n#endif\n\n__BEGIN_DECLS\n\n/* evaluation accelerator */\ntypedef struct {\n  size_t  cache;        /* cache of index   */\n  size_t  miss_count;   /* keep statistics  */\n  size_t  hit_count;\n}\ngsl_interp_accel;\n\n\n/* interpolation object type */\ntypedef struct {\n  const char * name;\n  unsigned int min_size;\n  void *  (*alloc) (size_t size);\n  int     (*init)    (void *, const double xa[], const double ya[], size_t size);\n  int     (*eval)    (const void *, const double xa[], const double ya[], size_t size, double x, gsl_interp_accel *, double * y);\n  int     (*eval_deriv)  (const void *, const double xa[], const double ya[], size_t size, double x, gsl_interp_accel *, double * y_p);\n  int     (*eval_deriv2) (const void *, const double xa[], const double ya[], size_t size, double x, gsl_interp_accel *, double * y_pp);\n  int     (*eval_integ)  (const void *, const double xa[], const double ya[], size_t size, gsl_interp_accel *, double a, double b, double * result);\n  void    (*free)         (void *);\n\n} gsl_interp_type;\n\n\n/* general interpolation object */\ntypedef struct {\n  const gsl_interp_type * type;\n  double  xmin;\n  double  xmax;\n  size_t  size;\n  void * state;\n} gsl_interp;\n\n\n/* available types */\nGSL_VAR const gsl_interp_type * gsl_interp_linear;\nGSL_VAR const gsl_interp_type * gsl_interp_polynomial;\nGSL_VAR const gsl_interp_type * gsl_interp_cspline;\nGSL_VAR const gsl_interp_type * gsl_interp_cspline_periodic;\nGSL_VAR const gsl_interp_type * gsl_interp_akima;\nGSL_VAR const gsl_interp_type * gsl_interp_akima_periodic;\n\ngsl_interp_accel *\ngsl_interp_accel_alloc(void);\n\nint\ngsl_interp_accel_reset (gsl_interp_accel * a);\n\nvoid\ngsl_interp_accel_free(gsl_interp_accel * a);\n\ngsl_interp *\ngsl_interp_alloc(const gsl_interp_type * T, size_t n);\n     \nint\ngsl_interp_init(gsl_interp * obj, const double xa[], const double ya[], size_t size);\n\nconst char * gsl_interp_name(const gsl_interp * interp);\nunsigned int gsl_interp_min_size(const gsl_interp * interp);\n\n\nint\ngsl_interp_eval_e(const gsl_interp * obj,\n                  const double xa[], const double ya[], double x,\n                  gsl_interp_accel * a, double * y);\n\ndouble\ngsl_interp_eval(const gsl_interp * obj,\n                const double xa[], const double ya[], double x,\n                gsl_interp_accel * a);\n\nint\ngsl_interp_eval_deriv_e(const gsl_interp * obj,\n                        const double xa[], const double ya[], double x,\n                        gsl_interp_accel * a,\n                        double * d);\n\ndouble\ngsl_interp_eval_deriv(const gsl_interp * obj,\n                      const double xa[], const double ya[], double x,\n                      gsl_interp_accel * a);\n\nint\ngsl_interp_eval_deriv2_e(const gsl_interp * obj,\n                         const double xa[], const double ya[], double x,\n                         gsl_interp_accel * a,\n                         double * d2);\n\ndouble\ngsl_interp_eval_deriv2(const gsl_interp * obj,\n                       const double xa[], const double ya[], double x,\n                       gsl_interp_accel * a);\n\nint\ngsl_interp_eval_integ_e(const gsl_interp * obj,\n                        const double xa[], const double ya[],\n                        double a, double b,\n                        gsl_interp_accel * acc,\n                        double * result);\n\ndouble\ngsl_interp_eval_integ(const gsl_interp * obj,\n                      const double xa[], const double ya[],\n                      double a, double b,\n                      gsl_interp_accel * acc);\n\nvoid\ngsl_interp_free(gsl_interp * interp);\n\nINLINE_DECL size_t\ngsl_interp_bsearch(const double x_array[], double x,\n                   size_t index_lo, size_t index_hi);\n\n#ifdef HAVE_INLINE\n\n/* Perform a binary search of an array of values.\n * \n * The parameters index_lo and index_hi provide an initial bracket,\n * and it is assumed that index_lo < index_hi. The resulting index\n * is guaranteed to be strictly less than index_hi and greater than\n * or equal to index_lo, so that the implicit bracket [index, index+1]\n * always corresponds to a region within the implicit value range of\n * the value array.\n *\n * Note that this means the relationship of 'x' to x_array[index]\n * and x_array[index+1] depends on the result region, i.e. the\n * behaviour at the boundaries may not correspond to what you\n * expect. We have the following complete specification of the\n * behaviour.\n * Suppose the input is x_array[] = { x0, x1, ..., xN }\n *    if ( x == x0 )           then  index == 0\n *    if ( x > x0 && x <= x1 ) then  index == 0, and sim. for other interior pts\n *    if ( x == xN )           then  index == N-1\n *    if ( x > xN )            then  index == N-1\n *    if ( x < x0 )            then  index == 0 \n */\n\nINLINE_FUN size_t\ngsl_interp_bsearch(const double x_array[], double x,\n                   size_t index_lo, size_t index_hi)\n{\n  size_t ilo = index_lo;\n  size_t ihi = index_hi;\n  while(ihi > ilo + 1) {\n    size_t i = (ihi + ilo)/2;\n    if(x_array[i] > x)\n      ihi = i;\n    else\n      ilo = i;\n  }\n  \n  return ilo;\n}\n#endif\n\nINLINE_DECL size_t \ngsl_interp_accel_find(gsl_interp_accel * a, const double x_array[], size_t size, double x);\n\n#ifdef HAVE_INLINE\nINLINE_FUN size_t\ngsl_interp_accel_find(gsl_interp_accel * a, const double xa[], size_t len, double x)\n{\n  size_t x_index = a->cache;\n \n  if(x < xa[x_index]) {\n    a->miss_count++;\n    a->cache = gsl_interp_bsearch(xa, x, 0, x_index);\n  }\n  else if(x >= xa[x_index + 1]) {\n    a->miss_count++;\n    a->cache = gsl_interp_bsearch(xa, x, x_index, len-1);\n  }\n  else {\n    a->hit_count++;\n  }\n  \n  return a->cache;\n}\n#endif /* HAVE_INLINE */\n\n\n__END_DECLS\n\n#endif /* __GSL_INTERP_H__ */\n", "meta": {"hexsha": "cfc60abc3c46bac3e7a1646599d5107206b8fd4f", "size": 6843, "ext": "h", "lang": "C", "max_stars_repo_path": "include/gsl/gsl_interp.h", "max_stars_repo_name": "iti-luebeck/HANSE2011", "max_stars_repo_head_hexsha": "0bd5b3f1e0bc5a02516e7514b2241897337334c2", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 77.0, "max_stars_repo_stars_event_min_datetime": "2015-01-18T00:45:00.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-24T22:20:56.000Z", "max_issues_repo_path": "CMVS-PMVS/program/thirdParty/gsl-1.13/interpolation/gsl_interp.h", "max_issues_repo_name": "skair39/structured", "max_issues_repo_head_hexsha": "0cb4635af7602f2a243a9b739e5ed757424ab2a7", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2015-02-12T21:17:00.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-20T13:50:38.000Z", "max_forks_repo_path": "gsl/include/gsl/gsl_interp.h", "max_forks_repo_name": "gersteinlab/LESSeq", "max_forks_repo_head_hexsha": "bfc0a9aae081682a176e26d9804b980999595f16", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 30.0, "max_forks_repo_forks_event_min_datetime": "2015-02-01T15:12:21.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-30T23:53:15.000Z", "avg_line_length": 30.5491071429, "max_line_length": 148, "alphanum_fraction": 0.6527838667, "num_tokens": 1716, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.39606816627404173, "lm_q2_score": 0.031143832558095677, "lm_q1q2_score": 0.012335080652030752}}
{"text": "#include \"quantum_gates.h\"\n#include \"quac_p.h\"\n#include <stdlib.h>\n#include <stdio.h>\n#include <petsc.h>\n#include <stdarg.h>\n\n\nint _num_quantum_gates = 0;\nint _current_gate = 0;\nstruct quantum_gate_struct _quantum_gate_list[MAX_GATES];\nint _min_gate_enum = 5; // Minimum gate enumeration number\nint _gate_array_initialized = 0;\nint _num_circuits    = 0;\nint _current_circuit = 0;\ncircuit _circuit_list[MAX_GATES];\nvoid (*_get_val_j_functions_gates[MAX_GATES])(PetscInt,struct quantum_gate_struct,PetscInt*,PetscInt[],PetscScalar[],PetscInt);\n\n/* EventFunction is one step in Petsc to apply some action at a specific time.\n * This function checks to see if an event has happened.\n */\nPetscErrorCode _QG_EventFunction(TS ts,PetscReal t,Vec U,PetscScalar *fvalue,void *ctx) {\n  /* Check if the time has passed a gate */\n\n  if (_current_gate<_num_quantum_gates) {\n    /* We signal that we passed the time by returning a negative number */\n    fvalue[0] = _quantum_gate_list[_current_gate].time - t;\n  } else {\n    fvalue[0] = t;\n  }\n\n  return(0);\n}\n\n/* PostEventFunction is the other step in Petsc. If an event has happend, petsc will call this function\n * to apply that event.\n*/\nPetscErrorCode _QG_PostEventFunction(TS ts,PetscInt nevents,PetscInt event_list[],PetscReal t,\n                                     Vec U,PetscBool forward,void* ctx) {\n\n   /* We only have one event at the moment, so we do not need to branch.\n    * If we had more than one event, we would put some logic here.\n    */\n  if (nevents) {\n    /* Apply the current gate */\n    //Deprecated?\n    /* _apply_gate(_quantum_gate_list[_current_gate].my_gate_type,_quantum_gate_list[_current_gate].qubit_numbers,U); */\n    /* Increment our gate counter */\n    _current_gate = _current_gate + 1;\n  }\n\n  TSSetSolution(ts,U);\n  return(0);\n}\n\n/* EventFunction is one step in Petsc to apply some action at a specific time.\n * This function checks to see if an event has happened.\n */\nPetscErrorCode _QC_EventFunction(TS ts,PetscReal t,Vec U,PetscScalar *fvalue,void *ctx) {\n  /* Check if the time has passed a gate */\n  PetscInt current_gate,num_gates;\n  PetscLogEventBegin(_qc_event_function_event,0,0,0,0);\n  if (_current_circuit<_num_circuits) {\n    current_gate = _circuit_list[_current_circuit].current_gate;\n    num_gates    = _circuit_list[_current_circuit].num_gates;\n    if (current_gate<num_gates) {\n      /* We signal that we passed the time by returning a negative number */\n      fvalue[0] = _circuit_list[_current_circuit].gate_list[current_gate].time\n        +_circuit_list[_current_circuit].start_time - t;\n    } else {\n      if (nid==0){\n        printf(\"ERROR! current_gate should never be larger than num_gates in _QC_EventFunction\\n\");\n        exit(0);\n      }\n    }\n  } else {\n    fvalue[0] = t;\n  }\n  PetscLogEventEnd(_qc_event_function_event,0,0,0,0);\n  return(0);\n}\n\n/* PostEventFunction is the other step in Petsc. If an event has happend, petsc will call this function\n * to apply that event.\n*/\nPetscErrorCode _QC_PostEventFunction(TS ts,PetscInt nevents,PetscInt event_list[],\n                                     PetscReal t,Vec U,PetscBool forward,void* ctx) {\n  PetscInt current_gate,num_gates;\n  PetscReal gate_time;\n   /* We only have one event at the moment, so we do not need to branch.\n    * If we had more than one event, we would put some logic here.\n    */\n\n  PetscLogEventBegin(_qc_postevent_function_event,0,0,0,0);\n\n  if (nevents) {\n    num_gates    = _circuit_list[_current_circuit].num_gates;\n    current_gate = _circuit_list[_current_circuit].current_gate;\n    gate_time = _circuit_list[_current_circuit].gate_list[current_gate].time;\n    /* Apply all gates at a given time incrementally  */\n    while (current_gate<num_gates && _circuit_list[_current_circuit].gate_list[current_gate].time == gate_time){\n      /* apply the current gate */\n        printf(\"current_gate %d num_gates %d\\n\",current_gate,num_gates);\n      _apply_gate(_circuit_list[_current_circuit].gate_list[current_gate],U);\n\n      /* Increment our gate counter */\n      _circuit_list[_current_circuit].current_gate = _circuit_list[_current_circuit].current_gate + 1;\n      current_gate = _circuit_list[_current_circuit].current_gate;\n    }\n    if(_circuit_list[_current_circuit].current_gate>=_circuit_list[_current_circuit].num_gates){\n      /* We've exhausted this circuit; move on to the next. */\n      _current_circuit = _current_circuit + 1;\n    }\n\n  }\n\n  TSSetSolution(ts,U);\n  PetscLogEventEnd(_qc_postevent_function_event,0,0,0,0);\n  return(0);\n}\n\n/* Add a gate to the list */\nvoid add_gate(PetscReal time,gate_type my_gate_type,...) {\n  int num_qubits=0,qubit,i;\n  va_list ap;\n\n  if (my_gate_type==HADAMARD) {\n    num_qubits = 1;\n  } else if (my_gate_type==CNOT){\n    num_qubits = 2;\n  } else {\n    if (nid==0){\n      printf(\"ERROR! Gate type not recognized!\\n\");\n      exit(0);\n    }\n  }\n\n  // Store arguments in list\n  _quantum_gate_list[_num_quantum_gates].qubit_numbers = malloc(num_qubits*sizeof(int));\n  _quantum_gate_list[_num_quantum_gates].time = time;\n  _quantum_gate_list[_num_quantum_gates].my_gate_type = my_gate_type;\n  _quantum_gate_list[_num_quantum_gates]._get_val_j_from_global_i = HADAMARD_get_val_j_from_global_i;\n\n  // Loop through and store qubits\n  for (i=0;i<num_qubits;i++){\n    qubit = va_arg(ap,int);\n    _quantum_gate_list[_num_quantum_gates].qubit_numbers[i] = qubit;\n  }\n\n  _num_quantum_gates = _num_quantum_gates + 1;\n}\n\n\n/* Apply a specific gate */\nvoid _apply_gate(struct quantum_gate_struct this_gate,Vec rho){\n  PetscScalar op_vals[total_levels*2];\n  Mat gate_mat; //FIXME Consider having only one static Mat for all gates, rather than creating new ones every time\n  Vec tmp_answer;\n  PetscInt dim,i,Istart,Iend,num_js,these_js[total_levels*2];\n  // FIXME: maybe total_levels*2 is too much or not enough? Consider having a better bound.\n\n  PetscLogEventBegin(_apply_gate_event,0,0,0,0);\n\n  if (_lindblad_terms){\n    dim = total_levels*total_levels;\n  } else {\n    dim = total_levels;\n  }\n\n  VecDuplicate(rho,&tmp_answer); //Create a new vec with the same size as rho\n\n  MatCreate(PETSC_COMM_WORLD,&gate_mat);\n  MatSetSizes(gate_mat,PETSC_DECIDE,PETSC_DECIDE,dim,dim);\n  MatSetFromOptions(gate_mat);\n  MatMPIAIJSetPreallocation(gate_mat,4,NULL,4,NULL); //This matrix is incredibly sparse!\n  MatSetUp(gate_mat);\n  /* Construct the gate matrix, on the fly */\n  MatGetOwnershipRange(gate_mat,&Istart,&Iend);\n\n  for (i=Istart;i<Iend;i++){\n    if (_lindblad_terms){\n      // Get the corresponding j and val for the superoperator U* cross U\n      this_gate._get_val_j_from_global_i(i,this_gate,&num_js,these_js,op_vals,0);\n    } else {\n      // Get the corresponding j and val for just the matrix U\n      this_gate._get_val_j_from_global_i(i,this_gate,&num_js,these_js,op_vals,-1);\n    }\n    MatSetValues(gate_mat,1,&i,num_js,these_js,op_vals,ADD_VALUES);\n  }\n  MatAssemblyBegin(gate_mat,MAT_FINAL_ASSEMBLY);\n  MatAssemblyEnd(gate_mat,MAT_FINAL_ASSEMBLY);\n  /* MatView(gate_mat,PETSC_VIEWER_STDOUT_SELF); */\n  MatMult(gate_mat,rho,tmp_answer);\n  VecCopy(tmp_answer,rho); //Copy our tmp_answer array into rho\n\n  VecDestroy(&tmp_answer); //Destroy the temp answer\n  MatDestroy(&gate_mat);\n\n  PetscLogEventEnd(_apply_gate_event,0,0,0,0);\n}\n\n/*z\n * _construct_gate_mat constructs the matrix needed for the quantum\n * computing gates.\n *\n * Inputs:\n *     gate_type my_gate_type  type of quantum gate\n *     int *s\n * Outputs:\n *      Mat gate_mat: the expanded, superoperator matrix for that gate\n */\n\nvoid _construct_gate_mat(gate_type my_gate_type,int *systems,Mat gate_mat){\n  PetscInt i,j,i_mat,j_mat,k1,k2,k3,k4,n_before1,n_before2,my_levels,n_after;\n  PetscInt i1,j1,i2=0,j2=0,comb_levels,control=-1,moved_system;\n  PetscReal    val1,val2;\n  PetscScalar add_to_mat;\n\n  if (my_gate_type == CNOT) {\n\n    /* The controlled NOT gate has two inputs, a target and a control.\n     * the target output is equal to the target input if the control is\n     * |0> and is flipped if the control input is |1> (Marinescu 146)\n     * As a matrix, for a two qubit system:\n     *     1 0 0 0        I2 0\n     *     0 1 0 0   =    0  sig_x\n     *     0 0 0 1\n     *     0 0 1 0\n     * Of course, when there are other qubits, tensor products and such\n     * must be applied to get the full basis representation.\n     */\n\n\n    /* Figure out which system is first in our basis\n     * 0 and 1 is hardcoded because CNOT gates have only 2 qubits */\n    n_before1  = subsystem_list[systems[0]]->n_before;\n    n_before2  = subsystem_list[systems[1]]->n_before;\n    control    = 0;\n    moved_system = systems[1];\n    /* 2 is hardcoded because CNOT gates are for qubits, which have 2 levels */\n    /* 4 is hardcoded because 2 qubits with 2 levels each */\n    n_after   = total_levels/(4*n_before1);\n\n    /* Check which is the control and which is the target */\n    if (n_before2<n_before1) {\n      n_after   = total_levels/(4*n_before2);\n      control   = 1;\n      moved_system = systems[0];\n      n_before1 = n_before2;\n    }\n    /* 4 is hardcoded because 2 qubits with 2 levels each */\n    my_levels   = 4;\n    for (k1=0;k1<n_after;k1++){\n      for (k2=0;k2<n_before1;k2++){\n        for (i=0;i<4;i++){ //4 is hardcoded because there are only 4 entries\n          val1 = _get_val_in_subspace_gate(i,my_gate_type,control,&i1,&j1);\n\n          /* Get I_b cross CNOT cross I_a in the temporary basis */\n          i1 = i1*n_after + k1 + k2*my_levels*n_after;\n          j1 = j1*n_after + k1 + k2*my_levels*n_after;\n\n          /* Permute to computational basis\n           * To aid in the computation, we generated the matrix in the 'temporary basis',\n           * where we exchanged the subsystem immediately after the first qubit with\n           * the second qubit of interest. I.e., doing a CNOT(q3,q7)\n           * Computational basis: q1 q2 q3 q4 q5 q6 q7 q8 q9 q10\n           * Temporary basis:     q1 q2 q3 q7 q5 q6 q4 q8 q9 q10\n           * This allows us to calculate CNOT easily - we just need to change\n           * the basis back to the computational one.\n           *\n           * Since the control variable tells us which qubit was the first,\n           * we switched the system immediately before that one with the\n           * stored variable moved_system\n           */\n           _change_basis_ij_pair(&i1,&j1,systems[control]+1,moved_system);\n          for (k3=0;k3<n_after;k3++){\n            for (k4=0;k4<n_before1;k4++){\n              for (j=0;j<4;j++){ //4 is hardcoded because there are only 4 entries\n                val2 = _get_val_in_subspace_gate(j,my_gate_type,control,&i2,&j2);\n\n                /* Get I_b cross CNOT cross I_a in the temporary basis */\n                i2 = i2*n_after + k3 + k4*my_levels*n_after;\n                j2 = j2*n_after + k3 + k4*my_levels*n_after;\n\n                /* Permute to computational basis */\n                _change_basis_ij_pair(&i2,&j2,systems[control]+1,moved_system);\n\n                add_to_mat = val1*val2;\n                /* Do the normal kron product expansion */\n                i_mat = my_levels*n_before1*n_after*i1 + i2;\n                j_mat = my_levels*n_before1*n_after*j1 + j2;\n                MatSetValue(gate_mat,i_mat,j_mat,add_to_mat,ADD_VALUES);\n              }\n            }\n          }\n        }\n      }\n    }\n  } else if (my_gate_type == HADAMARD) {\n\n    /*\n     * The Hadamard gate is a one qubit gate defined as:\n     *\n     *    H = 1/sqrt(2) 1  1\n     *                  1 -1\n     *\n     * Find the necessary Hilbert space dimensions for constructing the\n     * full space matrix.\n     */\n\n    n_before1  = subsystem_list[systems[0]]->n_before;\n    my_levels  = subsystem_list[systems[0]]->my_levels; //Should be 2, because qubit\n    n_after   = total_levels/(my_levels*n_before1);\n    comb_levels = my_levels*my_levels*n_before1*n_after;\n\n    for (k4=0;k4<n_before1*n_after;k4++){\n      for (i=0;i<4;i++){ // 4 hardcoded because there are 4 values in the hadamard\n        val1 = _get_val_in_subspace_gate(i,my_gate_type,control,&i1,&j1);\n        for (j=0;j<4;j++){\n          val2 = _get_val_in_subspace_gate(j,my_gate_type,control,&i2,&j2);\n          i2 = i2 + k4*my_levels;\n          j2 = j2 + k4*my_levels;\n          /*\n           * We need my_levels*n_before*n_after because we are taking\n           * H cross (Ia cross Ib cross H), so the the size of the second operator\n           * is my_levels*n_before*n_after\n           */\n          add_to_mat = val1*val2;\n          i_mat = my_levels*n_before1*n_after*i1 + i2;\n          j_mat = my_levels*n_before1*n_after*j1 + j2;\n          _add_to_PETSc_kron_ij(gate_mat,add_to_mat,i_mat,j_mat,n_before1,n_after,comb_levels);\n        }\n      }\n    }\n  } else if (my_gate_type == SIGMAX || my_gate_type == SIGMAY || my_gate_type == SIGMAZ || my_gate_type == SWAP) {\n\n    /*\n     * The pauli matrices are two qubit gates, sigmax, sigmay, sigmaz\n     * The SWAP gate swaps two qubits.\n     */\n\n    n_before1  = subsystem_list[systems[0]]->n_before;\n    my_levels  = subsystem_list[systems[0]]->my_levels; //Should be 2, because qubit\n    n_after   = total_levels/(my_levels*n_before1);\n    comb_levels = my_levels*my_levels*n_before1*n_after;\n\n    for (k4=0;k4<n_before1*n_after;k4++){\n      for (i=0;i<2;i++){// 2 hardcoded because there are 4 values in the hadamard\n        val1 = _get_val_in_subspace_gate(i,my_gate_type,control,&i1,&j1);\n        for (j=0;j<2;j++){\n          val2 = _get_val_in_subspace_gate(j,my_gate_type,control,&i2,&j2);\n          i2 = i2 + k4*my_levels;\n          j2 = j2 + k4*my_levels;\n          /*\n           * We need my_levels*n_before*n_after because we are taking\n           * H cross (Ia cross Ib cross H), so the the size of the second operator\n           * is my_levels*n_before*n_after\n           */\n          add_to_mat = val1*val2;\n          i_mat = my_levels*n_before1*n_after*i1 + i2;\n          j_mat = my_levels*n_before1*n_after*j1 + j2;\n          _add_to_PETSc_kron_ij(gate_mat,add_to_mat,i_mat,j_mat,n_before1,n_after,comb_levels);\n        }\n      }\n    }\n  }\n\n  return;\n}\n\n\n\nvoid _change_basis_ij_pair(PetscInt *i_op,PetscInt *j_op,PetscInt system1,PetscInt system2){\n  PetscInt na1,na2,lev1,lev2;\n\n  /*\n   * To apply our change of basis we use the neat trick that the row number\n   * in a given basis can be calculated similar to how a binary number is\n   * calculated (but generalized in that some bits can have more than two\n   * states. e.g. with three qubits\n   *  i(| 0 1 0 >) = 0*4 + 1*2 + 0*1 = 2\n   * where i() is the index, in this ordering, of the ket.\n   * Another example, with 1 2level, 1 3levels, and 1 4 level system:\n   *  i(| 0 1 0 >) = 0*12 + 1*4 + 0*1 = 4\n   * that is,\n   *  i(| a b c >) = a*n_af^a + b*n_af^b + c*n_af^c\n   * where n_af^a is the Hilbert space before system a, etc.\n   *\n   * Given a specific i, and only switching two systems,\n   * we can calculate i's partner in the switched basis\n   * by subtracting off the part from the current basis and\n   * adding in the part from the desired basis. This leaves everything\n   * else the same, but switches the two systems of interest.\n   *\n   * We need to be able to go from i to a specific subsystem's state.\n   * This is accomplished with the formula:\n   * (i/n_a % l)\n   * Take our example above:\n   * three qubits:  2 -> 2/4 % 2 = 0$2 = 0\n   *                2 -> 2/2 % 2 = 1%2 = 1\n   *                2 -> 2/1 % 2 = 2%2 = 0\n   * Or, the other example: 4 -> 4/12 % 2 = 0\n   *                        4 -> 4/4 % 3  = 1\n   *                        4 -> 4/1 % 4  = 0\n   * Note that this depends on integer division - 4/12 = 0\n   *\n   * Using this, we can precisely calculate a system's part of the sum,\n   * subtract that off, and then add the new basis.\n   *\n   * For example, let's switch our qubits from before around:\n   * i(| 1 0 0 >) = 1*4 + 0*2 + 0*1 = 4\n   * Now, switch back to the original basis. Note we swapped q3 and q2\n   * first, subtract off the contributions from q3 and q2\n   * i_new = 4 - 1*4 - 0*2 = 0\n   * Now, add on the contributions in the original basis\n   * i_new = 0 + 0*4 + 1*2 = 2\n   * Algorithmically,\n   * i_new = i - (i/na1)%lev1 * na1 - (i/na2)%lev2 * na2\n   *           + (i/na2)%lev1 * na1 + (i/na1)%lev2 * na2\n   * Note that we use our formula above to calculate the qubits\n   * state in this basis, given this specific i.\n   */\n\n\n  lev1  = subsystem_list[system1]->my_levels;\n  na1   = total_levels/(lev1*subsystem_list[system1]->n_before);\n\n  lev2  = subsystem_list[system2]->my_levels;\n  na2   = total_levels/(lev2*subsystem_list[system2]->n_before); // Changed from lev1->lev2\n\n  *i_op = *i_op - ((*i_op/na1)%lev1)*na1 - ((*i_op/na2)%lev2)*na2 +\n    ((*i_op/na1)%lev2)*na2 + ((*i_op/na2)%lev1)*na1;\n\n  *j_op = *j_op - ((*j_op/na1)%lev1)*na1 - ((*j_op/na2)%lev2)*na2 +\n    ((*j_op/na1)%lev2)*na2 + ((*j_op/na2)%lev1)*na1;\n\n  return;\n}\n\n\n\n/*\n * _get_val_in_subspace_gate is a simple function that returns the\n * i_op,j_op pair and val for a given index;\n * Inputs:\n *      int i:              current index\n *      gate_type my_gate_type the gate type\n * Outputs:\n *      int *i_op:          row value in subspace\n *      int *j_op:          column value in subspace\n * Return value:\n *      PetscScalar val:         value at i_op,j_op\n */\n\nPetscScalar _get_val_in_subspace_gate(PetscInt i,gate_type my_gate_type,PetscInt control,PetscInt *i_op,PetscInt *j_op){\n  PetscScalar val=0.0;\n  if (my_gate_type == CNOT) {\n    /* The controlled NOT gate has two inputs, a target and a control.\n     * the target output is equal to the target input if the control is\n     * |0> and is flipped if the control input is |1> (Marinescu 146)\n     * As a matrix, for a two qubit system:\n     *     1 0 0 0        I2 0\n     *     0 1 0 0   =    0  sig_x\n     *     0 0 0 1\n     *     0 0 1 0\n     * Of course, when there are other qubits, tensor products and such\n     * must be applied to get the full basis representation.\n     */\n    if (control==0) {\n      if (i==0){\n        *i_op = 0; *j_op = 0;\n        val = 1.0;\n      } else if (i==1) {\n        *i_op = 1; *j_op = 1;\n        val = 1.0;\n      } else if (i==2) {\n        *i_op = 2; *j_op = 3;\n        val = 1.0;\n      } else if (i==3) {\n        *i_op = 3; *j_op = 2;\n        val = 1.0;\n      }\n    } else if (control==1) {\n\n      if (i==0){\n        *i_op = 0; *j_op = 0;\n        val = 1.0;\n      } else if (i==1) {\n        *i_op = 1; *j_op = 3;\n        val = 1.0;\n      } else if (i==2) {\n        *i_op = 2; *j_op = 2;\n        val = 1.0;\n      } else if (i==3) {\n        *i_op = 3; *j_op = 1;\n        val = 1.0;\n      }\n    }\n\n  } else if (my_gate_type == HADAMARD) {\n    /*\n     * The Hadamard gate is a one qubit gate defined as:\n     *\n     *    H = 1/sqrt(2) 1  1\n     *                  1 -1\n     *\n     * Find the necessary Hilbert space dimensions for constructing the\n     * full space matrix.\n     */\n    if (i==0){\n      *i_op = 0; *j_op = 0;\n      val = 1.0/sqrt(2);\n    } else if (i==1) {\n      *i_op = 0; *j_op = 1;\n      val = 1.0/sqrt(2);\n    } else if (i==2) {\n      *i_op = 1; *j_op = 0;\n      val = 1.0/sqrt(2);\n    } else if (i==3) {\n      *i_op = 1; *j_op = 1;\n      val = -1.0/sqrt(2);\n    }\n  } else if (my_gate_type == SIGMAX){\n    /*\n     * SIGMAX gate\n     *\n     *   | 0  1 |\n     *   | 1  0 |\n     *\n     */\n    if (i==0){\n      *i_op = 0; *j_op = 1;\n      val = 1.0;\n    } else if (i==1) {\n      *i_op = 1; *j_op = 0;\n      val = 1.0;\n    } else if (i==2){\n      *i_op = 1; *j_op = 1;\n      val = 0.0;\n    } else if (i==2) {\n      *i_op = 0; *j_op = 0;\n      val = 0.0;\n    }\n  } else if (my_gate_type == SIGMAX){\n    /*\n     * SIGMAY gate\n     *\n     *   | 0    -1.j |\n     *   | 1.j    0 |\n     *\n     */\n    if (i==0){\n      *i_op = 0; *j_op = 1;\n      val = -PETSC_i;\n    } else if (i==1) {\n      *i_op = 1; *j_op = 0;\n      val = PETSC_i;\n    } else if (i==2){\n      *i_op = 1; *j_op = 1;\n      val = 0.0;\n    } else if (i==2) {\n      *i_op = 0; *j_op = 0;\n      val = 0.0;\n    }\n  } else if (my_gate_type == SIGMAZ){\n    /*\n     * SIGMAZ gate\n     *\n     *   | 1  0 |\n     *   | 0 -1 |\n     *\n     */\n    if (i==0){\n      *i_op = 0; *j_op = 0;\n      val = 1.0;\n    } else if (i==1) {\n      *i_op = 1; *j_op = 1;\n      val = 1.0;\n    }else if (i==2){\n      *i_op = 1; *j_op = 0;\n      val = 0.0;\n    } else if (i==2) {\n      *i_op = 0; *j_op = 1;\n      val = 0.0;\n    }\n  }\n\n  return val;\n\n}\n\n/*\n * create_circuit initializez the circuit struct. Gates can be added\n * later.\n *\n * Inputs:\n *        circuit circ: circuit to be initialized\n *        PetscIn num_gates_est: an estimate of the number of gates in\n *                               the circuit; can be negative, if no\n *                               estimate is known.\n * Outputs:\n *       operator *new_op: lowering op (op), raising op (op->dag), and number op (op->n)\n */\n\nvoid create_circuit(circuit *circ,PetscInt num_gates_est){\n  (*circ).start_time   = 0.0;\n  (*circ).num_gates    = 0;\n  (*circ).current_gate = 0;\n  /*\n   * If num_gates_est was positive when passed in, use that\n   * as the initial gate_list size, otherwise set to\n   * 100. gate_list will be dynamically resized when needed.\n   */\n  if (num_gates_est>0) {\n    (*circ).gate_list_size = num_gates_est;\n  } else {\n    // Default gate_list_size\n    (*circ).gate_list_size = 100;\n  }\n  // Allocate gate list\n  (*circ).gate_list = malloc((*circ).gate_list_size * sizeof(struct quantum_gate_struct));\n}\n\n/*\n * Add a gate to a circuit.\n * Inputs:\n *        circuit circ: circuit to add to\n *        PetscReal time: time that gate would be applied, counting from 0 at\n *                        the start of the circuit\n *        gate_type my_gate_type: which gate to add\n *        ...:   list of qubit gate will act on, other (U for controlled_U?)\n */\nvoid add_gate_to_circuit(circuit *circ,PetscReal time,gate_type my_gate_type,...){\n  PetscReal theta,phi,lambda;\n  int num_qubits=0,qubit,i;\n  va_list ap;\n\n  if (_gate_array_initialized==0){\n    //Initialize the array of gate function pointers\n    _initialize_gate_function_array();\n    _gate_array_initialized = 1;\n  }\n\n  _check_gate_type(my_gate_type,&num_qubits);\n\n  if ((*circ).num_gates==(*circ).gate_list_size){\n    if (nid==0){\n      printf(\"ERROR! Gate list not large enough!\\n\");\n      exit(1);\n    }\n  }\n  // Store arguments in list\n  (*circ).gate_list[(*circ).num_gates].qubit_numbers = malloc(num_qubits*sizeof(int));\n  (*circ).gate_list[(*circ).num_gates].time = time;\n  (*circ).gate_list[(*circ).num_gates].my_gate_type = my_gate_type;\n  (*circ).gate_list[(*circ).num_gates]._get_val_j_from_global_i = _get_val_j_functions_gates[my_gate_type+_min_gate_enum];\n\n  if (my_gate_type==RX||my_gate_type==RY||my_gate_type==RZ) {\n    va_start(ap,num_qubits+1);\n  } else if (my_gate_type==U3){\n    va_start(ap,num_qubits+3);\n  } else {\n    va_start(ap,num_qubits);\n  }\n\n  // Loop through and store qubits\n  for (i=0;i<num_qubits;i++){\n    qubit = va_arg(ap,int);\n    if (qubit>=num_subsystems) {\n      if (nid==0){\n        // Disable warning because of qasm parser will make the circuit before\n        // the qubits are allocated\n        //printf(\"Warning! Qubit number greater than total systems\\n\");\n      }\n    }\n    (*circ).gate_list[(*circ).num_gates].qubit_numbers[i] = qubit;\n  }\n  if (my_gate_type==RX||my_gate_type==RY||my_gate_type==RZ||my_gate_type==PHASESHIFT){\n    //Get the theta parameter from the last argument passed in\n    theta = va_arg(ap,PetscReal);\n    (*circ).gate_list[(*circ).num_gates].theta = theta;\n    (*circ).gate_list[(*circ).num_gates].phi = 0;\n    (*circ).gate_list[(*circ).num_gates].lambda = 0;\n  } else if (my_gate_type==U3){\n    theta = va_arg(ap,PetscReal);\n    (*circ).gate_list[(*circ).num_gates].theta = theta;\n    phi = va_arg(ap,PetscReal);\n    (*circ).gate_list[(*circ).num_gates].phi = phi;\n    lambda = va_arg(ap,PetscReal);\n    (*circ).gate_list[(*circ).num_gates].lambda = lambda;\n  } else {\n    //Set theta to 0\n    (*circ).gate_list[(*circ).num_gates].theta = 0;\n    (*circ).gate_list[(*circ).num_gates].phi = 0;\n    (*circ).gate_list[(*circ).num_gates].lambda = 0;\n  }\n\n  (*circ).num_gates = (*circ).num_gates + 1;\n  return;\n}\n\n\n/*\n * Add a circuit to another circuit.\n * Assumes whole circuit happens at time\n */\nvoid add_circuit_to_circuit(circuit *circ,circuit circ_to_add,PetscReal time){\n  int num_qubits=0,i,j;\n\n  // Check that we can fit the circuit in\n  if (((*circ).num_gates+circ_to_add.num_gates-1)==(*circ).gate_list_size){\n    if (nid==0){\n      printf(\"ERROR! Gate list not large enough to add this circuit!\\n\");\n      exit(1);\n    }\n  }\n\n  for (i=0;i<circ_to_add.num_gates;i++){\n    // Copy gate information over\n    (*circ).gate_list[(*circ).num_gates].time = time;\n    if (circ_to_add.gate_list[i].my_gate_type<0){\n      num_qubits = 2;\n    } else {\n      num_qubits = 1;\n    }\n    (*circ).gate_list[(*circ).num_gates].qubit_numbers = malloc(num_qubits*sizeof(int));\n    for (j=0;j<num_qubits;j++){\n      (*circ).gate_list[(*circ).num_gates].qubit_numbers[j] = circ_to_add.gate_list[i].qubit_numbers[j];\n    }\n\n    (*circ).gate_list[(*circ).num_gates].my_gate_type = circ_to_add.gate_list[i].my_gate_type;\n    (*circ).gate_list[(*circ).num_gates]._get_val_j_from_global_i = circ_to_add.gate_list[i]._get_val_j_from_global_i;\n    (*circ).gate_list[(*circ).num_gates].theta = circ_to_add.gate_list[i].theta;\n    (*circ).num_gates = (*circ).num_gates + 1;\n  }\n\n\n\n  return;\n}\n\n/* register a circuit to be run a specific time during the time stepping */\nvoid start_circuit_at_time(circuit *circ,PetscReal time){\n  (*circ).start_time = time;\n  _circuit_list[_num_circuits] = *circ;\n  _num_circuits = _num_circuits + 1;\n\n}\n\n/*\n *\n * tensor_control - switch on which superoperator to compute\n *                  -1: I cross G or just G (the difference is controlled by the passed in i's, but\n *                                           the internal logic is exactly the same)\n *                   0: G* cross G\n *                   1: G* cross I\n */\n\nvoid _get_val_j_from_global_i_gates(PetscInt i,struct quantum_gate_struct gate,PetscInt *num_js,\n                                    PetscInt js[],PetscScalar vals[],PetscInt tensor_control){\n  operator this_op1,this_op2;\n  PetscInt n_after,i_sub,tmp_int,control,moved_system,my_levels,num_js_i1=0,num_js_i2=0;\n  PetscInt k1,k2,n_before1,n_before2,i_tmp,j_sub,extra_after,i1,i2,j1,js_i1[2],js_i2[2];\n  PetscScalar vals_i1[2],vals_i2[2],theta,phi,lambda;\n  //2 is hardcoded because 2 is the largest number of js from 1 i (HADAMARD)\n  /*\n   * We store our gates as a type and affected systems;\n   * we use the stored information to calculate the global j(s) location\n   * and nonzero value(s) for a give global i\n   *\n   * Fo all 2-qubit gates, we use the fact that\n   * diagonal elements are diagonal, even in global space\n   * and that off-diagonal elements can be worked out from the\n   * following:\n   * Off diagonal elements:\n   *    if (i_sub==1)\n   *       i = 1 * n_af + k1 + k2*n_me*n_af\n   *       j = 0 * n_af + k1 + k2*n_me*n_af\n   *    if (i_sub==0)\n   *       i = 0 * n_af + k1 + k2*n_l*n_af\n   *       j = 1 * n_af + k1 + k2*n_l*n_af\n   * We work out k1 and k2 from i to get j.\n   *\n   */\n  if (tensor_control!= 0) {\n    if (tensor_control==1) {\n      extra_after = total_levels;\n    } else {\n      extra_after = 1;\n    }\n\n    if (gate.my_gate_type > 0) { // Single qubit gates are coded as positive numbers\n\n      //Get the system this is affecting\n      this_op1 = subsystem_list[gate.qubit_numbers[0]];\n      if (this_op1->my_levels!=2) {\n        //Check that it is a two level system\n        if (nid==0){\n          printf(\"ERROR! Single qubit gates can only affect 2-level systems\\n\");\n          exit(0);\n        }\n      }\n      n_after = total_levels/(this_op1->my_levels*this_op1->n_before)*extra_after;\n      i_sub = i/n_after%this_op1->my_levels; //Use integer arithmetic to get floor function\n\n\n      //Branch on the gate types\n      if (gate.my_gate_type == HADAMARD){\n        /*\n         * HADAMARD gate\n         *\n         * 1/sqrt(2) | 1  1 |\n         *           | 1 -1 |\n         * Hadamard gates have two values per row,\n         * with both diagonal anad off diagonal elements\n         *\n         */\n        *num_js = 2;\n        if (i_sub==0) {\n          // Diagonal element\n          js[0]   = i;\n          vals[0] = pow(2,-0.5);\n\n          // Off diagonal element\n          tmp_int = i - 0 * n_after;\n          k2      = tmp_int/(this_op1->my_levels*n_after);//Use integer arithmetic to get floor function\n          k1      = tmp_int%(this_op1->my_levels*n_after);\n          js[1]   = (0 + 1) * n_after + k1 + k2*this_op1->my_levels*n_after;\n          vals[1] = pow(2,-0.5);\n\n        } else if (i_sub==1){\n          // Diagonal element\n          js[0]   = i;\n          vals[0] = -pow(2,-0.5);\n\n          // Off diagonal element\n          tmp_int = i - (0+1) * n_after;\n          k2      = tmp_int/(this_op1->my_levels*n_after);//Use integer arithmetic to get floor function\n          k1      = tmp_int%(this_op1->my_levels*n_after);\n          js[1]   = 0 * n_after + k1 + k2*this_op1->my_levels*n_after;\n          vals[1] = pow(2,-0.5);\n\n        } else {\n          if (nid==0){\n            printf(\"ERROR! Hadamard gate is only defined for qubits\\n\");\n            exit(0);\n          }\n        }\n      } else if (gate.my_gate_type == SIGMAX){\n        /*\n         * SIGMAX gate\n         *\n         *   | 0  1 |\n         *   | 1  0 |\n         *\n         */\n        *num_js = 1;\n        if (i_sub==0) {\n\n          // Off diagonal element\n          tmp_int = i - 0 * n_after;\n          k2      = tmp_int/(this_op1->my_levels*n_after);//Use integer arithmetic to get floor function\n          k1      = tmp_int%(this_op1->my_levels*n_after);\n          js[0]     = (0 + 1) * n_after + k1 + k2*this_op1->my_levels*n_after;\n          vals[0]   = 1.0;\n\n        } else if (i_sub==1){\n\n          // Off diagonal element\n          tmp_int = i - (0+1) * n_after;\n          k2      = tmp_int/(this_op1->my_levels*n_after);//Use integer arithmetic to get floor function\n          k1      = tmp_int%(this_op1->my_levels*n_after);\n          js[0]   = 0 * n_after + k1 + k2*this_op1->my_levels*n_after;\n          vals[0] = 1.0;\n\n        } else {\n          if (nid==0){\n            printf(\"ERROR! sigmax gate is only defined for qubits\\n\");\n            exit(0);\n          }\n        }\n      } else if (gate.my_gate_type == SIGMAY){\n        /*\n         * SIGMAY gate\n         *\n         *   | 0  -1.j |\n         *   | 1.j  0 |\n         *\n         */\n        *num_js = 1;\n        if (i_sub==0) {\n\n          // Off diagonal element\n          tmp_int = i - 0 * n_after;\n          k2      = tmp_int/(this_op1->my_levels*n_after);//Use integer arithmetic to get floor function\n          k1      = tmp_int%(this_op1->my_levels*n_after);\n          js[0]   = (0 + 1) * n_after + k1 + k2*this_op1->my_levels*n_after;\n          vals[0] = -1.0*PETSC_i;\n\n        } else if (i_sub==1){\n\n          // Off diagonal element\n          tmp_int = i - (0+1) * n_after;\n          k2      = tmp_int/(this_op1->my_levels*n_after);//Use integer arithmetic to get floor function\n          k1      = tmp_int%(this_op1->my_levels*n_after);\n          js[0]   = 0 * n_after + k1 + k2*this_op1->my_levels*n_after;\n          vals[0] = 1.0*PETSC_i;\n\n        } else {\n          if (nid==0){\n            printf(\"ERROR! sigmax gate is only defined for qubits\\n\");\n            exit(0);\n          }\n        }\n      } else if (gate.my_gate_type == SIGMAZ){\n        /*\n         * SIGMAZ gate\n         *\n         *   | 1   0 |\n         *   | 0  -1 |\n         *\n         */\n        *num_js = 1;\n        if (i_sub==0) {\n          // Diagonal element\n          js[0] = i;\n          vals[0] = 1.0;\n\n        } else if (i_sub==1){\n          // Diagonal element\n          js[0] = i;\n          vals[0] = -1.0;\n\n        } else {\n          if (nid==0){\n            printf(\"ERROR! sigmax gate is only defined for qubits\\n\");\n            exit(0);\n          }\n        }\n\n      } else if (gate.my_gate_type == EYE){\n          /*\n           * Identity (EYE) gate\n           *\n           *   | 1   0 |\n           *   | 0   1 |\n           *\n           */\n          *num_js = 1;\n          if (i_sub==0) {\n              // Diagonal element\n              js[0] = i;\n              vals[0] = 1.0;\n              \n          } else if (i_sub==1){\n              // Diagonal element\n              js[0] = i;\n              vals[0] = 1.0;\n              \n          } else {\n              if (nid==0){\n                  printf(\"ERROR! sigmax gate is only defined for qubits\\n\");\n                  exit(0);\n              }\n          }\n          \n      } else if (gate.my_gate_type == PHASESHIFT){\n           /*\n           * PHASESHIFT gate\n           *\n           *   | 1   0 |\n           *   | 0  e^(-i*theta) |\n           *\n           */\n          *num_js = 1;\n          theta = gate.theta;\n          if (i_sub==0) {\n              // Diagonal element\n              js[0] = i;\n              vals[0] = 1.0;\n              \n          } else if (i_sub==1){\n              // Diagonal element\n              js[0] = i;\n              vals[0] = PetscExpComplex(-PETSC_i*theta);\n          } else {\n              if (nid==0){\n                  printf(\"ERROR! phaseshift gate is only defined for qubits\\n\");\n                  exit(0);\n              }\n          }\n          \n      } else if (gate.my_gate_type == T){\n          /*\n           * T gate\n           *\n           *   | 1   0 |\n           *   | 0  e^(i*pi/4) |\n           *\n           */\n          *num_js = 1;\n          theta = gate.theta;\n          if (i_sub==0) {\n              // Diagonal element\n              js[0] = i;\n              vals[0] = 1.0;\n              \n          } else if (i_sub==1){\n              // Diagonal element\n              js[0] = i;\n              vals[0] = PetscExpComplex(PETSC_i*PETSC_PI/4);\n          } else {\n              if (nid==0){\n                  printf(\"ERROR! t gate is only defined for qubits\\n\");\n                  exit(0);\n              }\n          }\n          \n      } else if (gate.my_gate_type == TDAG){\n          /*\n           * TDAG gate\n           *\n           *   | 1   0 |\n           *   | 0  e^(-i*pi/4) |\n           *\n           */\n          *num_js = 1;\n          theta = gate.theta;\n          if (i_sub==0) {\n              // Diagonal element\n              js[0] = i;\n              vals[0] = 1.0;\n              \n          } else if (i_sub==1){\n              // Diagonal element\n              js[0] = i;\n              vals[0] = PetscExpComplex(-PETSC_i*PETSC_PI/4);\n          } else {\n              if (nid==0){\n                  printf(\"ERROR! tdag gate is only defined for qubits\\n\");\n                  exit(0);\n              }\n          }\n          \n      } else if (gate.my_gate_type == S){\n          /*\n           * S gate\n           *\n           *   | 1   0 |\n           *   | 0   i |\n           *\n           */\n          *num_js = 1;\n          theta = gate.theta;\n          if (i_sub==0) {\n              // Diagonal element\n              js[0] = i;\n              vals[0] = 1.0;\n              \n          } else if (i_sub==1){\n              // Diagonal element\n              js[0] = i;\n              vals[0] = PetscExpComplex(PETSC_i*PETSC_PI/4);\n          } else {\n              if (nid==0){\n                  printf(\"ERROR! t gate is only defined for qubits\\n\");\n                  exit(0);\n              }\n          }\n          \n      } else if (gate.my_gate_type == RX){\n          /*\n           * RX gate\n           *\n           *   | cos(theta/2)    i*sin(theta/2) |\n           *   | i*sin(theta/2)  cos(theta/2)   |\n           *\n           */\n          theta = gate.theta;\n          *num_js = 2;\n          if (i_sub==0) {\n              // Diagonal element\n              js[0] = i;\n              vals[0] = PetscCosReal(theta/2);\n              \n              // Off diagonal element\n              tmp_int = i - 0 * n_after;\n              k2      = tmp_int/(this_op1->my_levels*n_after);//Use integer arithmetic to get floor function\n              k1      = tmp_int%(this_op1->my_levels*n_after);\n              js[1]     = (0 + 1) * n_after + k1 + k2*this_op1->my_levels*n_after;\n              vals[1]   = PETSC_i * PetscSinReal(theta/2);\n              \n              \n          } else if (i_sub==1){\n              // Diagonal element\n              js[0] = i;\n              vals[0] = PetscCosReal(theta/2);\n              \n              // Off diagonal element\n              tmp_int = i - (0+1) * n_after;\n              k2      = tmp_int/(this_op1->my_levels*n_after);//Use integer arithmetic to get floor function\n              k1      = tmp_int%(this_op1->my_levels*n_after);\n              js[1]   = 0 * n_after + k1 + k2*this_op1->my_levels*n_after;\n              vals[1]   = PETSC_i * PetscSinReal(theta/2);              \n              \n          } else {\n              if (nid==0){\n                  printf(\"ERROR! rz gate is only defined for qubits\\n\");\n                  exit(0);\n              }\n          }\n          \n      } else if (gate.my_gate_type == U3) {\n          /*\n           * u3 gate\n           *\n           * u3(theta,phi,lambda)  = | cos(theta/2)              -e^(i lambda) * sin(theta/2)    |\n           *                         | e^(i phi) sin(theta/2)    e^(i (lambda+phi)) cos(theta/2) |\n           * the u3 gate is a general one qubit transformation.\n           * the u2 gate is u3(pi/2,phi,lambda)\n           * the u1 gate is u3(0,0,lambda)\n           * The u3 gate has two elements per row,\n           * with both diagonal anad off diagonal elements\n           *\n           */\n          theta = gate.theta;\n          phi = gate.phi;\n          lambda = gate.lambda;\n          *num_js = 2;\n          if (i_sub==0) {\n              // Diagonal element\n              js[0]   = i;\n              vals[0] = PetscCosReal(theta/2);\n              \n              // Off diagonal element\n              tmp_int = i - 0 * n_after;\n              k2      = tmp_int/(this_op1->my_levels*n_after);//Use integer arithmetic to get floor function\n              k1      = tmp_int%(this_op1->my_levels*n_after);\n              js[1]   = (0 + 1) * n_after + k1 + k2*this_op1->my_levels*n_after;\n              vals[1] = -PetscExpComplex(PETSC_i*lambda)*PetscSinReal(theta/2);\n              \n          } else if (i_sub==1){\n              // Diagonal element\n              js[0]   = i;\n              vals[0] = PetscExpComplex(PETSC_i*(lambda+phi))*PetscCosReal(theta/2);\n              // Off diagonal element\n              tmp_int = i - (0+1) * n_after;\n              k2      = tmp_int/(this_op1->my_levels*n_after);//Use integer arithmetic to get floor function\n              k1      = tmp_int%(this_op1->my_levels*n_after);\n              js[1]   = 0 * n_after + k1 + k2*this_op1->my_levels*n_after;\n              vals[1] = PetscExpComplex(PETSC_i*phi)*PetscSinReal(theta/2);\n              \n          } else {\n              if (nid==0){\n                  printf(\"ERROR! u3 gate is only defined for qubits\\n\");\n                  exit(0);\n              }\n          }\n      } else {\n\n\n        if (nid==0){\n          printf(\"ERROR! Gate type not understood! %d\\n\", gate.my_gate_type);\n          exit(0);\n        }\n      }\n    } else {\n      //Two qubit gates\n      this_op1 = subsystem_list[gate.qubit_numbers[0]];\n      this_op2 = subsystem_list[gate.qubit_numbers[1]];\n      if (this_op1->my_levels * this_op2->my_levels != 4) {\n        //Check that it is a two level system\n        if (nid==0){\n          printf(\"ERROR! Two qubit gates can only affect two 2-level systems (global_i)\\n\");\n          exit(0);\n        }\n      }\n\n      n_before1  = this_op1->n_before;\n      n_before2  = this_op2->n_before;\n\n      control = 0;\n      moved_system = gate.qubit_numbers[1];\n\n      /* 2 is hardcoded because CNOT gates are for qubits, which have 2 levels */\n      /* 4 is hardcoded because 2 qubits with 2 levels each */\n      n_after   = total_levels/(4*n_before1)*extra_after;\n\n      /*\n       * Check which is the control and which is the target,\n       * flip if need be.\n       */\n      if (n_before2<n_before1) {\n        n_after   = total_levels/(4*n_before2);\n        control   = 1;\n        moved_system = gate.qubit_numbers[0];\n        n_before1 = n_before2;\n      }\n\n      /* 4 is hardcoded because 2 qubits with 2 levels each */\n      my_levels   = 4;\n\n      /*\n       * Permute to temporary basis\n       * Get the i_sub in the permuted basis\n       */\n      i_tmp = i;\n      _change_basis_ij_pair(&i_tmp,&j1,gate.qubit_numbers[control]+1,moved_system); // j1 useless here\n\n      i_sub = i_tmp/n_after%my_levels; //Use integer arithmetic to get floor function\n\n      if (gate.my_gate_type == CNOT) {\n        /* The controlled NOT gate has two inputs, a target and a control.\n         * the target output is equal to the target input if the control is\n         * |0> and is flipped if the control input is |1> (Marinescu 146)\n         * As a matrix, for a two qubit system:\n         *     1 0 0 0        I2 0\n         *     0 1 0 0   =    0  sig_x\n         *     0 0 0 1\n         *     0 0 1 0\n         * Of course, when there are other qubits, tensor products and such\n         * must be applied to get the full basis representation.\n         */\n        *num_js = 1;\n        if (i_sub==0){\n          // Same, regardless of control\n          // Diagonal\n          vals[0] = 1.0;\n          /*\n           * We shouldn't need to deal with any permutation here;\n           * i_sub is in the permuted basis, but we know that a\n           * diagonal element is diagonal in all bases, so\n           * we just use the computational basis value.\n           p         */\n          js[0]  = i;\n\n        } else if (i_sub==1){\n          // Check which is the control bit\n          vals[0] = 1.0;\n          if (control==0){\n            // Diagonal\n            js[0]   = i;\n          } else {\n            // Off diagonal\n            tmp_int = i_tmp - i_sub * n_after;\n            k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n            k1      = tmp_int%(my_levels*n_after);\n            j_sub   = 3;\n            j1   = (j_sub) * n_after + k1 + k2*my_levels*n_after; // 3 = j_sub\n\n            /* Permute back to computational basis */\n            _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1); // i_tmp useless here\n            js[0] = j1;\n          }\n\n        } else if (i_sub==2){\n          vals[0] = 1.0;\n          if (control==0){\n            // Off diagonal\n            tmp_int = i_tmp - i_sub * n_after;\n            k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n            k1      = tmp_int%(my_levels*n_after);\n            j_sub   = 3;\n            j1     = j_sub * n_after + k1 + k2*my_levels*n_after;\n\n            /* Permute back to computational basis */\n            _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1); // i_tmp useless here\n            js[0] = j1;\n          } else {\n            // Diagonal\n            js[0]   = i;\n          }\n        } else if (i_sub==3){\n          vals[0]   = 1.0;\n          if (control==0){\n            // Off diagonal element\n            tmp_int = i_tmp - i_sub * n_after;\n            k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n            k1      = tmp_int%(my_levels*n_after);\n            j_sub   = 2;\n            j1     = j_sub * n_after + k1 + k2*my_levels*n_after;\n          } else {\n            // Off diagonal element\n            tmp_int = i_tmp - i_sub * n_after;\n            k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n            k1      = tmp_int%(my_levels*n_after);\n            j_sub   = 1;\n            j1     = j_sub * n_after + k1 + k2*my_levels*n_after;\n          }\n          /* Permute back to computational basis */\n          _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1);//i_tmp useless here\n          js[0] = j1;\n        } else {\n          if (nid==0){\n            printf(\"ERROR! CNOT gate is only defined for 2 qubits!\\n\");\n            exit(0);\n          }\n        }\n      } else if (gate.my_gate_type == CXZ) {\n        /* The controlled-XZ gate has two inputs, a target and a control.\n         * As a matrix, for a two qubit system\n         *     1 0 0 0        I2 0\n         *     0 1 0 0   =    0  sig_x * sig_z\n         *     0 0 0 -1\n         *     0 0 1 0\n         * Of course, when there are other qubits, tensor products and such\n         * must be applied to get the full basis representation.\n         *\n         * Note that this is a temporary gate; i.e., we will create a more\n         * general controlled-U gate at a later time that will replace this.\n         */\n        *num_js = 1;\n        if (i_sub==0){\n          // Same, regardless of control\n          // Diagonal\n          vals[0] = 1.0;\n          /*\n           * We shouldn't need to deal with any permutation here;\n           * i_sub is in the permuted basis, but we know that a\n           * diagonal element is diagonal in all bases, so\n           * we just use the computational basis value.\n           p         */\n          js[0]  = i;\n\n        } else if (i_sub==1){\n          // Check which is the control bit\n          if (control==0){\n            // Diagonal\n            vals[0] = 1.0;\n            js[0]   = i;\n          } else {\n            // Off diagonal\n            vals[0] = -1.0;\n            tmp_int = i_tmp - i_sub * n_after;\n            k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n            k1      = tmp_int%(my_levels*n_after);\n            j_sub   = 3;\n            j1   = (j_sub) * n_after + k1 + k2*my_levels*n_after; // 3 = j_sub\n\n            /* Permute back to computational basis */\n            _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1); // i_tmp useless here\n            js[0] = j1;\n          }\n\n        } else if (i_sub==2){\n          if (control==0){\n            vals[0] = -1.0;\n            // Off diagonal\n            tmp_int = i_tmp - i_sub * n_after;\n            k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n            k1      = tmp_int%(my_levels*n_after);\n            j_sub   = 3;\n            j1     = j_sub * n_after + k1 + k2*my_levels*n_after;\n\n            /* Permute back to computational basis */\n            _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1); // i_tmp useless here\n            js[0] = j1;\n          } else {\n            // Diagonal\n            vals[0] = 1.0;\n            js[0]   = i;\n          }\n        } else if (i_sub==3){\n          vals[0]   = 1.0;\n          if (control==0){\n            // Off diagonal element\n            tmp_int = i_tmp - i_sub * n_after;\n            k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n            k1      = tmp_int%(my_levels*n_after);\n            j_sub   = 2;\n            j1     = j_sub * n_after + k1 + k2*my_levels*n_after;\n          } else {\n            // Off diagonal element\n            tmp_int = i_tmp - i_sub * n_after;\n            k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n            k1      = tmp_int%(my_levels*n_after);\n            j_sub   = 1;\n            j1     = j_sub * n_after + k1 + k2*my_levels*n_after;\n          }\n          /* Permute back to computational basis */\n          _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1);//i_tmp useless here\n          js[0] = j1;\n        } else {\n          if (nid==0){\n            printf(\"ERROR! CXZ gate is only defined for 2 qubits!\\n\");\n            exit(0);\n          }\n        }\n      } else if (gate.my_gate_type == CZX) {\n        /* The controlled-ZX gate has two inputs, a target and a control.\n         * As a matrix, for a two qubit system\n         *     1 0 0 0        I2 0\n         *     0 1 0 0   =    0  sig_z * sig_x\n         *     0 0 0 1\n         *     0 0 -1 0\n         * Of course, when there are other qubits, tensor products and such\n         * must be applied to get the full basis representation.\n         *\n         * Note that this is a temporary gate; i.e., we will create a more\n         * general controlled-U gate at a later time that will replace this.\n         */\n        *num_js = 1;\n        if (i_sub==0){\n          // Same, regardless of control\n          // Diagonal\n          vals[0] = 1.0;\n          /*\n           * We shouldn't need to deal with any permutation here;\n           * i_sub is in the permuted basis, but we know that a\n           * diagonal element is diagonal in all bases, so\n           * we just use the computational basis value.\n           p         */\n          js[0]  = i;\n\n        } else if (i_sub==1){\n          // Check which is the control bit\n          vals[0] = 1.0;\n          if (control==0){\n            // Diagonal\n            js[0]   = i;\n          } else {\n            // Off diagonal\n            tmp_int = i_tmp - i_sub * n_after;\n            k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n            k1      = tmp_int%(my_levels*n_after);\n            j_sub   = 3;\n            j1   = (j_sub) * n_after + k1 + k2*my_levels*n_after; // 3 = j_sub\n\n            /* Permute back to computational basis */\n            _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1); // i_tmp useless here\n            js[0] = j1;\n          }\n\n        } else if (i_sub==2){\n          vals[0] = 1.0;\n          if (control==0){\n            // Off diagonal\n            tmp_int = i_tmp - i_sub * n_after;\n            k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n            k1      = tmp_int%(my_levels*n_after);\n            j_sub   = 3;\n            j1     = j_sub * n_after + k1 + k2*my_levels*n_after;\n\n            /* Permute back to computational basis */\n            _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1); // i_tmp useless here\n            js[0] = j1;\n          } else {\n            // Diagonal\n            js[0]   = i;\n          }\n        } else if (i_sub==3){\n          vals[0]   = -1.0;\n          if (control==0){\n            // Off diagonal element\n            tmp_int = i_tmp - i_sub * n_after;\n            k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n            k1      = tmp_int%(my_levels*n_after);\n            j_sub   = 2;\n            j1     = j_sub * n_after + k1 + k2*my_levels*n_after;\n          } else {\n            // Off diagonal element\n            tmp_int = i_tmp - i_sub * n_after;\n            k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n            k1      = tmp_int%(my_levels*n_after);\n            j_sub   = 1;\n            j1     = j_sub * n_after + k1 + k2*my_levels*n_after;\n          }\n          /* Permute back to computational basis */\n          _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1);//i_tmp useless here\n          js[0] = j1;\n        } else {\n          if (nid==0){\n            printf(\"ERROR! CZX gate is only defined for 2 qubits!\\n\");\n            exit(0);\n          }\n        }\n      } else if (gate.my_gate_type == CZ) {\n        /* The controlled-Z gate has two inputs, a target and a control.\n         * As a matrix, for a two qubit system\n         *     1 0 0 0        I2 0\n         *     0 1 0 0   =    0  sig_z\n         *     0 0 1 0\n         *     0 0 0 -1\n         * Of course, when there are other qubits, tensor products and such\n         * must be applied to get the full basis representation.\n         *\n         * Note that this is a temporary gate; i.e., we will create a more\n         * general controlled-U gate at a later time that will replace\n         *\n         * Controlled-z is the same for both possible controls\n         */\n        *num_js = 1;\n        if (i_sub==0){\n          // Same, regardless of control\n          // Diagonal\n          vals[0] = 1.0;\n          /*\n           * We shouldn't need to deal with any permutation here;\n           * i_sub is in the permuted basis, but we know that a\n           * diagonal element is diagonal in all bases, so\n           * we just use the computational basis value.\n           p         */\n          js[0]  = i;\n\n        } else if (i_sub==1){\n          // Diagonal\n          vals[0] = 1.0;\n          js[0]   = i;\n        } else if (i_sub==2){\n          // Diagonal\n          vals[0] = 1.0;\n          js[0]   = i;\n        } else if (i_sub==3){\n          vals[0] = -1.0;\n          js[0]   = i;\n        } else {\n          if (nid==0){\n            printf(\"ERROR! CZ gate is only defined for 2 qubits!\\n\");\n            exit(0);\n          }\n        }\n      } else if (gate.my_gate_type == CmZ) {\n        /* The controlled-mZ gate has two inputs, a target and a control.\n         * As a matrix, for a two qubit system\n         *     1 0 0 0        I2 0\n         *     0 1 0 0   =    0  -sig_z\n         *     0 0 -1 0\n         *     0 0 0 1\n         * Of course, when there are other qubits, tensor products and such\n         * must be applied to get the full basis representation.\n         *\n         * Note that this is a temporary gate; i.e., we will create a more\n         * general controlled-U gate at a later time that will replace\n         *\n         */\n        *num_js = 1;\n        if (i_sub==0){\n          // Same, regardless of control\n          // Diagonal\n          vals[0] = 1.0;\n          /*\n           * We shouldn't need to deal with any permutation here;\n           * i_sub is in the permuted basis, but we know that a\n           * diagonal element is diagonal in all bases, so\n           * we just use the computational basis value.\n           p         */\n          js[0]  = i;\n\n        } else if (i_sub==1){\n          // Diagonal\n          js[0]   = i;\n          if (control==0) {\n            vals[0] = 1.0;\n          } else {\n            vals[0] = -1.0;\n          }\n        } else if (i_sub==2){\n          // Diagonal\n          js[0]   = i;\n          if (control==0) {\n            vals[0] = -1.0;\n          } else {\n            vals[0] = 1.0;\n          }\n        } else if (i_sub==3){\n          vals[0] = 1.0;\n          js[0]   = i;\n        } else {\n          if (nid==0){\n            printf(\"ERROR! CmZ gate is only defined for 2 qubits!\\n\");\n            exit(0);\n          }\n        }\n      } else if (gate.my_gate_type == SWAP) {\n          /* The swap gate swaps two qubits.\n           * As a matrix, for a two qubit system\n           *     1 0 0 0        I2 0\n           *     0 0 1 0   =    0  sig_z * sig_x\n           *     0 1 0 0\n           *     0 0 0 1\n           */\n          *num_js = 1;\n          if (i_sub==0){\n              // Same, regardless of control\n              // Diagonal\n              vals[0] = 1.0;\n              /*\n               * We shouldn't need to deal with any permutation here;\n               * i_sub is in the permuted basis, but we know that a\n               * diagonal element is diagonal in all bases, so\n               * we just use the computational basis value.\n               p         */\n              js[0]  = i;\n              \n          } else if (i_sub==1){\n              // Check which is the control bit\n              vals[0] = 1.0;\n                  // Off diagonal\n                  tmp_int = i_tmp - i_sub * n_after;\n                  k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n                  k1      = tmp_int%(my_levels*n_after);\n                  j_sub   = 3;\n                  j1   = (j_sub) * n_after + k1 + k2*my_levels*n_after; // 3 = j_sub\n                  \n                  /* Permute back to computational basis */\n                  _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1); // i_tmp useless here\n                  js[0] = j1;\n              \n          } else if (i_sub==2){\n              vals[0] = 1.0;\n                  // Off diagonal\n                  tmp_int = i_tmp - i_sub * n_after;\n                  k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n                  k1      = tmp_int%(my_levels*n_after);\n                  j_sub   = 3;\n                  j1     = j_sub * n_after + k1 + k2*my_levels*n_after;\n                  \n                  /* Permute back to computational basis */\n                  _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1); // i_tmp useless here\n                  js[0] = j1;\n          } else if (i_sub==3){\n              vals[0]   = 1.0;\n                  // Off diagonal element\n                  tmp_int = i_tmp - i_sub * n_after;\n                  k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n                  k1      = tmp_int%(my_levels*n_after);\n                  j_sub   = 1;\n                  j1     = j_sub * n_after + k1 + k2*my_levels*n_after;\n              /* Permute back to computational basis */\n              _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1);//i_tmp useless here\n              js[0] = j1;\n          } else {\n              if (nid==0){\n                  printf(\"ERROR! SWAP gate is only defined for 2 qubits!\\n\");\n                  exit(0);\n              }\n          }\n      } else {\n        if (nid==0){\n          printf(\"ERROR!Two Qubit gate type not understood! %d\\n\",gate.my_gate_type);\n          exit(0);\n        }\n      }\n    }\n    if (tensor_control==1){\n      //Take complex conjugate of answer to get U* cross I\n      for (i=0;i<*num_js;i++){\n        vals[i] = PetscConjComplex(vals[i]);\n      }\n    }\n  } else {\n    /*\n     * U* cross U\n     * To calculate this, we first take our i_global, convert\n     * it to i1 (for U*) and i2 (for U) within their own\n     * part of the Hilbert space. pWe then treat i1 and i2 as\n     * global i's for the matrices U* and U themselves, which\n     * gives us j's for those matrices. We then expand the j's\n     * to get the full space representation, using the normal\n     * tensor product.\n     */\n\n    /* Calculate i1, i2 */\n    i1 = i/total_levels;\n    i2 = i%total_levels;\n\n    /* Now, get js for U* (i1) by calling this function */\n    _get_val_j_from_global_i_gates(i1,gate,&num_js_i1,js_i1,vals_i1,-1);\n\n    /* Now, get js for U (i2) by calling this function */\n    _get_val_j_from_global_i_gates(i2,gate,&num_js_i2,js_i2,vals_i2,-1);\n\n    /*\n     * Combine j's to get U* cross U\n     * Must do all possible permutations\n     */\n    *num_js = 0;\n    for(k1=0;k1<num_js_i1;k1++){\n      for(k2=0;k2<num_js_i2;k2++){\n        js[*num_js] = total_levels * js_i1[k1] + js_i2[k2];\n        //Need to take complex conjugate to get true U*\n        vals[*num_js] = PetscConjComplex(vals_i1[k1])*vals_i2[k2];\n\n        *num_js = *num_js + 1;\n      }\n    }\n  }\n  return;\n}\n\n\nvoid combine_circuit_to_mat2(Mat *matrix_out,circuit circ){\n  PetscScalar op_val,op_vals[total_levels],vals[2]={0};\n  PetscInt Istart,Iend;\n  PetscInt i,j,k,l,this_i,these_js[total_levels],js[2]={0},num_js_tmp=0,num_js,num_js_current;\n\n  // Should this inherit its stucture from full_A?\n  MatCreate(PETSC_COMM_WORLD,matrix_out);\n  MatSetType(*matrix_out,MATMPIAIJ);\n  MatSetSizes(*matrix_out,PETSC_DECIDE,PETSC_DECIDE,total_levels,total_levels);\n  MatSetFromOptions(*matrix_out);\n\n  MatMPIAIJSetPreallocation(*matrix_out,16,NULL,16,NULL);\n\n  /*\n   * Calculate G1*G2*G3*.. using the following observation:\n   *     Each gate is very sparse - having no more than\n   *          2 values per row. This allows us to efficiently do the\n   *          multiplication by just touching the nonzero values\n   */\n  MatGetOwnershipRange(*matrix_out,&Istart,&Iend);\n  for (i=Istart;i<Iend;i++){\n    this_i = i; // The leading index which we check\n    // Reset the result for the row\n    num_js = 1;\n    these_js[0] = i;\n    op_vals[0]  = 1.0;\n    for (j=0;j<circ.num_gates;j++){\n      num_js_current = num_js;\n      for (k=0;k<num_js_current;k++){\n        // Loop through all of the js from the previous gate multiplications\n        this_i = these_js[k];\n        op_val = op_vals[k];\n\n        _get_val_j_from_global_i_gates(this_i,circ.gate_list[j],&num_js_tmp,js,vals,-1); // Get the corresponding j and val\n        /*\n         * Assume there is always at least 1 nonzero per row. This is a good assumption\n         * because all basic quantum gates have at least 1 nonzero per row\n         */\n        // WARNING! CODE NOT FINISHED\n        // WILL NOT WORK FOR HADAMARD * HADAMARD\n\n        these_js[k] = js[0];\n        op_vals[k]  = op_val*vals[0];\n\n        for (l=1;l<num_js_tmp;l++){\n          //If we have more than 1 num_js_tmp, we append to the end of the list\n          these_js[num_js+l-1] = js[l];\n          op_vals[num_js+l-1]  = op_val*vals[l];\n        }\n         num_js = num_js + num_js_tmp - 1; //If we spawned an extra j, add it here\n      }\n    }\n    MatSetValues(*matrix_out,1,&i,num_js,these_js,op_vals,ADD_VALUES);\n  }\n\n  MatAssemblyBegin(*matrix_out,MAT_FINAL_ASSEMBLY);\n  MatAssemblyEnd(*matrix_out,MAT_FINAL_ASSEMBLY);\n\n  return;\n}\n\n\nvoid combine_circuit_to_mat(Mat *matrix_out,circuit circ){\n  PetscScalar op_vals[2];\n  PetscInt Istart,Iend,i_mat;\n  PetscInt i,these_js[2],num_js;\n  Mat tmp_mat1,tmp_mat2,tmp_mat3;\n\n  // Should this inherit its stucture from full_A?\n\n  MatCreate(PETSC_COMM_WORLD,&tmp_mat1);\n  MatSetType(tmp_mat1,MATMPIAIJ);\n  MatSetSizes(tmp_mat1,PETSC_DECIDE,PETSC_DECIDE,total_levels,total_levels);\n  MatSetFromOptions(tmp_mat1);\n\n  MatMPIAIJSetPreallocation(tmp_mat1,2,NULL,2,NULL);\n\n  /* Construct the first matrix in tmp_mat1 */\n  MatGetOwnershipRange(tmp_mat1,&Istart,&Iend);\n  for (i=Istart;i<Iend;i++){\n    circ.gate_list[0]._get_val_j_from_global_i(i,circ.gate_list[0],&num_js,these_js,op_vals,-1); // Get the corresponding j and val\n    MatSetValues(tmp_mat1,1,&i,num_js,these_js,op_vals,ADD_VALUES);\n  }\n\n  MatAssemblyBegin(tmp_mat1,MAT_FINAL_ASSEMBLY);\n  MatAssemblyEnd(tmp_mat1,MAT_FINAL_ASSEMBLY);\n\n  for (i_mat=1;i_mat<circ.num_gates;i_mat++){\n    // Create the next matrix\n    MatCreate(PETSC_COMM_WORLD,&tmp_mat2);\n    MatSetType(tmp_mat2,MATMPIAIJ);\n    MatSetSizes(tmp_mat2,PETSC_DECIDE,PETSC_DECIDE,total_levels,total_levels);\n    MatSetFromOptions(tmp_mat2);\n\n    MatMPIAIJSetPreallocation(tmp_mat2,2,NULL,2,NULL);\n\n    /* Construct new matrix */\n    MatGetOwnershipRange(tmp_mat2,&Istart,&Iend);\n    for (i=Istart;i<Iend;i++){\n      _get_val_j_from_global_i_gates(i,circ.gate_list[i_mat],&num_js,these_js,op_vals,-1); // Get the corresponding j and val\n      MatSetValues(tmp_mat2,1,&i,num_js,these_js,op_vals,ADD_VALUES);\n    }\n\n    MatAssemblyBegin(tmp_mat2,MAT_FINAL_ASSEMBLY);\n    MatAssemblyEnd(tmp_mat2,MAT_FINAL_ASSEMBLY);\n\n    // Now do matrix matrix multiply\n    MatMatMult(tmp_mat2,tmp_mat1,MAT_INITIAL_MATRIX,PETSC_DEFAULT,&tmp_mat3);\n    MatDestroy(&tmp_mat1);\n    MatDestroy(&tmp_mat2); //Do I need to destroy it?\n\n    //Store tmp_mat3 into tmp_mat1\n    MatConvert(tmp_mat3,MATSAME,MAT_INITIAL_MATRIX,&tmp_mat1);\n    MatDestroy(&tmp_mat3);\n  }\n\n  //Copy tmp_mat1 into *matrix_out\n  MatConvert(tmp_mat1,MATSAME,MAT_INITIAL_MATRIX,matrix_out);;\n\n  MatDestroy(&tmp_mat1);\n  return;\n}\n\n\nvoid combine_circuit_to_super_mat(Mat *matrix_out,circuit circ){\n  PetscScalar op_vals[4];\n  PetscInt Istart,Iend,i_mat,dim;\n  PetscInt i,these_js[4],num_js;\n  Mat tmp_mat1,tmp_mat2,tmp_mat3;\n\n  // Should this inherit its stucture from full_A?\n  dim = total_levels*total_levels;\n  MatCreate(PETSC_COMM_WORLD,&tmp_mat1);\n  MatSetType(tmp_mat1,MATMPIAIJ);\n  MatSetSizes(tmp_mat1,PETSC_DECIDE,PETSC_DECIDE,dim,dim);\n  MatSetFromOptions(tmp_mat1);\n\n  MatMPIAIJSetPreallocation(tmp_mat1,8,NULL,8,NULL);\n\n  /* Construct the first matrix in tmp_mat1 */\n  MatGetOwnershipRange(tmp_mat1,&Istart,&Iend);\n  for (i=Istart;i<Iend;i++){\n    _get_val_j_from_global_i_gates(i,circ.gate_list[0],&num_js,these_js,op_vals,0); // Get the corresponding j and val\n    MatSetValues(tmp_mat1,1,&i,num_js,these_js,op_vals,ADD_VALUES);\n  }\n\n  MatAssemblyBegin(tmp_mat1,MAT_FINAL_ASSEMBLY);\n  MatAssemblyEnd(tmp_mat1,MAT_FINAL_ASSEMBLY);\n\n  for (i_mat=1;i_mat<circ.num_gates;i_mat++){\n    // Create the next matrix\n    MatCreate(PETSC_COMM_WORLD,&tmp_mat2);\n    MatSetType(tmp_mat2,MATMPIAIJ);\n    MatSetSizes(tmp_mat2,PETSC_DECIDE,PETSC_DECIDE,dim,dim);\n    MatSetFromOptions(tmp_mat2);\n\n    MatMPIAIJSetPreallocation(tmp_mat2,8,NULL,8,NULL);\n\n    /* Construct new matrix */\n    MatGetOwnershipRange(tmp_mat2,&Istart,&Iend);\n    for (i=Istart;i<Iend;i++){\n      _get_val_j_from_global_i_gates(i,circ.gate_list[i_mat],&num_js,these_js,op_vals,0); // Get the corresponding j and val\n      MatSetValues(tmp_mat2,1,&i,num_js,these_js,op_vals,ADD_VALUES);\n    }\n\n    MatAssemblyBegin(tmp_mat2,MAT_FINAL_ASSEMBLY);\n    MatAssemblyEnd(tmp_mat2,MAT_FINAL_ASSEMBLY);\n\n    // Now do matrix matrix multiply\n    MatMatMult(tmp_mat2,tmp_mat1,MAT_INITIAL_MATRIX,PETSC_DEFAULT,&tmp_mat3);\n    MatDestroy(&tmp_mat1);\n    MatDestroy(&tmp_mat2); //Do I need to destroy it?\n\n    //Store tmp_mat3 into tmp_mat1\n    MatConvert(tmp_mat3,MATSAME,MAT_INITIAL_MATRIX,&tmp_mat1);\n    MatDestroy(&tmp_mat3);\n  }\n\n  //Copy tmp_mat1 into *matrix_out\n  MatConvert(tmp_mat1,MATSAME,MAT_INITIAL_MATRIX,matrix_out);;\n\n  MatDestroy(&tmp_mat1);\n  return;\n}\n\n\n/*\n * No issue for js_i* = -1 because every row is guaranteed to have a 0\n * in all the gates implemented below.\n * See commit: 9956c78171fdac1fa0ef9e2f0a39cbffd4d755dc where this was an issue\n * in _get_val_j_from_global_i for raising / lowering / number operators, where\n * -1 was used to say there was no nonzero in that row.\n */\n\n\nvoid CNOT_get_val_j_from_global_i(PetscInt i,struct quantum_gate_struct gate,PetscInt *num_js,\n                                  PetscInt js[],PetscScalar vals[],PetscInt tensor_control){\n  PetscInt n_after,i_sub,k1,k2,tmp_int,i1,i2,num_js_i1=0,num_js_i2=0,js_i1[2],js_i2[2];\n  PetscInt control,i_tmp,my_levels,j_sub,moved_system,j1;\n  PetscScalar vals_i1[2],vals_i2[2];\n\n  /* The controlled NOT gate has two inputs, a target and a control.\n   * the target output is equal to the target input if the control is\n   * |0> and is flipped if the control input is |1> (Marinescu 146)\n   * As a matrix, for a two qubit system:\n   *     1 0 0 0        I2 0\n   *     0 1 0 0   =    0  sig_x\n   *     0 0 0 1\n   *     0 0 1 0\n   * Of course, when there are other qubits, tensor products and such\n   * must be applied to get the full basis representation.\n   */\n\n  if (tensor_control!= 0) {\n\n    /* 4 is hardcoded because 2 qubits with 2 levels each */\n    my_levels   = 4;\n    // Get the correct hilbert space information\n    i_tmp = i;\n    _get_n_after_2qbit(&i_tmp,gate.qubit_numbers,tensor_control,&n_after,&control,&moved_system,&i_sub);\n\n    *num_js = 1;\n    if (i_sub==0){\n      // Same, regardless of control\n      // Diagonal\n      vals[0] = 1.0;\n      /*\n       * We shouldn't need to deal with any permutation here;\n       * i_sub is in the permuted basis, but we know that a\n       * diagonal element is diagonal in all bases, so\n       * we just use the computational basis value.\n       p         */\n      js[0]  = i;\n\n    } else if (i_sub==1){\n      // Check which is the control bit\n      vals[0] = 1.0;\n      if (control==0){\n        // Diagonal\n        js[0]   = i;\n      } else {\n        // Off diagonal\n        tmp_int = i_tmp - i_sub * n_after;\n        k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n        k1      = tmp_int%(my_levels*n_after);\n        j_sub   = 3;\n        j1   = (j_sub) * n_after + k1 + k2*my_levels*n_after; // 3 = j_sub\n\n        /* Permute back to computational basis */\n        _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1); // i_tmp useless here\n        js[0] = j1;\n      }\n\n    } else if (i_sub==2){\n      vals[0] = 1.0;\n      if (control==0){\n        // Off diagonal\n        tmp_int = i_tmp - i_sub * n_after;\n        k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n        k1      = tmp_int%(my_levels*n_after);\n        j_sub   = 3;\n        j1     = j_sub * n_after + k1 + k2*my_levels*n_after;\n        /* Permute back to computational basis */\n        _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1); // i_tmp useless here\n        js[0] = j1;\n      } else {\n        // Diagonal\n        js[0]   = i;\n      }\n    } else if (i_sub==3){\n      vals[0]   = 1.0;\n      if (control==0){\n        // Off diagonal element\n        tmp_int = i_tmp - i_sub * n_after;\n        k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n        k1      = tmp_int%(my_levels*n_after);\n        j_sub   = 2;\n        j1     = j_sub * n_after + k1 + k2*my_levels*n_after;\n      } else {\n        // Off diagonal element\n        tmp_int = i_tmp - i_sub * n_after;\n        k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n        k1      = tmp_int%(my_levels*n_after);\n        j_sub   = 1;\n        j1     = j_sub * n_after + k1 + k2*my_levels*n_after;\n      }\n      /* Permute back to computational basis */\n      _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1);//i_tmp useless here\n      js[0] = j1;\n    } else {\n      if (nid==0){\n        printf(\"ERROR! CNOT gate is only defined for 2 qubits!\\n\");\n        exit(0);\n      }\n    }\n  } else {\n    /*\n     * U* cross U\n     * To calculate this, we first take our i_global, convert\n     * it to i1 (for U*) and i2 (for U) within their own\n     * part of the Hilbert space. pWe then treat i1 and i2 as\n     * global i's for the matrices U* and U themselves, which\n     * gives us j's for those matrices. We then expand the j's\n     * to get the full space representation, using the normal\n     * tensor product.\n     */\n\n    /* Calculate i1, i2 */\n    i1 = i/total_levels;\n    i2 = i%total_levels;\n\n    /* Now, get js for U* (i1) by calling this function */\n    CNOT_get_val_j_from_global_i(i1,gate,&num_js_i1,js_i1,vals_i1,-1);\n\n    /* Now, get js for U (i2) by calling this function */\n    CNOT_get_val_j_from_global_i(i2,gate,&num_js_i2,js_i2,vals_i2,-1);\n\n    /*\n     * Combine j's to get U* cross U\n     * Must do all possible permutations\n     */\n    *num_js = 0;\n    for(k1=0;k1<num_js_i1;k1++){\n      for(k2=0;k2<num_js_i2;k2++){\n        js[*num_js] = total_levels * js_i1[k1] + js_i2[k2];\n        //Need to take complex conjugate to get true U*\n        vals[*num_js] = PetscConjComplex(vals_i1[k1])*vals_i2[k2];\n\n        *num_js = *num_js + 1;\n      }\n    }\n\n  }\n\n  return;\n}\n\n\nvoid CXZ_get_val_j_from_global_i(PetscInt i,struct quantum_gate_struct gate,PetscInt *num_js,\n                                  PetscInt js[],PetscScalar vals[],PetscInt tensor_control){\n  PetscInt n_after,i_sub,k1,k2,tmp_int,i1,i2,num_js_i1=0,num_js_i2=0,js_i1[2],js_i2[2];\n  PetscInt control,i_tmp,my_levels,j_sub,moved_system,j1;\n  PetscScalar vals_i1[2],vals_i2[2];\n\n  /* The controlled-XZ gate has two inputs, a target and a control.\n   * As a matrix, for a two qubit system\n   *     1 0 0 0        I2 0\n   *     0 1 0 0   =    0  sig_x * sig_z\n   *     0 0 0 -1\n   *     0 0 1 0\n   * Of course, when there are other qubits, tensor products and such\n   * must be applied to get the full basis representation.\n   *\n   * Note that this is a temporary gate; i.e., we will create a more\n   * general controlled-U gate at a later time that will replace this.\n   */\n\n  if (tensor_control!= 0) {\n\n    /* 4 is hardcoded because 2 qubits with 2 levels each */\n    my_levels   = 4;\n    // Get the correct hilbert space information\n    i_tmp = i;\n    _get_n_after_2qbit(&i_tmp,gate.qubit_numbers,tensor_control,&n_after,&control,&moved_system,&i_sub);\n    *num_js = 1;\n    if (i_sub==0){\n      // Same, regardless of control\n      // Diagonal\n      vals[0] = 1.0;\n      /*\n       * We shouldn't need to deal with any permutation here;\n       * i_sub is in the permuted basis, but we know that a\n       * diagonal element is diagonal in all bases, so\n       * we just use the computational basis value.\n       p         */\n      js[0]  = i;\n\n    } else if (i_sub==1){\n      // Check which is the control bit\n      if (control==0){\n        // Diagonal\n        vals[0] = 1.0;\n        js[0]   = i;\n      } else {\n        // Off diagonal\n        vals[0] = -1.0;\n        tmp_int = i_tmp - i_sub * n_after;\n        k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n        k1      = tmp_int%(my_levels*n_after);\n        j_sub   = 3;\n        j1   = (j_sub) * n_after + k1 + k2*my_levels*n_after; // 3 = j_sub\n\n        /* Permute back to computational basis */\n        _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1); // i_tmp useless here\n        js[0] = j1;\n      }\n\n    } else if (i_sub==2){\n      if (control==0){\n        vals[0] = -1.0;\n        // Off diagonal\n        tmp_int = i_tmp - i_sub * n_after;\n        k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n        k1      = tmp_int%(my_levels*n_after);\n        j_sub   = 3;\n        j1     = j_sub * n_after + k1 + k2*my_levels*n_after;\n\n        /* Permute back to computational basis */\n        _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1); // i_tmp useless here\n        js[0] = j1;\n      } else {\n        // Diagonal\n        vals[0] = 1.0;\n        js[0]   = i;\n      }\n    } else if (i_sub==3){\n      vals[0]   = 1.0;\n      if (control==0){\n        // Off diagonal element\n        tmp_int = i_tmp - i_sub * n_after;\n        k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n        k1      = tmp_int%(my_levels*n_after);\n        j_sub   = 2;\n        j1     = j_sub * n_after + k1 + k2*my_levels*n_after;\n      } else {\n        // Off diagonal element\n        tmp_int = i_tmp - i_sub * n_after;\n        k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n        k1      = tmp_int%(my_levels*n_after);\n        j_sub   = 1;\n        j1     = j_sub * n_after + k1 + k2*my_levels*n_after;\n      }\n      /* Permute back to computational basis */\n      _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1);//i_tmp useless here\n      js[0] = j1;\n    } else {\n      if (nid==0){\n        printf(\"ERROR! CXZ gate is only defined for 2 qubits!\\n\");\n        exit(0);\n      }\n    }\n  } else {\n        /*\n     * U* cross U\n     * To calculate this, we first take our i_global, convert\n     * it to i1 (for U*) and i2 (for U) within their own\n     * part of the Hilbert space. pWe then treat i1 and i2 as\n     * global i's for the matrices U* and U themselves, which\n     * gives us j's for those matrices. We then expand the j's\n     * to get the full space representation, using the normal\n     * tensor product.\n     */\n\n    /* Calculate i1, i2 */\n    i1 = i/total_levels;\n    i2 = i%total_levels;\n\n    /* Now, get js for U* (i1) by calling this function */\n    CXZ_get_val_j_from_global_i(i1,gate,&num_js_i1,js_i1,vals_i1,-1);\n\n    /* Now, get js for U (i2) by calling this function */\n    CXZ_get_val_j_from_global_i(i2,gate,&num_js_i2,js_i2,vals_i2,-1);\n\n    /*\n     * Combine j's to get U* cross U\n     * Must do all possible permutations\n     */\n    *num_js = 0;\n    for(k1=0;k1<num_js_i1;k1++){\n      for(k2=0;k2<num_js_i2;k2++){\n        js[*num_js] = total_levels * js_i1[k1] + js_i2[k2];\n        //Need to take complex conjugate to get true U*\n        vals[*num_js] = PetscConjComplex(vals_i1[k1])*vals_i2[k2];\n\n        *num_js = *num_js + 1;\n      }\n    }\n\n  }\n\n  return;\n}\n\nvoid CZ_get_val_j_from_global_i(PetscInt i,struct quantum_gate_struct gate,PetscInt *num_js,\n                                  PetscInt js[],PetscScalar vals[],PetscInt tensor_control){\n  PetscInt n_after,i_sub,k1,k2,i1,i2,num_js_i1=0,num_js_i2=0,js_i1[2],js_i2[2];\n  PetscInt control,i_tmp,my_levels,moved_system;\n  PetscScalar vals_i1[2],vals_i2[2];\n\n  /* The controlled-Z gate has two inputs, a target and a control.\n   * As a matrix, for a two qubit system\n   *     1 0 0 0        I2 0\n   *     0 1 0 0   =    0  sig_z\n   *     0 0 1 0\n   *     0 0 0 -1\n   * Of course, when there are other qubits, tensor products and such\n   * must be applied to get the full basis representation.\n   *\n   * Note that this is a temporary gate; i.e., we will create a more\n   * general controlled-U gate at a later time that will replace\n   *\n   * Controlled-z is the same for both possible controls\n   */\n\n  if (tensor_control!= 0) {\n\n    /* 4 is hardcoded because 2 qubits with 2 levels each */\n    my_levels   = 4;\n    // Get the correct hilbert space information\n    i_tmp = i;\n    _get_n_after_2qbit(&i_tmp,gate.qubit_numbers,tensor_control,&n_after,&control,&moved_system,&i_sub);\n    *num_js = 1;\n    if (i_sub==0){\n      // Same, regardless of control\n      // Diagonal\n      vals[0] = 1.0;\n      /*\n       * We shouldn't need to deal with any permutation here;\n       * i_sub is in the permuted basis, but we know that a\n       * diagonal element is diagonal in all bases, so\n       * we just use the computational basis value.\n       p         */\n      js[0]  = i;\n\n    } else if (i_sub==1){\n      // Diagonal\n      vals[0] = 1.0;\n      js[0]   = i;\n    } else if (i_sub==2){\n      // Diagonal\n      vals[0] = 1.0;\n      js[0]   = i;\n    } else if (i_sub==3){\n      vals[0] = -1.0;\n      js[0]   = i;\n    } else {\n      if (nid==0){\n        printf(\"ERROR! CZ gate is only defined for 2 qubits!\\n\");\n        exit(0);\n      }\n    }\n  } else {\n        /*\n     * U* cross U\n     * To calculate this, we first take our i_global, convert\n     * it to i1 (for U*) and i2 (for U) within their own\n     * part of the Hilbert space. pWe then treat i1 and i2 as\n     * global i's for the matrices U* and U themselves, which\n     * gives us j's for those matrices. We then expand the j's\n     * to get the full space representation, using the normal\n     * tensor product.\n     */\n\n    /* Calculate i1, i2 */\n    i1 = i/total_levels;\n    i2 = i%total_levels;\n\n    /* Now, get js for U* (i1) by calling this function */\n    CZ_get_val_j_from_global_i(i1,gate,&num_js_i1,js_i1,vals_i1,-1);\n\n    /* Now, get js for U (i2) by calling this function */\n    CZ_get_val_j_from_global_i(i2,gate,&num_js_i2,js_i2,vals_i2,-1);\n\n    /*\n     * Combine j's to get U* cross U\n     * Must do all possible permutations\n     */\n    *num_js = 0;\n    for(k1=0;k1<num_js_i1;k1++){\n      for(k2=0;k2<num_js_i2;k2++){\n        js[*num_js] = total_levels * js_i1[k1] + js_i2[k2];\n        //Need to take complex conjugate to get true U*\n        vals[*num_js] = PetscConjComplex(vals_i1[k1])*vals_i2[k2];\n\n        *num_js = *num_js + 1;\n      }\n    }\n\n  }\n\n  return;\n}\n\n\nvoid CmZ_get_val_j_from_global_i(PetscInt i,struct quantum_gate_struct gate,PetscInt *num_js,\n                                  PetscInt js[],PetscScalar vals[],PetscInt tensor_control){\n  PetscInt n_after,i_sub,k1,k2,i1,i2,num_js_i1=0,num_js_i2=0,js_i1[2],js_i2[2];\n  PetscInt control,i_tmp,my_levels,moved_system;\n  PetscScalar vals_i1[2],vals_i2[2];\n\n  /* The controlled-mZ gate has two inputs, a target and a control.\n   * As a matrix, for a two qubit system\n   *     1 0 0 0        I2 0\n   *     0 1 0 0   =    0  -sig_z\n   *     0 0 -1 0\n   *     0 0 0 1\n   * Of course, when there are other qubits, tensor products and such\n   * must be applied to get the full basis representation.\n   *\n   * Note that this is a temporary gate; i.e., we will create a more\n   * general controlled-U gate at a later time that will replace\n   *\n   */\n\n  if (tensor_control!= 0) {\n\n    /* 4 is hardcoded because 2 qubits with 2 levels each */\n    my_levels   = 4;\n    // Get the correct hilbert space information\n    i_tmp = i;\n    _get_n_after_2qbit(&i_tmp,gate.qubit_numbers,tensor_control,&n_after,&control,&moved_system,&i_sub);\n\n    *num_js = 1;\n    if (i_sub==0){\n      // Same, regardless of control\n      // Diagonal\n      vals[0] = 1.0;\n      /*\n       * We shouldn't need to deal with any permutation here;\n       * i_sub is in the permuted basis, but we know that a\n       * diagonal element is diagonal in all bases, so\n       * we just use the computational basis value.\n       p         */\n      js[0]  = i;\n\n    } else if (i_sub==1){\n      // Diagonal\n      js[0]   = i;\n      if (control==0) {\n        vals[0] = 1.0;\n      } else {\n        vals[0] = -1.0;\n      }\n    } else if (i_sub==2){\n      // Diagonal\n      js[0]   = i;\n      if (control==0) {\n        vals[0] = -1.0;\n      } else {\n        vals[0] = 1.0;\n      }\n    } else if (i_sub==3){\n      vals[0] = 1.0;\n      js[0]   = i;\n    } else {\n      if (nid==0){\n        printf(\"ERROR! CmZ gate is only defined for 2 qubits!\\n\");\n        exit(0);\n      }\n    }\n  } else {\n        /*\n     * U* cross U\n     * To calculate this, we first take our i_global, convert\n     * it to i1 (for U*) and i2 (for U) within their own\n     * part of the Hilbert space. pWe then treat i1 and i2 as\n     * global i's for the matrices U* and U themselves, which\n     * gives us j's for those matrices. We then expand the j's\n     * to get the full space representation, using the normal\n     * tensor product.\n     */\n\n    /* Calculate i1, i2 */\n    i1 = i/total_levels;\n    i2 = i%total_levels;\n\n    /* Now, get js for U* (i1) by calling this function */\n    CmZ_get_val_j_from_global_i(i1,gate,&num_js_i1,js_i1,vals_i1,-1);\n\n    /* Now, get js for U (i2) by calling this function */\n    CmZ_get_val_j_from_global_i(i2,gate,&num_js_i2,js_i2,vals_i2,-1);\n\n    /*\n     * Combine j's to get U* cross U\n     * Must do all possible permutations\n     */\n    *num_js = 0;\n    for(k1=0;k1<num_js_i1;k1++){\n      for(k2=0;k2<num_js_i2;k2++){\n        js[*num_js] = total_levels * js_i1[k1] + js_i2[k2];\n        //Need to take complex conjugate to get true U*\n        vals[*num_js] = PetscConjComplex(vals_i1[k1])*vals_i2[k2];\n\n        *num_js = *num_js + 1;\n      }\n    }\n\n  }\n\n  return;\n}\n\n\nvoid CZX_get_val_j_from_global_i(PetscInt i,struct quantum_gate_struct gate,PetscInt *num_js,\n                                  PetscInt js[],PetscScalar vals[],PetscInt tensor_control){\n  PetscInt n_after,i_sub,k1,k2,tmp_int,i1,i2,num_js_i1=0,num_js_i2=0,js_i1[2],js_i2[2];\n  PetscInt control,i_tmp,my_levels,j_sub,moved_system,j1;\n  PetscScalar vals_i1[2],vals_i2[2];\n\n  /* The controlled-ZX gate has two inputs, a target and a control.\n   * As a matrix, for a two qubit system\n   *     1 0 0 0        I2 0\n   *     0 1 0 0   =    0  sig_z * sig_x\n   *     0 0 0 1\n   *     0 0 -1 0\n   * Of course, when there are other qubits, tensor products and such\n   * must be applied to get the full basis representation.\n   *\n   * Note that this is a temporary gate; i.e., we will create a more\n   * general controlled-U gate at a later time that will replace this.\n   */\n\n  if (tensor_control!= 0) {\n\n    /* 4 is hardcoded because 2 qubits with 2 levels each */\n    my_levels   = 4;\n    // Get the correct hilbert space information\n    i_tmp = i;\n    _get_n_after_2qbit(&i_tmp,gate.qubit_numbers,tensor_control,&n_after,&control,&moved_system,&i_sub);\n\n    *num_js = 1;\n    if (i_sub==0){\n      // Same, regardless of control\n      // Diagonal\n      vals[0] = 1.0;\n      /*\n       * We shouldn't need to deal with any permutation here;\n       * i_sub is in the permuted basis, but we know that a\n       * diagonal element is diagonal in all bases, so\n       * we just use the computational basis value.\n       p         */\n      js[0]  = i;\n\n    } else if (i_sub==1){\n      // Check which is the control bit\n      vals[0] = 1.0;\n      if (control==0){\n        // Diagonal\n        js[0]   = i;\n      } else {\n        // Off diagonal\n        tmp_int = i_tmp - i_sub * n_after;\n        k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n        k1      = tmp_int%(my_levels*n_after);\n        j_sub   = 3;\n        j1   = (j_sub) * n_after + k1 + k2*my_levels*n_after; // 3 = j_sub\n\n        /* Permute back to computational basis */\n        _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1); // i_tmp useless here\n        js[0] = j1;\n      }\n\n    } else if (i_sub==2){\n      vals[0] = 1.0;\n      if (control==0){\n        // Off diagonal\n        tmp_int = i_tmp - i_sub * n_after;\n        k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n        k1      = tmp_int%(my_levels*n_after);\n        j_sub   = 3;\n        j1     = j_sub * n_after + k1 + k2*my_levels*n_after;\n\n        /* Permute back to computational basis */\n        _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1); // i_tmp useless here\n        js[0] = j1;\n      } else {\n        // Diagonal\n        js[0]   = i;\n      }\n    } else if (i_sub==3){\n      vals[0]   = -1.0;\n      if (control==0){\n        // Off diagonal element\n        tmp_int = i_tmp - i_sub * n_after;\n        k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n        k1      = tmp_int%(my_levels*n_after);\n        j_sub   = 2;\n        j1     = j_sub * n_after + k1 + k2*my_levels*n_after;\n      } else {\n        // Off diagonal element\n        tmp_int = i_tmp - i_sub * n_after;\n        k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n        k1      = tmp_int%(my_levels*n_after);\n        j_sub   = 1;\n        j1     = j_sub * n_after + k1 + k2*my_levels*n_after;\n      }\n      /* Permute back to computational basis */\n      _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1);//i_tmp useless here\n      js[0] = j1;\n    } else {\n      if (nid==0){\n        printf(\"ERROR! CZX gate is only defined for 2 qubits!\\n\");\n        exit(0);\n      }\n    }\n  } else {\n        /*\n     * U* cross U\n     * To calculate this, we first take our i_global, convert\n     * it to i1 (for U*) and i2 (for U) within their own\n     * part of the Hilbert space. pWe then treat i1 and i2 as\n     * global i's for the matrices U* and U themselves, which\n     * gives us j's for those matrices. We then expand the j's\n     * to get the full space representation, using the normal\n     * tensor product.\n     */\n\n    /* Calculate i1, i2 */\n    i1 = i/total_levels;\n    i2 = i%total_levels;\n\n    /* Now, get js for U* (i1) by calling this function */\n    CZX_get_val_j_from_global_i(i1,gate,&num_js_i1,js_i1,vals_i1,-1);\n\n    /* Now, get js for U (i2) by calling this function */\n    CZX_get_val_j_from_global_i(i2,gate,&num_js_i2,js_i2,vals_i2,-1);\n\n    /*\n     * Combine j's to get U* cross U\n     * Must do all possible permutations\n     */\n    *num_js = 0;\n    for(k1=0;k1<num_js_i1;k1++){\n      for(k2=0;k2<num_js_i2;k2++){\n        js[*num_js] = total_levels * js_i1[k1] + js_i2[k2];\n        //Need to take complex conjugate to get true U*\n        vals[*num_js] = PetscConjComplex(vals_i1[k1])*vals_i2[k2];\n\n        *num_js = *num_js + 1;\n      }\n    }\n\n  }\n\n  return;\n}\n\nvoid SWAP_get_val_j_from_global_i(PetscInt i,struct quantum_gate_struct gate,PetscInt *num_js,\n                                 PetscInt js[],PetscScalar vals[],PetscInt tensor_control){\n    PetscInt n_after,i_sub,k1,k2,tmp_int,i1,i2,num_js_i1=0,num_js_i2=0,js_i1[2],js_i2[2];\n    PetscInt control,i_tmp,my_levels,j_sub,moved_system,j1;\n    PetscScalar vals_i1[2],vals_i2[2];\n    \n    /* The swap gate swaps two qubits.\n     * As a matrix, for a two qubit system\n     *     1 0 0 0        I2 0\n     *     0 0 1 0   =    0  sig_z * sig_x\n     *     0 1 0 0\n     *     0 0 0 1\n     */\n    \n    if (tensor_control!= 0) {\n        \n        /* 4 is hardcoded because 2 qubits with 2 levels each */\n        my_levels   = 4;\n        // Get the correct hilbert space information\n        i_tmp = i;\n        _get_n_after_2qbit(&i_tmp,gate.qubit_numbers,tensor_control,&n_after,&control,&moved_system,&i_sub);\n        \n        printf(\"\\n tensor_control %d,control %d,i_sub %d n_after %d\\n\", tensor_control, control, i_sub, n_after );\n        *num_js = 1;\n        if (i_sub==0){\n            // Diagonal\n            vals[0] = 1.0;\n            /*\n             * We shouldn't need to deal with any permutation here;\n             * i_sub is in the permuted basis, but we know that a\n             * diagonal element is diagonal in all bases, so\n             * we just use the computational basis value.\n             p         */\n            js[0]  = i;\n            \n        } else if (i_sub==1){\n            // Check which is the control bit\n            vals[0] = 1.0;\n                // Off diagonal\n                tmp_int = i_tmp - i_sub * n_after;\n                k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n                k1      = tmp_int%(my_levels*n_after);\n                j_sub   = 2;\n                j1   = (j_sub) * n_after + k1 + k2*my_levels*n_after; // 3 = j_sub\n                \n                // Permute back to computational basis\n                _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1); // i_tmp useless here\n                js[0] = j1;\n            \n        } else if (i_sub==2){\n            vals[0] = 1.0;\n                // Off diagonal\n                tmp_int = i_tmp - i_sub * n_after;\n                k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n                k1      = tmp_int%(my_levels*n_after);\n                j_sub   = 1;\n                j1     = j_sub * n_after + k1 + k2*my_levels*n_after;\n                \n                /* Permute back to computational basis */\n                _change_basis_ij_pair(&i_tmp,&j1,moved_system,gate.qubit_numbers[control]+1); // i_tmp useless here\n                js[0] = j1;\n        } else if (i_sub==3){\n            // Diagonal\n            vals[0] = 1.0;\n            /*\n             * We shouldn't need to deal with any permutation here;\n             * i_sub is in the permuted basis, but we know that a\n             * diagonal element is diagonal in all bases, so\n             * we just use the computational basis value.\n             p         */\n            js[0]  = i;\n        } else {\n            if (nid==0){\n                printf(\"ERROR! SWAP gate is only defined for 2 qubits!\\n\");\n                exit(0);\n            }\n        }\n    } else {\n        /*\n         * U* cross U\n         * To calculate this, we first take our i_global, convert\n         * it to i1 (for U*) and i2 (for U) within their own\n         * part of the Hilbert space. pWe then treat i1 and i2 as\n         * global i's for the matrices U* and U themselves, which\n         * gives us j's for those matrices. We then expand the j's\n         * to get the full space representation, using the normal\n         * tensor product.\n         */\n        \n        /* Calculate i1, i2 */\n        i1 = i/total_levels;\n        i2 = i%total_levels;\n        \n        /* Now, get js for U* (i1) by calling this function */\n        SWAP_get_val_j_from_global_i(i1,gate,&num_js_i1,js_i1,vals_i1,-1);\n        \n        /* Now, get js for U (i2) by calling this function */\n        SWAP_get_val_j_from_global_i(i2,gate,&num_js_i2,js_i2,vals_i2,-1);\n        \n        /*\n         * Combine j's to get U* cross U\n         * Must do all possible permutations\n         */\n        *num_js = 0;\n        for(k1=0;k1<num_js_i1;k1++){\n            for(k2=0;k2<num_js_i2;k2++){\n                js[*num_js] = total_levels * js_i1[k1] + js_i2[k2];\n                //Need to take complex conjugate to get true U*\n                vals[*num_js] = PetscConjComplex(vals_i1[k1])*vals_i2[k2];\n                \n                *num_js = *num_js + 1;\n            }\n        }\n        \n    }\n    \n    return;\n}\n\n\nvoid HADAMARD_get_val_j_from_global_i(PetscInt i,struct quantum_gate_struct gate,PetscInt *num_js,\n                                      PetscInt js[],PetscScalar vals[],PetscInt tensor_control){\n  PetscInt n_after,i_sub,k1,k2,tmp_int,i1,i2,num_js_i1,num_js_i2,js_i1[2],js_i2[2],my_levels;\n  PetscScalar vals_i1[2],vals_i2[2];\n\n  /*\n   * HADAMARD gate\n   *\n   * 1/sqrt(2) | 1  1 |\n   *           | 1 -1 |\n   * Hadamard gates have two values per row,\n   * with both diagonal anad off diagonal elements\n   *\n   */\n  if (tensor_control!= 0) {\n    my_levels = 2; //Hardcoded becase single qubit gate\n    _get_n_after_1qbit(i,gate.qubit_numbers[0],tensor_control,&n_after,&i_sub);\n    *num_js = 2;\n    if (i_sub==0) {\n      // Diagonal element\n      js[0]   = i;\n      vals[0] = pow(2,-0.5);\n\n      // Off diagonal element\n      tmp_int = i - 0 * n_after;\n      k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n      k1      = tmp_int%(my_levels*n_after);\n      js[1]   = (0 + 1) * n_after + k1 + k2*my_levels*n_after;\n      vals[1] = pow(2,-0.5);\n\n    } else if (i_sub==1){\n      // Diagonal element\n      js[0]   = i;\n      vals[0] = -pow(2,-0.5);\n\n      // Off diagonal element\n      tmp_int = i - (0+1) * n_after;\n      k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n      k1      = tmp_int%(my_levels*n_after);\n      js[1]   = 0 * n_after + k1 + k2*my_levels*n_after;\n      vals[1] = pow(2,-0.5);\n\n    } else {\n      if (nid==0){\n        printf(\"ERROR! Hadamard gate is only defined for qubits\\n\");\n        exit(0);\n      }\n    }\n  } else {\n    /*\n     * U* cross U\n     * To calculate this, we first take our i_global, convert\n     * it to i1 (for U*) and i2 (for U) within their own\n     * part of the Hilbert space. pWe then treat i1 and i2 as\n     * global i's for the matrices U* and U themselves, which\n     * gives us j's for those matrices. We then expand the j's\n     * to get the full space representation, using the normal\n     * tensor product.\n     */\n\n    /* Calculate i1, i2 */\n    i1 = i/total_levels;\n    i2 = i%total_levels;\n\n    /* Now, get js for U* (i1) by calling this function */\n    HADAMARD_get_val_j_from_global_i(i1,gate,&num_js_i1,js_i1,vals_i1,-1);\n\n    /* Now, get js for U (i2) by calling this function */\n    HADAMARD_get_val_j_from_global_i(i2,gate,&num_js_i2,js_i2,vals_i2,-1);\n\n    /*\n     * Combine j's to get U* cross U\n     * Must do all possible permutations\n     */\n    *num_js = 0;\n    for(k1=0;k1<num_js_i1;k1++){\n      for(k2=0;k2<num_js_i2;k2++){\n        js[*num_js] = total_levels * js_i1[k1] + js_i2[k2];\n        //Need to take complex conjugate to get true U*\n        vals[*num_js] = PetscConjComplex(vals_i1[k1])*vals_i2[k2];\n\n        *num_js = *num_js + 1;\n      }\n    }\n  }\n\n  return;\n}\n\nvoid U3_get_val_j_from_global_i(PetscInt i,struct quantum_gate_struct gate,PetscInt *num_js,\n                                      PetscInt js[],PetscScalar vals[],PetscInt tensor_control){\n  PetscInt n_after,i_sub,k1,k2,tmp_int,i1,i2,num_js_i1,num_js_i2,js_i1[2],js_i2[2],my_levels;\n  PetscScalar vals_i1[2],vals_i2[2];\n  PetscReal theta,lambda,phi;\n  /*\n   * u3 gate\n   *\n   * u3(theta,phi,lambda)  = | cos(theta/2)              -e^(i lambda) * sin(theta/2)    |\n   *                         | e^(i phi) sin(theta/2)    e^(i (lambda+phi)) cos(theta/2) |\n   * the u3 gate is a general one qubit transformation.\n   * the u2 gate is u3(pi/2,phi,lambda)\n   * the u1 gate is u3(0,0,lambda)\n   * The u3 gate has two elements per row,\n   * with both diagonal anad off diagonal elements\n   *\n   */\n  theta = gate.theta;\n  phi = gate.phi;\n  lambda = gate.lambda;\n  if (tensor_control!= 0) {\n    my_levels = 2; //Hardcoded becase single qubit gate\n    _get_n_after_1qbit(i,gate.qubit_numbers[0],tensor_control,&n_after,&i_sub);\n    *num_js = 2;\n    if (i_sub==0) {\n      // Diagonal element\n      js[0]   = i;\n      vals[0] = PetscCosReal(theta/2);\n\n      // Off diagonal element\n      tmp_int = i - 0 * n_after;\n      k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n      k1      = tmp_int%(my_levels*n_after);\n      js[1]   = (0 + 1) * n_after + k1 + k2*my_levels*n_after;\n      vals[1] = -PetscExpComplex(PETSC_i*lambda)*PetscSinReal(theta/2);\n\n    } else if (i_sub==1){\n      // Diagonal element\n      js[0]   = i;\n      vals[0] = PetscExpComplex(PETSC_i*(lambda+phi))*PetscCosReal(theta/2);\n      // Off diagonal element\n      tmp_int = i - (0+1) * n_after;\n      k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n      k1      = tmp_int%(my_levels*n_after);\n      js[1]   = 0 * n_after + k1 + k2*my_levels*n_after;\n      vals[1] = PetscExpComplex(PETSC_i*phi)*PetscSinReal(theta/2);\n\n    } else {\n      if (nid==0){\n        printf(\"ERROR! u3 gate is only defined for qubits\\n\");\n        exit(0);\n      }\n    }\n  } else {\n    /*\n     * U* cross U\n     * To calculate this, we first take our i_global, convert\n     * it to i1 (for U*) and i2 (for U) within their own\n     * part of the Hilbert space. pWe then treat i1 and i2 as\n     * global i's for the matrices U* and U themselves, which\n     * gives us j's for those matrices. We then expand the j's\n     * to get the full space representation, using the normal\n     * tensor product.\n     */\n\n    /* Calculate i1, i2 */\n    i1 = i/total_levels;\n    i2 = i%total_levels;\n\n    /* Now, get js for U* (i1) by calling this function */\n    U3_get_val_j_from_global_i(i1,gate,&num_js_i1,js_i1,vals_i1,-1);\n\n    /* Now, get js for U (i2) by calling this function */\n    U3_get_val_j_from_global_i(i2,gate,&num_js_i2,js_i2,vals_i2,-1);\n\n\n    /*\n     * Combine j's to get U* cross U\n     * Must do all possible permutations\n     */\n    *num_js = 0;\n    for(k1=0;k1<num_js_i1;k1++){\n      for(k2=0;k2<num_js_i2;k2++){\n        js[*num_js] = total_levels * js_i1[k1] + js_i2[k2];\n        //Need to take complex conjugate to get true U*\n        vals[*num_js] = PetscConjComplex(vals_i1[k1])*vals_i2[k2];\n\n        *num_js = *num_js + 1;\n      }\n    }\n  }\n\n  return;\n}\n\n\nvoid EYE_get_val_j_from_global_i(PetscInt i,struct quantum_gate_struct gate,PetscInt *num_js,\n                                      PetscInt js[],PetscScalar vals[],PetscInt tensor_control){\n  PetscInt n_after,i_sub,k1,k2,i1,i2,num_js_i1,num_js_i2,js_i1[2],js_i2[2];\n  PetscScalar vals_i1[2],vals_i2[2];\n\n  /*\n   * Identity (EYE) gate\n   *\n   *   | 1   0 |\n   *   | 0   1 |\n   *\n   */\n\n  if (tensor_control!= 0) {\n    _get_n_after_1qbit(i,gate.qubit_numbers[0],tensor_control,&n_after,&i_sub);\n    *num_js = 1;\n    js[0] = i;\n    vals[0] = 1.0;\n  } else {\n    /*\n     * U* cross U\n     * To calculate this, we first take our i_global, convert\n     * it to i1 (for U*) and i2 (for U) within their own\n     * part of the Hilbert space. pWe then treat i1 and i2 as\n     * global i's for the matrices U* and U themselves, which\n     * gives us j's for those matrices. We then expand the j's\n     * to get the full space representation, using the normal\n     * tensor product.\n     */\n\n    /* Calculate i1, i2 */\n    i1 = i/total_levels;\n    i2 = i%total_levels;\n\n    /* Now, get js for U* (i1) by calling this function */\n    EYE_get_val_j_from_global_i(i1,gate,&num_js_i1,js_i1,vals_i1,-1);\n\n    /* Now, get js for U (i2) by calling this function */\n    EYE_get_val_j_from_global_i(i2,gate,&num_js_i2,js_i2,vals_i2,-1);\n\n    /*\n     * Combine j's to get U* cross U\n     * Must do all possible permutations\n     */\n    *num_js = 0;\n    for(k1=0;k1<num_js_i1;k1++){\n      for(k2=0;k2<num_js_i2;k2++){\n        js[*num_js] = total_levels * js_i1[k1] + js_i2[k2];\n        //Need to take complex conjugate to get true U*\n        vals[*num_js] = PetscConjComplex(vals_i1[k1])*vals_i2[k2];\n\n        *num_js = *num_js + 1;\n      }\n    }\n  }\n  return;\n}\n\n\nvoid PHASESHIFT_get_val_j_from_global_i(PetscInt i,struct quantum_gate_struct gate,PetscInt *num_js,\n                                    PetscInt js[],PetscScalar vals[],PetscInt tensor_control){\n    PetscInt n_after,i_sub,k1,k2,i1,i2,num_js_i1,num_js_i2,js_i1[2],js_i2[2],my_levels;\n    PetscScalar vals_i1[2],vals_i2[2];\n    PetscReal theta;\n    \n    /*\n     * PHASESHIFT gate\n     *\n     *   | 1   0 |\n     *   | 0  e^(-i*theta) |\n     *\n     */\n    \n    theta=gate.theta;\n    if (tensor_control!= 0) {\n        my_levels = 2; //Hardcoded becase single qubit gate\n        _get_n_after_1qbit(i,gate.qubit_numbers[0],tensor_control,&n_after,&i_sub);\n        *num_js = 1;\n        if (i_sub==0) {\n            // Diagonal element\n            js[0] = i;\n            vals[0] = 1.0;\n            \n        } else if (i_sub==1){\n            // Diagonal element\n            js[0] = i;\n            vals[0] = PetscExpComplex(-PETSC_i*theta);\n            \n        } else {\n            if (nid==0){\n                printf(\"ERROR! phaseshift gate is only defined for qubits\\n\");\n                exit(0);\n            }\n        }\n    } else {\n        /*\n         * U* cross U\n         * To calculate this, we first take our i_global, convert\n         * it to i1 (for U*) and i2 (for U) within their own\n         * part of the Hilbert space. pWe then treat i1 and i2 as\n         * global i's for the matrices U* and U themselves, which\n         * gives us j's for those matrices. We then expand the j's\n         * to get the full space representation, using the normal\n         * tensor product.\n         */\n        \n        /* Calculate i1, i2 */\n        i1 = i/total_levels;\n        i2 = i%total_levels;\n        \n        /* Now, get js for U* (i1) by calling this function */\n        PHASESHIFT_get_val_j_from_global_i(i1,gate,&num_js_i1,js_i1,vals_i1,-1);\n        \n        /* Now, get js for U (i2) by calling this function */\n        PHASESHIFT_get_val_j_from_global_i(i2,gate,&num_js_i2,js_i2,vals_i2,-1);\n        \n        /*\n         * Combine j's to get U* cross U\n         * Must do all possible permutations\n         */\n        *num_js = 0;\n        for(k1=0;k1<num_js_i1;k1++){\n            for(k2=0;k2<num_js_i2;k2++){\n                js[*num_js] = total_levels * js_i1[k1] + js_i2[k2];\n                //Need to take complex conjugate to get true U*\n                vals[*num_js] = PetscConjComplex(vals_i1[k1])*vals_i2[k2];\n                \n                *num_js = *num_js + 1;\n            }\n        }\n    }\n    return;\n}\n\nvoid SIGMAZ_get_val_j_from_global_i(PetscInt i,struct quantum_gate_struct gate,PetscInt *num_js,\n                                      PetscInt js[],PetscScalar vals[],PetscInt tensor_control){\n  PetscInt n_after,i_sub,k1,k2,i1,i2,num_js_i1,num_js_i2,js_i1[2],js_i2[2],my_levels;\n  PetscScalar vals_i1[2],vals_i2[2];\n\n  /*\n   * SIGMAZ gate\n   *\n   *   | 1   0 |\n   *   | 0  -1 |\n   *\n   */\n\n  if (tensor_control!= 0) {\n    my_levels = 2; //Hardcoded becase single qubit gate\n    _get_n_after_1qbit(i,gate.qubit_numbers[0],tensor_control,&n_after,&i_sub);\n    *num_js = 1;\n    if (i_sub==0) {\n      // Diagonal element\n      js[0] = i;\n      vals[0] = 1.0;\n\n    } else if (i_sub==1){\n      // Diagonal element\n      js[0] = i;\n      vals[0] = -1.0;\n\n    } else {\n      if (nid==0){\n        printf(\"ERROR! sigmaz gate is only defined for qubits\\n\");\n        exit(0);\n      }\n    }\n  } else {\n    /*\n     * U* cross U\n     * To calculate this, we first take our i_global, convert\n     * it to i1 (for U*) and i2 (for U) within their own\n     * part of the Hilbert space. pWe then treat i1 and i2 as\n     * global i's for the matrices U* and U themselves, which\n     * gives us j's for those matrices. We then expand the j's\n     * to get the full space representation, using the normal\n     * tensor product.\n     */\n\n    /* Calculate i1, i2 */\n    i1 = i/total_levels;\n    i2 = i%total_levels;\n\n    /* Now, get js for U* (i1) by calling this function */\n    SIGMAZ_get_val_j_from_global_i(i1,gate,&num_js_i1,js_i1,vals_i1,-1);\n\n    /* Now, get js for U (i2) by calling this function */\n    SIGMAZ_get_val_j_from_global_i(i2,gate,&num_js_i2,js_i2,vals_i2,-1);\n\n    /*\n     * Combine j's to get U* cross U\n     * Must do all possible permutations\n     */\n    *num_js = 0;\n    for(k1=0;k1<num_js_i1;k1++){\n      for(k2=0;k2<num_js_i2;k2++){\n        js[*num_js] = total_levels * js_i1[k1] + js_i2[k2];\n        //Need to take complex conjugate to get true U*\n        vals[*num_js] = PetscConjComplex(vals_i1[k1])*vals_i2[k2];\n\n        *num_js = *num_js + 1;\n      }\n    }\n  }\n  return;\n}\n\nvoid RZ_get_val_j_from_global_i(PetscInt i,struct quantum_gate_struct gate,PetscInt *num_js,\n                                      PetscInt js[],PetscScalar vals[],PetscInt tensor_control){\n  PetscInt n_after,i_sub,k1,k2,i1,i2,num_js_i1,num_js_i2,js_i1[2],js_i2[2],my_levels;\n  PetscScalar vals_i1[2],vals_i2[2];\n  PetscReal theta;\n  /*\n   * RZ gate\n   *\n   *   | exp(i*theta/2)   0               |\n   *   | 0                -exp(i*theta/2) |\n   *\n   */\n\n  theta = gate.theta;\n  if (tensor_control!= 0) {\n    my_levels = 2; //Hardcoded becase single qubit gate\n    _get_n_after_1qbit(i,gate.qubit_numbers[0],tensor_control,&n_after,&i_sub);\n    *num_js = 1;\n    if (i_sub==0) {\n      // Diagonal element\n      js[0] = i;\n      vals[0] = PetscExpComplex(PETSC_i*theta/2);\n\n    } else if (i_sub==1){\n      // Diagonal element\n      js[0] = i;\n      vals[0] = PetscExpComplex(-PETSC_i*theta/2);\n\n    } else {\n      if (nid==0){\n        printf(\"ERROR! rz gate is only defined for qubits\\n\");\n        exit(0);\n      }\n    }\n  } else {\n    /*\n     * U* cross U\n     * To calculate this, we first take our i_global, convert\n     * it to i1 (for U*) and i2 (for U) within their own\n     * part of the Hilbert space. pWe then treat i1 and i2 as\n     * global i's for the matrices U* and U themselves, which\n     * gives us j's for those matrices. We then expand the j's\n     * to get the full space representation, using the normal\n     * tensor product.\n     */\n\n    /* Calculate i1, i2 */\n    i1 = i/total_levels;\n    i2 = i%total_levels;\n\n    /* Now, get js for U* (i1) by calling this function */\n    RZ_get_val_j_from_global_i(i1,gate,&num_js_i1,js_i1,vals_i1,-1);\n\n    /* Now, get js for U (i2) by calling this function */\n    RZ_get_val_j_from_global_i(i2,gate,&num_js_i2,js_i2,vals_i2,-1);\n\n    /*\n     * Combine j's to get U* cross U\n     * Must do all possible permutations\n     */\n    *num_js = 0;\n    for(k1=0;k1<num_js_i1;k1++){\n      for(k2=0;k2<num_js_i2;k2++){\n        js[*num_js] = total_levels * js_i1[k1] + js_i2[k2];\n        //Need to take complex conjugate to get true U*\n        vals[*num_js] = PetscConjComplex(vals_i1[k1])*vals_i2[k2];\n\n        *num_js = *num_js + 1;\n      }\n    }\n  }\n  return;\n}\n\nvoid RY_get_val_j_from_global_i(PetscInt i,struct quantum_gate_struct gate,PetscInt *num_js,\n                                      PetscInt js[],PetscScalar vals[],PetscInt tensor_control){\n  PetscInt n_after,i_sub,k1,k2,tmp_int,i1,i2,num_js_i1,num_js_i2,js_i1[2],js_i2[2],my_levels;\n  PetscScalar vals_i1[2],vals_i2[2];\n  PetscReal theta;\n  /*\n   * RY gate\n   *\n   *   | cos(theta/2)   sin(theta/2)  |\n   *   | -sin(theta/2)  cos(theta/2)  |\n   *\n   */\n\n  theta = gate.theta;\n  if (tensor_control!= 0) {\n    my_levels = 2; //Hardcoded becase single qubit gate\n    _get_n_after_1qbit(i,gate.qubit_numbers[0],tensor_control,&n_after,&i_sub);\n    *num_js = 2;\n    if (i_sub==0) {\n      // Diagonal element\n      js[0] = i;\n      vals[0] = PetscCosReal(theta/2.0);\n      // Off diagonal element\n      tmp_int = i - 0 * n_after;\n      k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n      k1      = tmp_int%(my_levels*n_after);\n      js[1]     = (0 + 1) * n_after + k1 + k2*my_levels*n_after;\n      vals[1]   = PetscSinReal(theta/2);\n\n\n    } else if (i_sub==1){\n      // Diagonal element\n      js[0] = i;\n      vals[0] = PetscCosReal(theta/2);\n\n      // Off diagonal element\n      tmp_int = i - (0+1) * n_after;\n      k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n      k1      = tmp_int%(my_levels*n_after);\n      js[1]   = 0 * n_after + k1 + k2*my_levels*n_after;\n      vals[1]   = -PetscSinReal(theta/2);\n\n\n    } else {\n      if (nid==0){\n        printf(\"ERROR! rz gate is only defined for qubits\\n\");\n        exit(0);\n      }\n    }\n  } else {\n    /*\n     * U* cross U\n     * To calculate this, we first take our i_global, convert\n     * it to i1 (for U*) and i2 (for U) within their own\n     * part of the Hilbert space. pWe then treat i1 and i2 as\n     * global i's for the matrices U* and U themselves, which\n     * gives us j's for those matrices. We then expand the j's\n     * to get the full space representation, using the normal\n     * tensor product.\n     */\n\n    /* Calculate i1, i2 */\n    i1 = i/total_levels;\n    i2 = i%total_levels;\n\n    /* Now, get js for U* (i1) by calling this function */\n    RY_get_val_j_from_global_i(i1,gate,&num_js_i1,js_i1,vals_i1,-1);\n\n    /* Now, get js for U (i2) by calling this function */\n    RY_get_val_j_from_global_i(i2,gate,&num_js_i2,js_i2,vals_i2,-1);\n\n    /*\n     * Combine j's to get U* cross U\n     * Must do all possible permutations\n     */\n    *num_js = 0;\n    for(k1=0;k1<num_js_i1;k1++){\n      for(k2=0;k2<num_js_i2;k2++){\n        js[*num_js] = total_levels * js_i1[k1] + js_i2[k2];\n        //Need to take complex conjugate to get true U*\n        vals[*num_js] = PetscConjComplex(vals_i1[k1])*vals_i2[k2];\n\n        *num_js = *num_js + 1;\n      }\n    }\n  }\n  return;\n}\n\n\nvoid RX_get_val_j_from_global_i(PetscInt i,struct quantum_gate_struct gate,PetscInt *num_js,\n                                      PetscInt js[],PetscScalar vals[],PetscInt tensor_control){\n  PetscInt n_after,i_sub,k1,k2,tmp_int,i1,i2,num_js_i1,num_js_i2,js_i1[2],js_i2[2],my_levels;\n  PetscScalar vals_i1[2],vals_i2[2];\n  PetscReal theta;\n  /*\n   * RX gate\n   *\n   *   | cos(theta/2)    i*sin(theta/2) |\n   *   | i*sin(theta/2)  cos(theta/2)   |\n   *\n   */\n\n  theta = gate.theta;\n  if (tensor_control!= 0) {\n    my_levels = 2; //Hardcoded becase single qubit gate\n    _get_n_after_1qbit(i,gate.qubit_numbers[0],tensor_control,&n_after,&i_sub);\n    *num_js = 2;\n    if (i_sub==0) {\n      // Diagonal element\n      js[0] = i;\n      vals[0] = PetscCosReal(theta/2);\n\n      // Off diagonal element\n      tmp_int = i - 0 * n_after;\n      k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n      k1      = tmp_int%(my_levels*n_after);\n      js[1]     = (0 + 1) * n_after + k1 + k2*my_levels*n_after;\n      vals[1]   = PETSC_i * PetscSinReal(theta/2);\n\n\n    } else if (i_sub==1){\n      // Diagonal element\n      js[0] = i;\n      vals[0] = PetscCosReal(theta/2);\n\n      // Off diagonal element\n      tmp_int = i - (0+1) * n_after;\n      k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n      k1      = tmp_int%(my_levels*n_after);\n      js[1]   = 0 * n_after + k1 + k2*my_levels*n_after;\n      vals[1]   = PETSC_i * PetscSinReal(theta/2);\n\n\n    } else {\n      if (nid==0){\n        printf(\"ERROR! rz gate is only defined for qubits\\n\");\n        exit(0);\n      }\n    }\n  } else {\n    /*\n     * U* cross U\n     * To calculate this, we first take our i_global, convert\n     * it to i1 (for U*) and i2 (for U) within their own\n     * part of the Hilbert space. pWe then treat i1 and i2 as\n     * global i's for the matrices U* and U themselves, which\n     * gives us j's for those matrices. We then expand the j's\n     * to get the full space representation, using the normal\n     * tensor product.\n     */\n\n    /* Calculate i1, i2 */\n    i1 = i/total_levels;\n    i2 = i%total_levels;\n\n    /* Now, get js for U* (i1) by calling this function */\n    RX_get_val_j_from_global_i(i1,gate,&num_js_i1,js_i1,vals_i1,-1);\n\n    /* Now, get js for U (i2) by calling this function */\n    RX_get_val_j_from_global_i(i2,gate,&num_js_i2,js_i2,vals_i2,-1);\n\n    /*\n     * Combine j's to get U* cross U\n     * Must do all possible permutations\n     */\n    *num_js = 0;\n    for(k1=0;k1<num_js_i1;k1++){\n      for(k2=0;k2<num_js_i2;k2++){\n        js[*num_js] = total_levels * js_i1[k1] + js_i2[k2];\n        //Need to take complex conjugate to get true U*\n        vals[*num_js] = PetscConjComplex(vals_i1[k1])*vals_i2[k2];\n\n        *num_js = *num_js + 1;\n      }\n    }\n  }\n  return;\n}\n\n\nvoid SIGMAY_get_val_j_from_global_i(PetscInt i,struct quantum_gate_struct gate,PetscInt *num_js,\n                                      PetscInt js[],PetscScalar vals[],PetscInt tensor_control){\n  PetscInt n_after,i_sub,k1,k2,tmp_int,i1,i2,num_js_i1,num_js_i2,js_i1[2],js_i2[2],my_levels;\n  PetscScalar vals_i1[2],vals_i2[2];\n\n  /*\n   * SIGMAY gate\n   *\n   *   | 0  -1.j |\n   *   | 1.j  0 |\n   *\n   */\n  if (tensor_control!= 0) {\n    my_levels = 2; //Hardcoded becase single qubit gate\n    _get_n_after_1qbit(i,gate.qubit_numbers[0],tensor_control,&n_after,&i_sub);\n    *num_js = 1;\n    if (i_sub==0) {\n\n      // Off diagonal element\n      tmp_int = i - 0 * n_after;\n      k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n      k1      = tmp_int%(my_levels*n_after);\n      js[0]   = (0 + 1) * n_after + k1 + k2*my_levels*n_after;\n      vals[0] = -1.0*PETSC_i;\n\n    } else if (i_sub==1){\n\n      // Off diagonal element\n      tmp_int = i - (0+1) * n_after;\n      k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n      k1      = tmp_int%(my_levels*n_after);\n      js[0]   = 0 * n_after + k1 + k2*my_levels*n_after;\n      vals[0] = 1.0*PETSC_i;\n\n    } else {\n      if (nid==0){\n        printf(\"ERROR! sigmay gate is only defined for qubits\\n\");\n        exit(0);\n      }\n    }\n\n  } else {\n    /*\n     * U* cross U\n     * To calculate this, we first take our i_global, convert\n     * it to i1 (for U*) and i2 (for U) within their own\n     * part of the Hilbert space. pWe then treat i1 and i2 as\n     * global i's for the matrices U* and U themselves, which\n     * gives us j's for those matrices. We then expand the j's\n     * to get the full space representation, using the normal\n     * tensor product.\n     */\n\n    /* Calculate i1, i2 */\n    i1 = i/total_levels;\n    i2 = i%total_levels;\n\n    /* Now, get js for U* (i1) by calling this function */\n    SIGMAY_get_val_j_from_global_i(i1,gate,&num_js_i1,js_i1,vals_i1,-1);\n\n    /* Now, get js for U (i2) by calling this function */\n    SIGMAY_get_val_j_from_global_i(i2,gate,&num_js_i2,js_i2,vals_i2,-1);\n\n    /*\n     * Combine j's to get U* cross U\n     * Must do all possible permutations\n     */\n    *num_js = 0;\n    for(k1=0;k1<num_js_i1;k1++){\n      for(k2=0;k2<num_js_i2;k2++){\n        js[*num_js] = total_levels * js_i1[k1] + js_i2[k2];\n        //Need to take complex conjugate to get true U*\n        vals[*num_js] = PetscConjComplex(vals_i1[k1])*vals_i2[k2];\n\n        *num_js = *num_js + 1;\n      }\n    }\n  }\n  return;\n}\n\n\nvoid SIGMAX_get_val_j_from_global_i(PetscInt i,struct quantum_gate_struct gate,PetscInt *num_js,\n                                      PetscInt js[],PetscScalar vals[],PetscInt tensor_control){\n  PetscInt n_after,i_sub,k1,k2,tmp_int,i1,i2,num_js_i1,num_js_i2,js_i1[2],js_i2[2],my_levels;\n  PetscScalar vals_i1[2],vals_i2[2];\n\n  /*\n   * SIGMAX gate\n   *\n   *   | 0  1 |\n   *   | 1  0 |\n   *\n   */\n  if (tensor_control!= 0) {\n    my_levels = 2; //Hardcoded becase single qubit gate\n    _get_n_after_1qbit(i,gate.qubit_numbers[0],tensor_control,&n_after,&i_sub);\n    *num_js = 1;\n    if (i_sub==0) {\n\n      // Off diagonal element\n      tmp_int = i - 0 * n_after;\n      k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n      k1      = tmp_int%(my_levels*n_after);\n      js[0]     = (0 + 1) * n_after + k1 + k2*my_levels*n_after;\n      vals[0]   = 1.0;\n\n    } else if (i_sub==1){\n\n      // Off diagonal element\n      tmp_int = i - (0+1) * n_after;\n      k2      = tmp_int/(my_levels*n_after);//Use integer arithmetic to get floor function\n      k1      = tmp_int%(my_levels*n_after);\n      js[0]   = 0 * n_after + k1 + k2*my_levels*n_after;\n      vals[0] = 1.0;\n\n    } else {\n      if (nid==0){\n        printf(\"ERROR! sigmax gate is only defined for qubits\\n\");\n        exit(0);\n      }\n    }\n  } else {\n    /*\n     * U* cross U\n     * To calculate this, we first take our i_global, convert\n     * it to i1 (for U*) and i2 (for U) within their own\n     * part of the Hilbert space. pWe then treat i1 and i2 as\n     * global i's for the matrices U* and U themselves, which\n     * gives us j's for those matrices. We then expand the j's\n     * to get the full space representation, using the normal\n     * tensor product.\n     */\n\n    /* Calculate i1, i2 */\n    i1 = i/total_levels;\n    i2 = i%total_levels;\n\n    /* Now, get js for U* (i1) by calling this function */\n    SIGMAX_get_val_j_from_global_i(i1,gate,&num_js_i1,js_i1,vals_i1,-1);\n\n    /* Now, get js for U (i2) by calling this function */\n    SIGMAX_get_val_j_from_global_i(i2,gate,&num_js_i2,js_i2,vals_i2,-1);\n\n    /*\n     * Combine j's to get U* cross U\n     * Must do all possible permutations\n     */\n    *num_js = 0;\n    for(k1=0;k1<num_js_i1;k1++){\n      for(k2=0;k2<num_js_i2;k2++){\n        js[*num_js] = total_levels * js_i1[k1] + js_i2[k2];\n        //Need to take complex conjugate to get true U*\n        vals[*num_js] = PetscConjComplex(vals_i1[k1])*vals_i2[k2];\n\n        *num_js = *num_js + 1;\n      }\n    }\n  }\n  return;\n}\n\nvoid T_get_val_j_from_global_i(PetscInt i,struct quantum_gate_struct gate,PetscInt *num_js,\n                                PetscInt js[],PetscScalar vals[],PetscInt tensor_control){\n    PetscInt n_after,i_sub,k1,k2,i1,i2,num_js_i1,num_js_i2,js_i1[2],js_i2[2],my_levels;\n    PetscScalar vals_i1[2],vals_i2[2];\n    PetscReal theta;\n    /*\n     * T gate\n     *\n     *   | 1   0               |\n     *   | 0       exp(i*pi/4) |\n     *\n     */\n    \n    theta = gate.theta;\n    if (tensor_control!= 0) {\n        my_levels = 2; //Hardcoded becase single qubit gate\n        _get_n_after_1qbit(i,gate.qubit_numbers[0],tensor_control,&n_after,&i_sub);\n        *num_js = 1;\n        if (i_sub==0) {\n            // Diagonal element\n            js[0] = i;\n            vals[0] = 1;\n            \n        } else if (i_sub==1){\n            // Diagonal element\n            js[0] = i;\n            vals[0] = PetscExpComplex(PETSC_i*PETSC_PI/4);\n            \n        } else {\n            if (nid==0){\n                printf(\"ERROR! T gate is only defined for qubits\\n\");\n                exit(0);\n            }\n        }\n    } else {\n        /*\n         * U* cross U\n         * To calculate this, we first take our i_global, convert\n         * it to i1 (for U*) and i2 (for U) within their own\n         * part of the Hilbert space. pWe then treat i1 and i2 as\n         * global i's for the matrices U* and U themselves, which\n         * gives us j's for those matrices. We then expand the j's\n         * to get the full space representation, using the normal\n         * tensor product.\n         */\n        \n        /* Calculate i1, i2 */\n        i1 = i/total_levels;\n        i2 = i%total_levels;\n        \n        /* Now, get js for U* (i1) by calling this function */\n        T_get_val_j_from_global_i(i1,gate,&num_js_i1,js_i1,vals_i1,-1);\n        \n        /* Now, get js for U (i2) by calling this function */\n        T_get_val_j_from_global_i(i2,gate,&num_js_i2,js_i2,vals_i2,-1);\n        \n        /*\n         * Combine j's to get U* cross U\n         * Must do all possible permutations\n         */\n        *num_js = 0;\n        for(k1=0;k1<num_js_i1;k1++){\n            for(k2=0;k2<num_js_i2;k2++){\n                js[*num_js] = total_levels * js_i1[k1] + js_i2[k2];\n                //Need to take complex conjugate to get true U*\n                vals[*num_js] = PetscConjComplex(vals_i1[k1])*vals_i2[k2];\n                \n                *num_js = *num_js + 1;\n            }\n        }\n    }\n    return;\n}\n\nvoid TDAG_get_val_j_from_global_i(PetscInt i,struct quantum_gate_struct gate,PetscInt *num_js,\n                               PetscInt js[],PetscScalar vals[],PetscInt tensor_control){\n    PetscInt n_after,i_sub,k1,k2,i1,i2,num_js_i1,num_js_i2,js_i1[2],js_i2[2],my_levels;\n    PetscScalar vals_i1[2],vals_i2[2];\n    PetscReal theta;\n    /*\n     * TDAG gate\n     *\n     *   | 1   0               |\n     *   | 0       exp(i*pi/4) |\n     *\n     */\n    \n    theta = gate.theta;\n    if (tensor_control!= 0) {\n        my_levels = 2; //Hardcoded becase single qubit gate\n        _get_n_after_1qbit(i,gate.qubit_numbers[0],tensor_control,&n_after,&i_sub);\n        *num_js = 1;\n        if (i_sub==0) {\n            // Diagonal element\n            js[0] = i;\n            vals[0] = 1;\n            \n        } else if (i_sub==1){\n            // Diagonal element\n            js[0] = i;\n            vals[0] = PetscExpComplex(-PETSC_i*PETSC_PI/4);\n            \n        } else {\n            if (nid==0){\n                printf(\"ERROR! T gate is only defined for qubits\\n\");\n                exit(0);\n            }\n        }\n    } else {\n        /*\n         * U* cross U\n         * To calculate this, we first take our i_global, convert\n         * it to i1 (for U*) and i2 (for U) within their own\n         * part of the Hilbert space. pWe then treat i1 and i2 as\n         * global i's for the matrices U* and U themselves, which\n         * gives us j's for those matrices. We then expand the j's\n         * to get the full space representation, using the normal\n         * tensor product.\n         */\n        \n        /* Calculate i1, i2 */\n        i1 = i/total_levels;\n        i2 = i%total_levels;\n        \n        /* Now, get js for U* (i1) by calling this function */\n        TDAG_get_val_j_from_global_i(i1,gate,&num_js_i1,js_i1,vals_i1,-1);\n        \n        /* Now, get js for U (i2) by calling this function */\n        TDAG_get_val_j_from_global_i(i2,gate,&num_js_i2,js_i2,vals_i2,-1);\n        \n        /*\n         * Combine j's to get U* cross U\n         * Must do all possible permutations\n         */\n        *num_js = 0;\n        for(k1=0;k1<num_js_i1;k1++){\n            for(k2=0;k2<num_js_i2;k2++){\n                js[*num_js] = total_levels * js_i1[k1] + js_i2[k2];\n                //Need to take complex conjugate to get true U*\n                vals[*num_js] = PetscConjComplex(vals_i1[k1])*vals_i2[k2];\n                \n                *num_js = *num_js + 1;\n            }\n        }\n    }\n    return;\n}\n\nvoid S_get_val_j_from_global_i(PetscInt i,struct quantum_gate_struct gate,PetscInt *num_js,\n                               PetscInt js[],PetscScalar vals[],PetscInt tensor_control){\n    PetscInt n_after,i_sub,k1,k2,i1,i2,num_js_i1,num_js_i2,js_i1[2],js_i2[2],my_levels;\n    PetscScalar vals_i1[2],vals_i2[2];\n    PetscReal theta;\n    /*\n     * S gate\n     *\n     *   | 1   0 |\n     *   | 0   i |\n     *\n     */\n    \n    theta = gate.theta;\n    if (tensor_control!= 0) {\n        my_levels = 2; //Hardcoded becase single qubit gate\n        _get_n_after_1qbit(i,gate.qubit_numbers[0],tensor_control,&n_after,&i_sub);\n        *num_js = 1;\n        if (i_sub==0) {\n            // Diagonal element\n            js[0] = i;\n            vals[0] = 1;\n            \n        } else if (i_sub==1){\n            // Diagonal element\n            js[0] = i;\n            vals[0] = PETSC_i;\n            \n        } else {\n            if (nid==0){\n                printf(\"ERROR! S gate is only defined for qubits\\n\");\n                exit(0);\n            }\n        }\n    } else {\n        /*\n         * U* cross U\n         * To calculate this, we first take our i_global, convert\n         * it to i1 (for U*) and i2 (for U) within their own\n         * part of the Hilbert space. pWe then treat i1 and i2 as\n         * global i's for the matrices U* and U themselves, which\n         * gives us j's for those matrices. We then expand the j's\n         * to get the full space representation, using the normal\n         * tensor product.\n         */\n        \n        /* Calculate i1, i2 */\n        i1 = i/total_levels;\n        i2 = i%total_levels;\n        \n        /* Now, get js for U* (i1) by calling this function */\n        S_get_val_j_from_global_i(i1,gate,&num_js_i1,js_i1,vals_i1,-1);\n        \n        /* Now, get js for U (i2) by calling this function */\n        S_get_val_j_from_global_i(i2,gate,&num_js_i2,js_i2,vals_i2,-1);\n        \n        /*\n         * Combine j's to get U* cross U\n         * Must do all possible permutations\n         */\n        *num_js = 0;\n        for(k1=0;k1<num_js_i1;k1++){\n            for(k2=0;k2<num_js_i2;k2++){\n                js[*num_js] = total_levels * js_i1[k1] + js_i2[k2];\n                //Need to take complex conjugate to get true U*\n                vals[*num_js] = PetscConjComplex(vals_i1[k1])*vals_i2[k2];\n                \n                *num_js = *num_js + 1;\n            }\n        }\n    }\n    return;\n}\n\nvoid _get_n_after_2qbit(PetscInt *i,int qubit_numbers[],PetscInt tensor_control,PetscInt *n_after, PetscInt *control, PetscInt *moved_system, PetscInt *i_sub){\n  operator this_op1,this_op2;\n  PetscInt n_before1,n_before2,extra_after,my_levels=4,j1; //4 is hardcoded because 2 qbits\n  if (tensor_control==1) {\n    extra_after = total_levels;\n  } else {\n    extra_after = 1;\n  }\n\n  //Two qubit gates\n  this_op1 = subsystem_list[qubit_numbers[0]];\n  this_op2 = subsystem_list[qubit_numbers[1]];\n  if (this_op1->my_levels * this_op2->my_levels != 4) {\n    //Check that it is a two level system\n    if (nid==0){\n      printf(\"ERROR! Two qubit gates can only affect two 2-level systems (global_i)\\n\");\n      exit(0);\n    }\n  }\n\n  n_before1  = this_op1->n_before;\n  n_before2  = this_op2->n_before;\n\n  *control = 0;\n  *moved_system = qubit_numbers[1];\n\n  /* 2 is hardcoded because CNOT gates are for qubits, which have 2 levels */\n  /* 4 is hardcoded because 2 qubits with 2 levels each */\n  *n_after   = total_levels/(4*n_before1)*extra_after;\n\n  /*\n   * Check which is the control and which is the target,\n   * flip if need be.\n   */\n  if (n_before2<n_before1) {\n    *n_after   = total_levels/(4*n_before2);\n    *control   = 1;\n    *moved_system = qubit_numbers[0];\n    n_before1 = n_before2;\n  }\n  /*\n   * Permute to temporary basis\n   * Get the i_sub in the permuted basis\n   */\n  _change_basis_ij_pair(i,&j1,qubit_numbers[*control]+1,*moved_system); // j1 useless here\n\n  *i_sub = *i/(*n_after)%my_levels; //Use integer arithmetic to get floor function\n\n  return;\n}\n\nvoid _get_n_after_1qbit(PetscInt i,int qubit_number,PetscInt tensor_control,PetscInt *n_after,PetscInt *i_sub){\n  operator this_op1;\n  PetscInt extra_after;\n  if (tensor_control==1) {\n    extra_after = total_levels;\n  } else {\n    extra_after = 1;\n  }\n\n  //Get the system this is affecting\n  this_op1 = subsystem_list[qubit_number];\n  if (this_op1->my_levels!=2) {\n    //Check that it is a two level system\n    if (nid==0){\n      printf(\"ERROR! Single qubit gates can only affect 2-level systems\\n\");\n      exit(0);\n    }\n  }\n  *n_after = total_levels/(this_op1->my_levels*this_op1->n_before)*extra_after;\n  *i_sub = i/(*n_after)%this_op1->my_levels; //Use integer arithmetic to get floor function\n\n  return;\n}\n\n// Check that the gate type is valid and set the number of qubits\nvoid _check_gate_type(gate_type my_gate_type,int *num_qubits){\n\n  if (my_gate_type==HADAMARD||my_gate_type==SIGMAX||my_gate_type==SIGMAY||my_gate_type==SIGMAZ||my_gate_type==EYE||\n      my_gate_type==RZ||my_gate_type==RX||my_gate_type==RY||my_gate_type==U3||my_gate_type==PHASESHIFT||my_gate_type==T||my_gate_type==TDAG||my_gate_type==S) {\n    *num_qubits = 1;\n  } else if (my_gate_type==CNOT||my_gate_type==CXZ||my_gate_type==CZ||my_gate_type==CmZ||my_gate_type==CZX||my_gate_type==SWAP){\n    *num_qubits = 2;\n  } else {\n    if (nid==0){\n      printf(\"ERROR! Gate type not recognized\\n\");\n      exit(0);\n    }\n  }\n\n}\n/*\n * Put the gate function pointers into an array\n */\nvoid _initialize_gate_function_array(){\n  _get_val_j_functions_gates[CZX+_min_gate_enum] = CZX_get_val_j_from_global_i;\n  _get_val_j_functions_gates[CmZ+_min_gate_enum] = CmZ_get_val_j_from_global_i;\n  _get_val_j_functions_gates[CZ+_min_gate_enum] = CZ_get_val_j_from_global_i;\n  _get_val_j_functions_gates[CXZ+_min_gate_enum] = CXZ_get_val_j_from_global_i;\n  _get_val_j_functions_gates[CNOT+_min_gate_enum] = CNOT_get_val_j_from_global_i;\n  _get_val_j_functions_gates[HADAMARD+_min_gate_enum] = HADAMARD_get_val_j_from_global_i;\n  _get_val_j_functions_gates[SIGMAX+_min_gate_enum] = SIGMAX_get_val_j_from_global_i;\n  _get_val_j_functions_gates[SIGMAY+_min_gate_enum] = SIGMAY_get_val_j_from_global_i;\n  _get_val_j_functions_gates[SIGMAZ+_min_gate_enum] = SIGMAZ_get_val_j_from_global_i;\n  _get_val_j_functions_gates[EYE+_min_gate_enum] = EYE_get_val_j_from_global_i;\n  _get_val_j_functions_gates[RX+_min_gate_enum] = RX_get_val_j_from_global_i;\n  _get_val_j_functions_gates[RY+_min_gate_enum] = RY_get_val_j_from_global_i;\n  _get_val_j_functions_gates[RZ+_min_gate_enum] = RZ_get_val_j_from_global_i;\n  _get_val_j_functions_gates[U3+_min_gate_enum] = U3_get_val_j_from_global_i;\n  _get_val_j_functions_gates[SWAP+_min_gate_enum] = SWAP_get_val_j_from_global_i;\n  _get_val_j_functions_gates[PHASESHIFT+_min_gate_enum] = PHASESHIFT_get_val_j_from_global_i;\n  _get_val_j_functions_gates[T+_min_gate_enum] = T_get_val_j_from_global_i;\n  _get_val_j_functions_gates[TDAG+_min_gate_enum] = TDAG_get_val_j_from_global_i;\n  _get_val_j_functions_gates[S+_min_gate_enum] = S_get_val_j_from_global_i;\n}\n", "meta": {"hexsha": "1ca90ac558e934ff29655862b9329f4eee53ce25", "size": 129198, "ext": "c", "lang": "C", "max_stars_repo_path": "src/quantum_gates.c", "max_stars_repo_name": "sriharikrishna/QuaC", "max_stars_repo_head_hexsha": "679018a8f2642ca4c1fdf2b5eee275b4645bdbad", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/quantum_gates.c", "max_issues_repo_name": "sriharikrishna/QuaC", "max_issues_repo_head_hexsha": "679018a8f2642ca4c1fdf2b5eee275b4645bdbad", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/quantum_gates.c", "max_forks_repo_name": "sriharikrishna/QuaC", "max_forks_repo_head_hexsha": "679018a8f2642ca4c1fdf2b5eee275b4645bdbad", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.0442687747, "max_line_length": 159, "alphanum_fraction": 0.5716961563, "num_tokens": 38624, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4532618480153861, "lm_q2_score": 0.02675928337948029, "lm_q1q2_score": 0.012128962236150643}}
{"text": "/*\nODE: a program to get optime Runge-Kutta and multi-steps methods.\n\nCopyright 2011-2019, Javier Burguete Tolosa.\n\nRedistribution and use in source and binary forms, with or without modification,\nare permitted provided that the following conditions are met:\n\n\t1. Redistributions of source code must retain the above copyright notice,\n\t\tthis list of conditions and the following disclaimer.\n\n\t2. Redistributions in binary form must reproduce the above copyright notice,\n\t\tthis list of conditions and the following disclaimer in the\n\t\tdocumentation and/or other materials provided with the distribution.\n\nTHIS SOFTWARE IS PROVIDED BY Javier Burguete Tolosa ``AS IS'' AND ANY EXPRESS OR\nIMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\nMERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT\nSHALL Javier Burguete Tolosa OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,\nINCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT\nLIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\nPROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF\nLIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE\nOR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF\nADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n\n/**\n * \\file optimize.c\n * \\brief Source file with optimize functions.\n * \\author Javier Burguete Tolosa.\n * \\copyright Copyright 2011-2019.\n */\n#define _GNU_SOURCE\n#include <stdio.h>\n#include <string.h>\n#include <float.h>\n#include <math.h>\n#include <libxml/parser.h>\n#include <glib.h>\n#include <libintl.h>\n#include <gsl/gsl_rng.h>\n#if HAVE_MPI\n#include <mpi.h>\n#endif\n#include \"config.h\"\n#include \"utils.h\"\n#include \"optimize.h\"\n\n#define DEBUG_OPTIMIZE 0        ///< macro to debug.\n\nGMutex mutex[1];                ///< GMutex struct.\nFILE *file_variables = NULL;    ///< random variables file.\nint rank;                       ///< MPI rank.\nint nnodes;                     ///< MPI nodes number.\nunsigned nthreads;              ///< threads number.\n\n/**\n * Function to print the random variables on a file.\n */\nvoid\noptimize_print_random (Optimize * optimize,     ///< Optimize struct.\n                       FILE * file)     ///< file.\n{\n  unsigned int i, n;\n  n = optimize->nfree;\n  for (i = 0; i < n; ++i)\n    fprintf (file, \"o%d:%.19Le;\\n\", i, optimize->value_optimal[i]);\n  for (i = 0; i < n; ++i)\n    fprintf (file, \"m%d:%.19Le;\\n\", i, optimize->minimum[i]);\n  for (i = 0; i < n; ++i)\n    fprintf (file, \"i%d:%.19Le;\\n\", i, optimize->interval[i]);\n}\n\n/**\n * Function to perform every optimization step.\n */\nvoid\noptimize_step (Optimize * optimize)     ///< Optimize struct.\n{\n  long double *is, *vo, *vo2, *random;\n  long double o, o2, v, f;\n  unsigned long long int ii, nrandom;\n  unsigned int i, j, k, n, nfree;\n\n#if DEBUG_OPTIMIZE\n  fprintf (stderr, \"optimize_step: start\\n\");\n#endif\n\n  // save optimal values\n#if DEBUG_OPTIMIZE\n  fprintf (stderr, \"optimize_step: save optimal values\\n\");\n#endif\n  nfree = optimize->nfree;\n  o2 = *optimize->optimal;\n  vo = (long double *) alloca (nfree * sizeof (long double));\n  vo2 = (long double *) alloca (nfree * sizeof (long double));\n  memcpy (vo, optimize->value_optimal, nfree * sizeof (long double));\n\n  // optimization algorithm sampling\n#if DEBUG_OPTIMIZE\n  fprintf (stderr, \"optimize_step: optimization algorithm sampling\\n\");\n  fprintf (stderr, \"optimize_step: nsimulations=%Lu\\n\", optimize->nsimulations);\n#endif\n  random = optimize->random_data;\n  ii = optimize->nsimulations * (rank * nthreads + optimize->thread)\n    / (nnodes * nthreads);\n  nrandom = optimize->nsimulations * (rank * nthreads + optimize->thread + 1)\n    / (nnodes * nthreads);\n  for (; ii < nrandom; ++ii)\n    {\n\n      // random freedom degrees\n#if DEBUG_OPTIMIZE\n      fprintf (stderr, \"optimize_step: random freedom degrees\\n\");\n      fprintf (stderr, \"optimize_step: simulation=%Lu\\n\", ii);\n#endif\n      optimize_generate_freedom (optimize, ii);\n\n      // method coefficients\n#if DEBUG_OPTIMIZE\n      fprintf (stderr, \"optimize_step: method coefficients\\n\");\n#endif\n      if (!optimize->method (optimize))\n        o = INFINITY;\n      else\n        o = optimize->objective (optimize);\n      if (o < o2)\n        {\n          o2 = o;\n          memcpy (vo, random, nfree * sizeof (long double));\n        }\n      if (file_variables)\n        {\n          g_mutex_lock (mutex);\n          print_variables (random, nfree, file_variables);\n          fprintf (file_variables, \"%.19Le\\n\", o);\n          g_mutex_unlock (mutex);\n        }\n    }\n\n  // array of intervals to climb around the optimal\n#if DEBUG_OPTIMIZE\n  fprintf (stderr,\n           \"optimize_step: array of intervals to climb around the optimal\\n\");\n#endif\n  is = (long double *) alloca (nfree * sizeof (long double));\n  for (j = 0; j < nfree; ++j)\n    is[j] = optimize->interval0[j] * optimize->climbing_factor;\n\n  // hill climbing algorithm bucle\n#if DEBUG_OPTIMIZE\n  fprintf (stderr, \"optimize_step: hill climbing algorithm bucle\\n\");\n#endif\n  memcpy (vo2, vo, nfree * sizeof (long double));\n  n = optimize->nclimbings;\n  for (i = 0; i < n; ++i)\n    {\n      memcpy (random, vo, nfree * sizeof (long double));\n      for (j = k = 0; j < nfree; ++j)\n        {\n          v = vo[j];\n          random[j] = v + is[j];\n          if (!optimize->method (optimize))\n            o = INFINITY;\n          else\n            o = optimize->objective (optimize);\n          if (o < o2)\n            {\n              k = 1;\n              o2 = o;\n              memcpy (vo2, random, nfree * sizeof (long double));\n            }\n          if (file_variables)\n            {\n              g_mutex_lock (mutex);\n              print_variables (random, nfree, file_variables);\n              fprintf (file_variables, \"%.19Le\\n\", o);\n              g_mutex_unlock (mutex);\n            }\n          random[j] = fmaxl (0.L, v - is[j]);\n          if (!optimize->method (optimize))\n            o = INFINITY;\n          else\n            o = optimize->objective (optimize);\n          if (o < o2)\n            {\n              k = 1;\n              o2 = o;\n              memcpy (vo2, random, nfree * sizeof (long double));\n            }\n          if (file_variables)\n            {\n              g_mutex_lock (mutex);\n              print_variables (random, nfree, file_variables);\n              fprintf (file_variables, \"%.19Le\\n\", o);\n              g_mutex_unlock (mutex);\n            }\n          random[j] = v;\n        }\n\n\n      // update optimal values and increase or reduce intervals if converging or\n      // not\n      if (!k)\n        f = 0.5L;\n      else\n        {\n          f = 1.2L;\n          memcpy (vo, vo2, nfree * sizeof (long double));\n        }\n      for (j = 0; j < nfree; ++j)\n        is[j] *= f;\n    }\n\n  // update optimal values\n#if DEBUG_OPTIMIZE\n  fprintf (stderr, \"optimize_step: update optimal values\\n\");\n#endif\n  if (o2 < *optimize->optimal)\n    {\n      g_mutex_lock (mutex);\n      *optimize->optimal = o2;\n      memcpy (optimize->value_optimal, vo2, nfree * sizeof (long double));\n      g_mutex_unlock (mutex);\n    }\n\n#if DEBUG_OPTIMIZE\n  fprintf (stderr, \"optimize_step: end\\n\");\n#endif\n}\n\n/**\n * Function to init required variables on an Optimize struct data.\n */\nvoid\noptimize_init (Optimize * optimize,     ///< Optimize struct.\n               gsl_rng * rng,   ///< GSL pseudo-random number generator struct.\n               unsigned int thread)     ///< thread number.\n{\n#if DEBUG_OPTIMIZE\n  fprintf (stderr, \"optimize_init: start\\n\");\n#endif\n#if DEBUG_OPTIMIZE\n  fprintf (stderr, \"optimize_init: nsimulations=%Lu nfree=%u size=%u\\n\",\n           optimize->nsimulations, optimize->nfree, optimize->size);\n#endif\n  optimize->random_data\n    = (long double *) g_slice_alloc (optimize->nfree * sizeof (long double));\n  optimize->coefficient\n    = (long double *) g_slice_alloc (optimize->size * sizeof (long double));\n  optimize->minimum\n    = (long double *) g_slice_alloc (optimize->nfree * sizeof (long double));\n  optimize->interval\n    = (long double *) g_slice_alloc (optimize->nfree * sizeof (long double));\n  memcpy (optimize->minimum, optimize->minimum0,\n          optimize->nfree * sizeof (long double));\n  memcpy (optimize->interval, optimize->interval0,\n          optimize->nfree * sizeof (long double));\n  optimize->rng = rng;\n  optimize->thread = thread;\n#if DEBUG_OPTIMIZE\n  fprintf (stderr, \"optimize_init: end\\n\");\n#endif\n}\n\n/**\n * Function to free the memory allocated by an Optimize struct.\n */\nvoid\noptimize_delete (Optimize * optimize)   ///< Optimize struct.\n{\n  g_slice_free1 (optimize->nfree * sizeof (long double), optimize->interval);\n  g_slice_free1 (optimize->nfree * sizeof (long double), optimize->minimum);\n  g_slice_free1 (optimize->size * sizeof (long double), optimize->coefficient);\n  g_slice_free1 (optimize->nfree * sizeof (long double), optimize->random_data);\n}\n\n/**\n * Function to do the optimization bucle.\n */\nvoid\noptimize_bucle (Optimize * optimize)    ///< Optimize struct.\n{\n  GThread *thread[nthreads];\n#if HAVE_MPI\n  long double *vo;\n  MPI_Status status;\n#endif\n  unsigned int i, j, nfree;\n\n#if DEBUG_OPTIMIZE\n  fprintf (stderr, \"optimize_bucle: start\\n\");\n  fprintf (stderr, \"optimize_bucle: nfree=%u\\n\", optimize->nfree);\n#endif\n\n  // Allocate local array of optimal values\n#if DEBUG_OPTIMIZE\n  fprintf (stderr, \"optimize_bucle: allocate local array of optimal values\\n\");\n#endif\n  nfree = optimize->nfree;\n#if HAVE_MPI\n  vo = (long double *) alloca ((1 + nfree) * sizeof (long double));\n  printf (\"Rank=%d NNodes=%d\\n\", rank, nnodes);\n#endif\n\n  // Init some parameters\n#if DEBUG_OPTIMIZE\n  fprintf (stderr, \"optimize_bucle: init some parameters\\n\");\n#endif\n  *optimize->optimal = INFINITY;\n  for (i = 0; i < nfree; ++i)\n    optimize->value_optimal[i]\n      = optimize->minimum[i] + 0.5L * optimize->interval[i];\n\n  // Iterate\n#if DEBUG_OPTIMIZE\n  fprintf (stderr, \"optimize_bucle: iterate\\n\");\n#endif\n  for (i = 0; i < optimize->niterations; ++i)\n    {\n\n      // Optimization step parallelized for every node by GThreads\n      if (nthreads > 1)\n        {\n          for (j = 0; j < nthreads; ++j)\n            thread[j]\n              = g_thread_new (NULL,\n                              (GThreadFunc) (void (*)(void)) optimize_step,\n                              (void *) (optimize + j));\n          for (j = 0; j < nthreads; ++j)\n            g_thread_join (thread[j]);\n        }\n      else\n        optimize_step (optimize);\n\n#if HAVE_MPI\n      if (rank > 0)\n        {\n\n          // Secondary nodes send the optimal coefficients to the master node\n          vo[0] = *optimize->optimal;\n          memcpy (vo + 1, optimize->value_optimal,\n                  nfree * sizeof (long double));\n          MPI_Send (vo, 1 + nfree, MPI_LONG_DOUBLE, 0, 1, MPI_COMM_WORLD);\n\n          // Secondary nodes receive the optimal coefficients\n          MPI_Recv (vo, 1 + nfree, MPI_LONG_DOUBLE, 0, 1, MPI_COMM_WORLD,\n                    &status);\n          *optimize->optimal = vo[0];\n          memcpy (optimize->value_optimal, vo + 1,\n                  nfree * sizeof (long double));\n        }\n      else\n        {\n          printf (\"rank=%d optimal=%.19Le\\n\", rank, *optimize->optimal);\n\n          for (j = 1; j < nnodes; ++j)\n            {\n\n              // Master node receives the optimal coefficients obtained by\n              // secondary nodes\n              MPI_Recv (vo, 1 + nfree, MPI_LONG_DOUBLE, j, 1, MPI_COMM_WORLD,\n                        &status);\n\n              // Master node selects the optimal coefficients\n              if (vo[0] < *optimize->optimal)\n                {\n                  *optimize->optimal = vo[0];\n                  memcpy (optimize->value_optimal, vo + 1,\n                          nfree * sizeof (long double));\n                }\n            }\n\n          // Master node sends the optimal coefficients to secondary nodes\n          vo[0] = *optimize->optimal;\n          memcpy (vo + 1, optimize->value_optimal,\n                  nfree * sizeof (long double));\n          for (j = 1; j < nnodes; ++j)\n            MPI_Send (vo, 1 + nfree, MPI_LONG_DOUBLE, j, 1, MPI_COMM_WORLD);\n        }\n\n#endif\n\n      // Print the optimal coefficients\n#if DEBUG_OPTIMIZE\n      optimize_print_random (optimize, stderr);\n      fprintf (stderr, \"optimal=%.19Le\\n\", *optimize->optimal);\n#endif\n\n      // Updating coefficient intervals to converge\n      optimize_converge (optimize);\n\n      // Iterate\n#if HAVE_MPI\n      printf (\"Rank %u\\n\", rank);\n#endif\n      printf (\"Iteration %u Optimal %.19Le\\n\", i + 1, *optimize->optimal);\n    }\n\n#if DEBUG_OPTIMIZE\n  fprintf (stderr, \"optimize_bucle: end\\n\");\n#endif\n}\n\n/**\n * Function to create an Optimize struct data.\n */\nvoid\noptimize_create (Optimize * optimize,   ///< Optimize struct.\n                 long double *optimal,\n                 ///< pointer to the optimal objective function value.\n                 long double *value_optimal)\n                 ///< array of optimal freedom degree values.\n{\n  unsigned long long int nsimulations;\n  unsigned int i, nfree;\n#if DEBUG_OPTIMIZE\n  fprintf (stderr, \"optimize_create: start\\n\");\n#endif\n  optimize->optimal = optimal;\n  optimize->value_optimal = value_optimal;\n  nfree = optimize->nfree;\n  optimize->nsimulations = nsimulations = optimize->nvariable;\n  for (i = 1; i < nfree; ++i)\n    optimize->nsimulations *= nsimulations;\n  optimize->nclimbings *= nfree;\n#if DEBUG_OPTIMIZE\n  fprintf (stderr, \"optimize_create nsimulations=%Lu nclimbings=%u nfree=%u\\n\",\n           optimize->nsimulations, optimize->nclimbings, nfree);\n  fprintf (stderr, \"optimize_create: end\\n\");\n#endif\n}\n\n/**\n * Function to read the Optimize struct data on a XML node.\n *\n * \\return 1 on success, 0 on error.\n */\nint\noptimize_read (Optimize * optimize,     ///< Optimize struct.\n               xmlNode * node)  ///< XML node.\n{\n  int code;\n#if DEBUG_OPTIMIZE\n  fprintf (stderr, \"optimize_read: start\\n\");\n#endif\n  optimize->nvariable = xml_node_get_uint (node, XML_NSIMULATIONS, &code);\n  if (code || !optimize->nvariable)\n    {\n      error_message = g_strdup (_(\"Bad simulations number\"));\n      goto exit_on_error;\n    }\n  optimize->nclimbings\n    = xml_node_get_uint_with_default (node, XML_NCLIMBINGS, 0, &code);\n  if (code)\n    {\n      error_message = g_strdup (_(\"Bad hill climbings number\"));\n      goto exit_on_error;\n    }\n  optimize->niterations = xml_node_get_uint (node, XML_NITERATIONS, &code);\n  if (code || !optimize->niterations)\n    {\n      error_message = g_strdup (_(\"Bad iterations number\"));\n      goto exit_on_error;\n    }\n  optimize->convergence_factor\n    = xml_node_get_float (node, XML_CONVERGENCE_FACTOR, &code);\n  if (code || optimize->convergence_factor < LDBL_EPSILON)\n    {\n      error_message = g_strdup (_(\"Bad convergence factor\"));\n      goto exit_on_error;\n    }\n  optimize->climbing_factor\n    = xml_node_get_float (node, XML_CLIMBING_FACTOR, &code);\n  if (code || optimize->climbing_factor < LDBL_EPSILON)\n    {\n      error_message = g_strdup (_(\"Bad climging factor\"));\n      goto exit_on_error;\n    }\n#if DEBUG_OPTIMIZE\n  fprintf (stderr, \"optimize_read: end\\n\");\n#endif\n  return 1;\n\nexit_on_error:\n#if DEBUG_OPTIMIZE\n  fprintf (stderr, \"optimize_read: end\\n\");\n#endif\n  return 0;\n}\n", "meta": {"hexsha": "ecb8e16bf079c97e6b6daeeba64443aefd7af303", "size": 15262, "ext": "c", "lang": "C", "max_stars_repo_path": "optimize.c", "max_stars_repo_name": "jburguete/ode", "max_stars_repo_head_hexsha": "463b8402ed4aac140a4c4ca2295a69dcce98b061", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "optimize.c", "max_issues_repo_name": "jburguete/ode", "max_issues_repo_head_hexsha": "463b8402ed4aac140a4c4ca2295a69dcce98b061", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "optimize.c", "max_forks_repo_name": "jburguete/ode", "max_forks_repo_head_hexsha": "463b8402ed4aac140a4c4ca2295a69dcce98b061", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.0203252033, "max_line_length": 80, "alphanum_fraction": 0.618660726, "num_tokens": 3882, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3593641588823761, "lm_q2_score": 0.03358950190134913, "lm_q1q2_score": 0.012070863098056302}}
{"text": "/* Copyright (C) 2015 Atsushi Togo */\n/* All rights reserved. */\n\n/* This file is part of phonopy. */\n\n/* Redistribution and use in source and binary forms, with or without */\n/* modification, are permitted provided that the following conditions */\n/* are met: */\n\n/* * Redistributions of source code must retain the above copyright */\n/*   notice, this list of conditions and the following disclaimer. */\n\n/* * Redistributions in binary form must reproduce the above copyright */\n/*   notice, this list of conditions and the following disclaimer in */\n/*   the documentation and/or other materials provided with the */\n/*   distribution. */\n\n/* * Neither the name of the phonopy project nor the names of its */\n/*   contributors may be used to endorse or promote products derived */\n/*   from this software without specific prior written permission. */\n\n/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS */\n/* \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT */\n/* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS */\n/* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE */\n/* COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, */\n/* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, */\n/* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; */\n/* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER */\n/* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT */\n/* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN */\n/* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE */\n/* POSSIBILITY OF SUCH DAMAGE. */\n\n#include <Python.h>\n#include <stdio.h>\n#include <stdlib.h>\n#include <numpy/arrayobject.h>\n#include <lapacke.h>\n#include \"phonoc_array.h\"\n#include \"phonon4_h/fc4.h\"\n#include \"phonon4_h/real_to_reciprocal.h\"\n#include \"phonon4_h/frequency_shift.h\"\n\nstatic PyObject * py_get_fc4_normal_for_frequency_shift(PyObject *self, PyObject *args);\nstatic PyObject * py_get_fc4_frequency_shifts(PyObject *self, PyObject *args);\nstatic PyObject * py_real_to_reciprocal4(PyObject *self, PyObject *args);\nstatic PyObject * py_reciprocal_to_normal4(PyObject *self, PyObject *args);\nstatic PyObject * py_set_phonons_grid_points(PyObject *self, PyObject *args);\nstatic PyObject * py_distribute_fc4(PyObject *self, PyObject *args);\nstatic PyObject * py_rotate_delta_fc3s_elem(PyObject *self, PyObject *args);\nstatic PyObject * py_set_translational_invariance_fc4(PyObject *self,\n\t\t\t\t\t\t      PyObject *args);\nstatic PyObject * py_set_permutation_symmetry_fc4(PyObject *self,\n\t\t\t\t\t\t  PyObject *args);\nstatic PyObject * py_get_drift_fc4(PyObject *self, PyObject *args);\n\nstatic PyMethodDef functions[] = {\n  {\"fc4_normal_for_frequency_shift\", py_get_fc4_normal_for_frequency_shift, METH_VARARGS, \"Calculate fc4 normal for frequency shift\"},\n  {\"fc4_frequency_shifts\", py_get_fc4_frequency_shifts, METH_VARARGS, \"Calculate fc4 frequency shift\"},\n  {\"real_to_reciprocal4\", py_real_to_reciprocal4, METH_VARARGS, \"Transform fc4 of real space to reciprocal space\"},\n  {\"reciprocal_to_normal4\", py_reciprocal_to_normal4, METH_VARARGS, \"Transform fc4 of reciprocal space to normal coordinate in special case for frequency shift\"},\n  {\"phonons_grid_points\", py_set_phonons_grid_points, METH_VARARGS, \"Set phonons on grid points\"},\n  {\"distribute_fc4\", py_distribute_fc4, METH_VARARGS, \"Distribute least fc4 to full fc4\"},\n  {\"rotate_delta_fc3s_elem\", py_rotate_delta_fc3s_elem, METH_VARARGS, \"Rotate delta fc3s for a set of atomic indices\"},\n  {\"translational_invariance_fc4\", py_set_translational_invariance_fc4, METH_VARARGS, \"Set translational invariance for fc4\"},\n  {\"permutation_symmetry_fc4\", py_set_permutation_symmetry_fc4, METH_VARARGS, \"Set permutation symmetry for fc4\"},\n  {\"drift_fc4\", py_get_drift_fc4, METH_VARARGS, \"Get drifts of fc4\"},\n  {NULL, NULL, 0, NULL}\n};\n\nPyMODINIT_FUNC init_phono4py(void)\n{\n  Py_InitModule3(\"_phono4py\", functions, \"C-extension for phono4py\\n\\n...\\n\");\n  return;\n}\n\nstatic PyObject * py_get_fc4_normal_for_frequency_shift(PyObject *self,\n\t\t\t\t\t\t\tPyObject *args)\n{\n  PyArrayObject* fc4_normal_py;\n  PyArrayObject* frequencies_py;\n  PyArrayObject* eigenvectors_py;\n  PyArrayObject* grid_points1_py;\n  PyArrayObject* grid_address_py;\n  PyArrayObject* mesh_py;\n  PyArrayObject* fc4_py;\n  PyArrayObject* shortest_vectors_py;\n  PyArrayObject* multiplicity_py;\n  PyArrayObject* masses_py;\n  PyArrayObject* p2s_map_py;\n  PyArrayObject* s2p_map_py;\n  PyArrayObject* band_indicies_py;\n  double cutoff_frequency;\n  int grid_point0;\n\n  if (!PyArg_ParseTuple(args, \"OOOiOOOOOOOOOOd\",\n\t\t\t&fc4_normal_py,\n\t\t\t&frequencies_py,\n\t\t\t&eigenvectors_py,\n\t\t\t&grid_point0,\n\t\t\t&grid_points1_py,\n\t\t\t&grid_address_py,\n\t\t\t&mesh_py,\n\t\t\t&fc4_py,\n\t\t\t&shortest_vectors_py,\n\t\t\t&multiplicity_py,\n\t\t\t&masses_py,\n\t\t\t&p2s_map_py,\n\t\t\t&s2p_map_py,\n\t\t\t&band_indicies_py,\n\t\t\t&cutoff_frequency)) {\n    return NULL;\n  }\n\n  double* fc4_normal = (double*)fc4_normal_py->data;\n  double* freqs = (double*)frequencies_py->data;\n  /* npy_cdouble and lapack_complex_double may not be compatible. */\n  /* So eigenvectors should not be used in Python side */\n  lapack_complex_double* eigvecs =\n    (lapack_complex_double*)eigenvectors_py->data;\n  Iarray* grid_points1 = convert_to_iarray(grid_points1_py);\n  const int* grid_address = (int*)grid_address_py->data;\n  const int* mesh = (int*)mesh_py->data;\n  double* fc4 = (double*)fc4_py->data;\n  Darray* svecs = convert_to_darray(shortest_vectors_py);\n  Iarray* multi = convert_to_iarray(multiplicity_py);\n  const double* masses = (double*)masses_py->data;\n  const int* p2s = (int*)p2s_map_py->data;\n  const int* s2p = (int*)s2p_map_py->data;\n  Iarray* band_indicies = convert_to_iarray(band_indicies_py);\n\n  get_fc4_normal_for_frequency_shift(fc4_normal,\n\t\t\t\t     freqs,\n\t\t\t\t     eigvecs,\n\t\t\t\t     grid_point0,\n\t\t\t\t     grid_points1,\n\t\t\t\t     grid_address,\n\t\t\t\t     mesh,\n\t\t\t\t     fc4,\n\t\t\t\t     svecs,\n\t\t\t\t     multi,\n\t\t\t\t     masses,\n\t\t\t\t     p2s,\n\t\t\t\t     s2p,\n\t\t\t\t     band_indicies,\n\t\t\t\t     cutoff_frequency);\n\n  free(grid_points1);\n  free(svecs);\n  free(multi);\n  free(band_indicies);\n  \n  Py_RETURN_NONE;\n}\n\nstatic PyObject * py_get_fc4_frequency_shifts(PyObject *self, PyObject *args)\n{\n  PyArrayObject* frequency_shifts_py;\n  PyArrayObject* fc4_normal_py;\n  PyArrayObject* frequencies_py;\n  PyArrayObject* grid_points1_py;\n  PyArrayObject* temperatures_py;\n  PyArrayObject* band_indicies_py;\n  double unit_conversion_factor;\n\n  if (!PyArg_ParseTuple(args, \"OOOOOOd\",\n\t\t\t&frequency_shifts_py,\n\t\t\t&fc4_normal_py,\n\t\t\t&frequencies_py,\n\t\t\t&grid_points1_py,\n\t\t\t&temperatures_py,\n\t\t\t&band_indicies_py,\n\t\t\t&unit_conversion_factor)) {\n    return NULL;\n  }\n\n  double* freq_shifts = (double*)frequency_shifts_py->data;\n  double* fc4_normal = (double*)fc4_normal_py->data;\n  double* freqs = (double*)frequencies_py->data;\n  Iarray* grid_points1 = convert_to_iarray(grid_points1_py);\n  Darray* temperatures = convert_to_darray(temperatures_py);\n  int* band_indicies = (int*)band_indicies_py->data;\n  const int num_band0 = (int)band_indicies_py->dimensions[0];\n  const int num_band = (int)frequencies_py->dimensions[1];\n\n  get_fc4_frequency_shifts(freq_shifts,\n\t\t\t   fc4_normal,\n\t\t\t   freqs,\n\t\t\t   grid_points1,\n\t\t\t   temperatures,\n\t\t\t   band_indicies,\n\t\t\t   num_band0,\n\t\t\t   num_band,\n\t\t\t   unit_conversion_factor);\n\n  free(grid_points1);\n  free(temperatures);\n  \n  Py_RETURN_NONE;\n}\n\nstatic PyObject * py_real_to_reciprocal4(PyObject *self, PyObject *args)\n{\n  PyArrayObject* fc4_py;\n  PyArrayObject* fc4_reciprocal_py;\n  PyArrayObject* q_py;\n  PyArrayObject* shortest_vectors;\n  PyArrayObject* multiplicity;\n  PyArrayObject* p2s_map;\n  PyArrayObject* s2p_map;\n\n  if (!PyArg_ParseTuple(args, \"OOOOOOO\",\n\t\t\t&fc4_reciprocal_py,\n\t\t\t&fc4_py,\n\t\t\t&q_py,\n\t\t\t&shortest_vectors,\n\t\t\t&multiplicity,\n\t\t\t&p2s_map,\n\t\t\t&s2p_map)) {\n    return NULL;\n  }\n\n  double* fc4 = (double*)fc4_py->data;\n  lapack_complex_double* fc4_reciprocal =\n    (lapack_complex_double*)fc4_reciprocal_py->data;\n  Darray* svecs = convert_to_darray(shortest_vectors);\n  Iarray* multi = convert_to_iarray(multiplicity);\n  const int* p2s = (int*)p2s_map->data;\n  const int* s2p = (int*)s2p_map->data;\n  const double* q = (double*)q_py->data;\n\n  real_to_reciprocal4(fc4_reciprocal,\n\t\t      q,\n\t\t      fc4,\n\t\t      svecs,\n\t\t      multi,\n\t\t      p2s,\n\t\t      s2p);\n\n  free(svecs);\n  free(multi);\n  \n  Py_RETURN_NONE;\n}\n\nstatic PyObject * py_reciprocal_to_normal4(PyObject *self, PyObject *args)\n{\n  PyArrayObject* fc4_normal_py;\n  PyArrayObject* fc4_reciprocal_py;\n  PyArrayObject* frequencies_py;\n  PyArrayObject* eigenvectors_py;\n  PyArrayObject* grid_points_py;\n  PyArrayObject* masses_py;\n  PyArrayObject* band_indicies_py;\n  double cutoff_frequency;\n\n  if (!PyArg_ParseTuple(args, \"OOOOOOOd\",\n\t\t\t&fc4_normal_py,\n\t\t\t&fc4_reciprocal_py,\n\t\t\t&frequencies_py,\n\t\t\t&eigenvectors_py,\n\t\t\t&grid_points_py,\n\t\t\t&masses_py,\n\t\t\t&band_indicies_py,\n\t\t\t&cutoff_frequency)) {\n    return NULL;\n  }\n\n  lapack_complex_double* fc4_normal =\n    (lapack_complex_double*)fc4_normal_py->data;\n  const lapack_complex_double* fc4_reciprocal =\n    (lapack_complex_double*)fc4_reciprocal_py->data;\n  const lapack_complex_double* eigenvectors =\n    (lapack_complex_double*)eigenvectors_py->data;\n  const double* frequencies = (double*)frequencies_py->data;\n  const int* grid_points = (int*)grid_points_py->data;\n  const double* masses = (double*)masses_py->data;\n  const int* band_indices = (int*)band_indicies_py->data;\n  const int num_band0 = (int)band_indicies_py->dimensions[0];\n  const int num_band = (int)frequencies_py->dimensions[1];\n\n  reciprocal_to_normal4(fc4_normal,\n\t\t\tfc4_reciprocal,\n\t\t\tfrequencies + grid_points[0] * num_band,\n\t\t\tfrequencies + grid_points[1] * num_band,\n\t\t\teigenvectors + grid_points[0] * num_band * num_band,\n\t\t\teigenvectors + grid_points[1] * num_band * num_band,\n\t\t\tmasses,\n\t\t\tband_indices,\n\t\t\tnum_band0,\n\t\t\tnum_band,\n\t\t\tcutoff_frequency);\n\n  Py_RETURN_NONE;\n}\n\nstatic PyObject * py_set_phonons_grid_points(PyObject *self, PyObject *args)\n{\n  PyArrayObject* frequencies;\n  PyArrayObject* eigenvectors;\n  PyArrayObject* phonon_done_py;\n  PyArrayObject* grid_points_py;\n  PyArrayObject* grid_address_py;\n  PyArrayObject* mesh_py;\n  PyArrayObject* shortest_vectors_fc2;\n  PyArrayObject* multiplicity_fc2;\n  PyArrayObject* fc2_py;\n  PyArrayObject* atomic_masses_fc2;\n  PyArrayObject* p2s_map_fc2;\n  PyArrayObject* s2p_map_fc2;\n  PyArrayObject* reciprocal_lattice;\n  PyArrayObject* born_effective_charge;\n  PyArrayObject* q_direction;\n  PyArrayObject* dielectric_constant;\n  double nac_factor, unit_conversion_factor;\n  char uplo;\n\n  if (!PyArg_ParseTuple(args, \"OOOOOOOOOOOOdOOOOdc\",\n\t\t\t&frequencies,\n\t\t\t&eigenvectors,\n\t\t\t&phonon_done_py,\n\t\t\t&grid_points_py,\n\t\t\t&grid_address_py,\n\t\t\t&mesh_py,\n\t\t\t&fc2_py,\n\t\t\t&shortest_vectors_fc2,\n\t\t\t&multiplicity_fc2,\n\t\t\t&atomic_masses_fc2,\n\t\t\t&p2s_map_fc2,\n\t\t\t&s2p_map_fc2,\n\t\t\t&unit_conversion_factor,\n\t\t\t&born_effective_charge,\n\t\t\t&dielectric_constant,\n\t\t\t&reciprocal_lattice,\n\t\t\t&q_direction,\n\t\t\t&nac_factor,\n\t\t\t&uplo)) {\n    return NULL;\n  }\n\n  double* born;\n  double* dielectric;\n  double *q_dir;\n  Darray* freqs = convert_to_darray(frequencies);\n  /* npy_cdouble and lapack_complex_double may not be compatible. */\n  /* So eigenvectors should not be used in Python side */\n  Carray* eigvecs = convert_to_carray(eigenvectors);\n  char* phonon_done = (char*)phonon_done_py->data;\n  Iarray* grid_points = convert_to_iarray(grid_points_py);\n  const int* grid_address = (int*)grid_address_py->data;\n  const int* mesh = (int*)mesh_py->data;\n  Darray* fc2 = convert_to_darray(fc2_py);\n  Darray* svecs_fc2 = convert_to_darray(shortest_vectors_fc2);\n  Iarray* multi_fc2 = convert_to_iarray(multiplicity_fc2);\n  const double* masses_fc2 = (double*)atomic_masses_fc2->data;\n  const int* p2s_fc2 = (int*)p2s_map_fc2->data;\n  const int* s2p_fc2 = (int*)s2p_map_fc2->data;\n  const double* rec_lat = (double*)reciprocal_lattice->data;\n  if ((PyObject*)born_effective_charge == Py_None) {\n    born = NULL;\n  } else {\n    born = (double*)born_effective_charge->data;\n  }\n  if ((PyObject*)dielectric_constant == Py_None) {\n    dielectric = NULL;\n  } else {\n    dielectric = (double*)dielectric_constant->data;\n  }\n  if ((PyObject*)q_direction == Py_None) {\n    q_dir = NULL;\n  } else {\n    q_dir = (double*)q_direction->data;\n  }\n\n  set_phonons_for_frequency_shift(freqs,\n\t\t\t\t  eigvecs,\n\t\t\t\t  phonon_done,\n\t\t\t\t  grid_points,\n\t\t\t\t  grid_address,\n\t\t\t\t  mesh,\n\t\t\t\t  fc2,\n\t\t\t\t  svecs_fc2,\n\t\t\t\t  multi_fc2,\n\t\t\t\t  masses_fc2,\n\t\t\t\t  p2s_fc2,\n\t\t\t\t  s2p_fc2,\n\t\t\t\t  unit_conversion_factor,\n\t\t\t\t  born,\n\t\t\t\t  dielectric,\n\t\t\t\t  rec_lat,\n\t\t\t\t  q_dir,\n\t\t\t\t  nac_factor,\n\t\t\t\t  uplo);\n\n  free(freqs);\n  free(eigvecs);\n  free(grid_points);\n  free(fc2);\n  free(svecs_fc2);\n  free(multi_fc2);\n  \n  Py_RETURN_NONE;\n}\n\nstatic PyObject * py_distribute_fc4(PyObject *self, PyObject *args)\n{\n  PyArrayObject* fc4_copy_py;\n  PyArrayObject* fc4_py;\n  int fourth_atom;\n  PyArrayObject* rotation_cart_inv;\n  PyArrayObject* atom_mapping_py;\n\n  if (!PyArg_ParseTuple(args, \"OOiOO\",\n\t\t\t&fc4_copy_py,\n\t\t\t&fc4_py,\n\t\t\t&fourth_atom,\n\t\t\t&atom_mapping_py,\n\t\t\t&rotation_cart_inv)) {\n    return NULL;\n  }\n\n  double* fc4_copy = (double*)fc4_copy_py->data;\n  const double* fc4 = (double*)fc4_py->data;\n  const double* rot_cart_inv = (double*)rotation_cart_inv->data;\n  const int* atom_mapping = (int*)atom_mapping_py->data;\n  const int num_atom = (int)atom_mapping_py->dimensions[0];\n\n  return PyInt_FromLong((long) distribute_fc4(fc4_copy,\n\t\t\t\t\t      fc4,\n\t\t\t\t\t      fourth_atom,\n\t\t\t\t\t      atom_mapping,\n\t\t\t\t\t      num_atom,\n\t\t\t\t\t      rot_cart_inv));\n}\n\nstatic PyObject * py_rotate_delta_fc3s_elem(PyObject *self, PyObject *args)\n{\n  PyArrayObject* rotated_delta_fc3s_py;\n  PyArrayObject* delta_fc3s_py;\n  PyArrayObject* atom_mappings_of_rotations_py;\n  PyArrayObject* site_symmetries_cartesian_py;\n  int atom1, atom2, atom3;\n\n  if (!PyArg_ParseTuple(args, \"OOOOiii\",\n\t\t\t&rotated_delta_fc3s_py,\n\t\t\t&delta_fc3s_py,\n\t\t\t&atom_mappings_of_rotations_py,\n\t\t\t&site_symmetries_cartesian_py,\n\t\t\t&atom1,\n\t\t\t&atom2,\n\t\t\t&atom3)) {\n    return NULL;\n  }\n\n  double* rotated_delta_fc3s = (double*)rotated_delta_fc3s_py->data;\n  const double* delta_fc3s = (double*)delta_fc3s_py->data;\n  const int* rot_map_syms = (int*)atom_mappings_of_rotations_py->data;\n  const double* site_syms_cart = (double*)site_symmetries_cartesian_py->data;\n  const int num_rot = (int)site_symmetries_cartesian_py->dimensions[0];\n  const int num_delta_fc3s = (int)delta_fc3s_py->dimensions[0];\n  const int num_atom = (int)delta_fc3s_py->dimensions[1];\n\n  return PyInt_FromLong((long) rotate_delta_fc3s_elem(rotated_delta_fc3s,\n\t\t\t\t\t\t      delta_fc3s,\n\t\t\t\t\t\t      rot_map_syms,\n\t\t\t\t\t\t      site_syms_cart,\n\t\t\t\t\t\t      num_rot,\n\t\t\t\t\t\t      num_delta_fc3s,\n\t\t\t\t\t\t      atom1,\n\t\t\t\t\t\t      atom2,\n\t\t\t\t\t\t      atom3,\n\t\t\t\t\t\t      num_atom));\n}\n\nstatic PyObject * py_set_translational_invariance_fc4(PyObject *self,\n\t\t\t\t\t\t      PyObject *args)\n{\n  PyArrayObject* fc4_py;\n  int index;\n\n  if (!PyArg_ParseTuple(args, \"Oi\",\n\t\t\t&fc4_py,\n\t\t\t&index)) {\n    return NULL;\n  }\n\n  double* fc4 = (double*)fc4_py->data;\n  const int num_atom = (int)fc4_py->dimensions[0];\n\n  set_translational_invariance_fc4_per_index(fc4, num_atom, index);\n\n  Py_RETURN_NONE;\n}\n\nstatic PyObject * py_set_permutation_symmetry_fc4(PyObject *self, PyObject *args)\n{\n  PyArrayObject* fc4_py;\n\n  if (!PyArg_ParseTuple(args, \"O\",\n\t\t\t&fc4_py)) {\n    return NULL;\n  }\n\n  double* fc4 = (double*)fc4_py->data;\n  const int num_atom = (int)fc4_py->dimensions[0];\n\n  set_permutation_symmetry_fc4(fc4, num_atom);\n\n  Py_RETURN_NONE;\n}\n\nstatic PyObject * py_get_drift_fc4(PyObject *self, PyObject *args)\n{\n  PyArrayObject* fc4_py;\n\n  if (!PyArg_ParseTuple(args, \"O\",\n\t\t\t&fc4_py)) {\n    return NULL;\n  }\n\n  double* fc4 = (double*)fc4_py->data;\n  const int num_atom = (int)fc4_py->dimensions[0];\n\n  int i;\n  double drift[4];\n  PyObject* drift_py;\n\n  get_drift_fc4(drift, fc4, num_atom);\n  drift_py = PyList_New(4);\n\n  for (i = 0; i < 4; i++) {\n    PyList_SetItem(drift_py, i, PyFloat_FromDouble(drift[i]));\n  }\n\n  return drift_py;\n}\n", "meta": {"hexsha": "1a3f7eaeaa44bc9b4d844e47b0034ccc7fc0c9e9", "size": 16172, "ext": "c", "lang": "C", "max_stars_repo_path": "c/_phono4py.c", "max_stars_repo_name": "atztogo/forcefit", "max_stars_repo_head_hexsha": "faa1aea23a31faa3d642b99c51ebb8756e53c934", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-07-20T23:19:49.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-20T23:19:49.000Z", "max_issues_repo_path": "c/_phono4py.c", "max_issues_repo_name": "atztogo/forcefit", "max_issues_repo_head_hexsha": "faa1aea23a31faa3d642b99c51ebb8756e53c934", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "c/_phono4py.c", "max_forks_repo_name": "atztogo/forcefit", "max_forks_repo_head_hexsha": "faa1aea23a31faa3d642b99c51ebb8756e53c934", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2018-08-02T13:53:25.000Z", "max_forks_repo_forks_event_max_datetime": "2019-01-30T08:36:46.000Z", "avg_line_length": 30.0594795539, "max_line_length": 162, "alphanum_fraction": 0.7237818452, "num_tokens": 4654, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.41111086923216805, "lm_q2_score": 0.02887090537957738, "lm_q1q2_score": 0.011869143006117733}}
{"text": "/* multimin/fminimizer.c\n * \n * Copyright (C) 2002 Tuomo Keskitalo, Ivo Alxneit\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include <config.h>\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_multimin.h>\n\ngsl_multimin_fminimizer *\ngsl_multimin_fminimizer_alloc (const gsl_multimin_fminimizer_type * T,\n                               size_t n)\n{\n  int status;\n\n  gsl_multimin_fminimizer *s =\n    (gsl_multimin_fminimizer *) malloc (sizeof (gsl_multimin_fminimizer));\n\n  if (s == 0)\n    {\n      GSL_ERROR_VAL (\"failed to allocate space for minimizer struct\",\n                     GSL_ENOMEM, 0);\n    }\n\n  s->type = T;\n\n  s->x = gsl_vector_calloc (n);\n\n  if (s->x == 0) \n    {\n      free (s);\n      GSL_ERROR_VAL (\"failed to allocate space for x\", GSL_ENOMEM, 0);\n    }\n\n  s->state = malloc (T->size);\n\n  if (s->state == 0)\n    {\n      gsl_vector_free (s->x);\n      free (s);\n      GSL_ERROR_VAL (\"failed to allocate space for minimizer state\",\n                     GSL_ENOMEM, 0);\n    }\n\n  status = (T->alloc) (s->state, n);\n\n  if (status != GSL_SUCCESS)\n    {\n      free (s->state);\n      gsl_vector_free (s->x);\n      free (s);\n\n      GSL_ERROR_VAL (\"failed to initialize minimizer state\", GSL_ENOMEM, 0);\n    }\n\n  return s;\n}\n\nint\ngsl_multimin_fminimizer_set (gsl_multimin_fminimizer * s,\n                             gsl_multimin_function * f,\n                             const gsl_vector * x,\n                             const gsl_vector * step_size)\n{\n  if (s->x->size != f->n)\n    {\n      GSL_ERROR (\"function incompatible with solver size\", GSL_EBADLEN);\n    }\n  \n  if (x->size != f->n || step_size->size != f->n) \n    {\n      GSL_ERROR (\"vector length not compatible with function\", GSL_EBADLEN);\n    }  \n    \n  s->f = f;\n\n  gsl_vector_memcpy (s->x,x);\n\n  return (s->type->set) (s->state, s->f, s->x, &(s->size), step_size);\n}\n\nvoid\ngsl_multimin_fminimizer_free (gsl_multimin_fminimizer * s)\n{\n  (s->type->free) (s->state);\n  free (s->state);\n  gsl_vector_free (s->x);\n  free (s);\n}\n\nint\ngsl_multimin_fminimizer_iterate (gsl_multimin_fminimizer * s)\n{\n  return (s->type->iterate) (s->state, s->f, s->x, &(s->size), &(s->fval));\n}\n\nconst char * \ngsl_multimin_fminimizer_name (const gsl_multimin_fminimizer * s)\n{\n  return s->type->name;\n}\n\n\ngsl_vector * \ngsl_multimin_fminimizer_x (const gsl_multimin_fminimizer * s)\n{\n  return s->x;\n}\n\ndouble \ngsl_multimin_fminimizer_minimum (const gsl_multimin_fminimizer * s)\n{\n  return s->fval;\n}\n\ndouble\ngsl_multimin_fminimizer_size (const gsl_multimin_fminimizer * s)\n{\n  return s->size;\n}\n", "meta": {"hexsha": "507dfd4efca87f52f577b64b44c8a186985def7c", "size": 3220, "ext": "c", "lang": "C", "max_stars_repo_path": "pkgs/libs/gsl/src/multimin/fminimizer.c", "max_stars_repo_name": "manggoguy/parsec-modified", "max_stars_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 64.0, "max_stars_repo_stars_event_min_datetime": "2015-03-06T00:30:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T13:26:53.000Z", "max_issues_repo_path": "pkgs/libs/gsl/src/multimin/fminimizer.c", "max_issues_repo_name": "manggoguy/parsec-modified", "max_issues_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2020-12-15T08:30:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-13T03:54:24.000Z", "max_forks_repo_path": "pkgs/libs/gsl/src/multimin/fminimizer.c", "max_forks_repo_name": "manggoguy/parsec-modified", "max_forks_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 40.0, "max_forks_repo_forks_event_min_datetime": "2015-02-26T15:31:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T23:23:37.000Z", "avg_line_length": 23.8518518519, "max_line_length": 81, "alphanum_fraction": 0.6400621118, "num_tokens": 924, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3522017684487511, "lm_q2_score": 0.033589503957117864, "lm_q1q2_score": 0.011830282695013235}}
{"text": "/*\n** read data matrix, map of voxel addresses\n**\n** G.Lohmann, Jan 2013\n*/\n#include <stdio.h>\n#include <stdlib.h>\n#include <math.h>\n#include <string.h>\n\n#include <gsl/gsl_matrix.h>\n#include <gsl/gsl_vector.h>\n#include <gsl/gsl_blas.h>\n#include <gsl/gsl_sort.h>\n\n#include \"viaio/Vlib.h\"\n#include \"viaio/VImage.h\"\n#include \"viaio/mu.h\"\n\n#define SQR(x) ((x) * (x))\n#define ABS(x) ((x) > 0 ? (x) : -(x))\n\n\nVImage *VImagePointer(VAttrList list,int *nt)\n{\n  VImage tmp;\n  VAttrListPosn posn;\n  int i,ntimesteps,nrows,ncols,nslices;\n \n  /* get image dimensions, read functional data */\n  nslices = 0;\n  for (VFirstAttr (list, & posn); VAttrExists (& posn); VNextAttr (& posn)) {\n    if (VGetAttrRepn (& posn) != VImageRepn) continue;\n    VGetAttrValue (& posn, NULL,VImageRepn, & tmp);\n    if (VPixelRepn(tmp) != VShortRepn) continue;\n    nslices++;\n  }\n  /* VDestroyImage(tmp); */\n  if (nslices < 1) VError(\" no slices\");\n\n  VImage *src = (VImage *) VCalloc(nslices,sizeof(VImage));\n  i = ntimesteps = nrows = ncols = 0;\n  for (VFirstAttr (list, & posn); VAttrExists (& posn); VNextAttr (& posn)) {\n    if (VGetAttrRepn (& posn) != VImageRepn) continue;\n    VGetAttrValue (& posn, NULL,VImageRepn, & src[i]);\n    if (VPixelRepn(src[i]) != VShortRepn) continue;\n    if (VImageNBands(src[i]) > ntimesteps) ntimesteps = VImageNBands(src[i]);\n    if (VImageNRows(src[i])  > nrows)  nrows = VImageNRows(src[i]);\n    if (VImageNColumns(src[i]) > ncols) ncols = VImageNColumns(src[i]);\n    i++;\n  }\n  nslices = i;\n  if (nslices < 1) return NULL;\n  if (ntimesteps < 2) return NULL;\n  *nt = ntimesteps;\n  return src;\n}\n\n\n/* read functional data */\nvoid VReadImagePointer(VAttrList list,VImage *src)\n{\n  VAttrListPosn posn;\n \n  int i = 0;\n  for (VFirstAttr (list, & posn); VAttrExists (& posn); VNextAttr (& posn)) {\n    if (VGetAttrRepn (& posn) != VImageRepn) continue;\n    VGetAttrValue (& posn, NULL,VImageRepn, & src[i]);\n    if (VPixelRepn(src[i]) != VShortRepn) continue;\n    i++;\n  }\n}\n\n/* check if mask covers data. If not, set surplus voxels to zero */\nlong VMaskCoverage(VAttrList list,VImage mask)\n{\n  VImage src=NULL;\n  VAttrListPosn posn;\n  int b,r,c;\n  long count=0;\n\n  b = 0; \n  for (VFirstAttr (list, & posn); VAttrExists (& posn); VNextAttr (& posn)) {\n    if (VGetAttrRepn (& posn) != VImageRepn) continue;\n    VGetAttrValue (& posn, NULL,VImageRepn, & src);\n    if (VPixelRepn(src) != VShortRepn) continue;\n    if (VImageNRows(src) < 3) continue;\n\n    if (VImageNRows(src) != VImageNRows(mask)) \n      VError(\" inconsistent nrows: %d,  mask: %d\",VImageNRows(src),VImageNRows(mask));\n    if (VImageNColumns(src) != VImageNColumns(mask)) \n      VError(\" inconsistent ncols: %d,  mask: %d\",VImageNColumns(src),VImageNColumns(mask));\n\n    for (r=0; r<VImageNRows(src); r++) {\n      for (c=0; c<VImageNColumns(src); c++) {\n\tif (b >= VImageNBands(mask)) VError(\"VMaskCoverage, illegal addr, band= %d\",b);\n\tfloat u = VGetPixel(mask,b,r,c);\n\tint j = (int)VPixel(src,0,r,c,VShort);\n\tif (j == 0 && u > 0.3) {\n\t  VSetPixel(mask,b,r,c,0);\n\t  count++;\n\t}\n      }\n    }\n    b++;\n  }\n  return count;\n}\n\n\n/* check if data matrix contains zero voxels */\nvoid VCheckMatrix(gsl_matrix_float *X)\n{\n  long i,j,nvox=X->size1,nt=X->size2;\n  double sum1,sum2,nx,mean,var,tiny=1.0e-4;\n\n  long count = 0;\n  nx = (double)nt;\n  for (i=0; i<nvox; i++) {\n    const float *arr1 = gsl_matrix_float_const_ptr(X,i,0);\n    sum1 = sum2 = 0;\n    for (j=0; j<nt; j++) {\n      const double u = (double)arr1[j];\n      sum1 += u;\n      sum2 += u*u;\n    }\n    mean = sum1/nx;\n    var = (sum2 - nx * mean * mean) / (nx - 1.0);\n    if (var < tiny) count++;\n  }\n  if (count > 0)\n    VWarning(\" number of empty voxels: %ld\",count);\n}\n\n\nVImage VoxelMap(VImage mask,size_t *nvoxels)\n{\n  int b,r,c;\n  int nslices = VImageNBands(mask);\n  int nrows = VImageNRows(mask);\n  int ncols = VImageNColumns(mask);\n\n  /* count number of non-zero voxels */\n  size_t nvox = 0;  \n  for (b=0; b<nslices; b++) {\n    for (r=0; r<nrows; r++) {\n      for (c=0; c<ncols; c++) {\n\tfloat u = VGetPixel(mask,b,r,c);\n\tif (ABS(u) < 0.5) continue;\n\tnvox++;\n      }\n    }\n  }\n  (*nvoxels) = nvox;\n\n  /* voxel addresses */\n  VImage map = VCreateImage(1,4,nvox,VShortRepn);\n  if (map == NULL) VError(\" error allocating addr map\");\n  VFillImage(map,VAllBands,0);\n  VImage xmap=NULL;\n  VExtractAttr (VImageAttrList(mask),\"map\",NULL,VImageRepn,&xmap,FALSE);\n  VCopyImageAttrs (mask,map);\n  VSetAttr(VImageAttrList(map),\"nvoxels\",NULL,VLongRepn,(VLong)nvox);\n  VSetAttr(VImageAttrList(map),\"nslices\",NULL,VLongRepn,(VLong)nslices);\n  VSetAttr(VImageAttrList(map),\"nrows\",NULL,VLongRepn,(VLong)nrows);\n  VSetAttr(VImageAttrList(map),\"ncols\",NULL,VLongRepn,(VLong)ncols);\n\n  VPixel(map,0,3,0,VShort) = nslices;\n  VPixel(map,0,3,1,VShort) = nrows;\n  VPixel(map,0,3,2,VShort) = ncols;\n\n  size_t i = 0;\n  for (b=0; b<nslices; b++) {\n    for (r=0; r<nrows; r++) {\n      for (c=0; c<ncols; c++) {\n\tfloat u = VGetPixel(mask,b,r,c);\n\tif (ABS(u) < 0.5) continue;\n\tVPixel(map,0,0,i,VShort) = b;\n\tVPixel(map,0,1,i,VShort) = r;\n\tVPixel(map,0,2,i,VShort) = c;\n\ti++;\n      }\n    }\n  }\n  return map;\n}\n\n/* two-pass formula, correct for round-off error */\nvoid VNormalize(float *data,int nt,VBoolean stddev)\n{\n  int j;\n  float ave,var,sd,nx,s,u,tiny=1.0e-6;\n\n  nx = (float)nt;\n  ave = 0;\n  for (j=0; j<nt; j++) ave += data[j];\n  ave /= nx;\n\n  var = u = 0;\n  for (j=0; j<nt; j++) {\n    s = data[j]-ave;\n    u   += s;\n    var += s*s;\n  }\n  var=(var-u*u/nx)/(nx-1);\n  sd = sqrt(var);\n  if (sd < tiny) {\n    for (j=0; j<nt; j++) data[j] = 0;\n  }\n  else {\n    if (stddev==FALSE) sd = 1.0;  /* only subtract mean !!!! */\n    for (j=0; j<nt; j++) {\n      u = data[j];\n      data[j] = (u-ave)/sd;\n    }\n  }\n}\n\n\n/*  copy data to input matrix X, contains fMRI time series */\nvoid VDataMatrix(VImage *src,int first,int len,VImage map,gsl_matrix_float *X)\n{\n  long i,j,k,nvox;\n  int b,r,c;\n  float *data=NULL;\n\n  data = (float *) VCalloc(len,sizeof(float));\n\n  gsl_matrix_float_set_zero (X);\n  nvox = VImageNColumns(map);\n  if (nvox != (long)X->size1) VError(\" err, %ld %ld\",(long)X->size1,nvox);\n  if (len  != (long)X->size2) VError(\" err, %ld %ld\",(long)X->size2,len);\n\n  for (i=0; i<nvox; i++) {\n    \n    b = VPixel(map,0,0,i,VShort);\n    r = VPixel(map,0,1,i,VShort);\n    c = VPixel(map,0,2,i,VShort);\n\n    if ((first+len) > VImageNBands(src[b])) VError(\" illegal len addr, %d  %d %d %d\",\n\t\t\t\t\t\t   b,first,len,VImageNBands(src[b]));\n    if (r >= VImageNRows(src[b])) VError(\" illegal row addr\");\n    if (c >= VImageNColumns(src[b])) VError(\" illegal column addr\");\n\n    k = 0;\n    for (j=first; j<first+len; j++) {\n      data[k] = (float) VGetPixel(src[b],j,r,c);\n      k++;\n    }\n    VNormalize(data,len,TRUE);\n\n    float *ptr = gsl_matrix_float_ptr(X,i,0);\n    for (j=0; j<len; j++) *ptr++ = data[j];\n  }\n  VFree(data);\n}\n\n", "meta": {"hexsha": "e41fca749e7984b1fcc820df5a3a467b1eefc777", "size": 6822, "ext": "c", "lang": "C", "max_stars_repo_path": "src/ted/vted/VoxelMap.c", "max_stars_repo_name": "zrajna/lipsia", "max_stars_repo_head_hexsha": "8e7252653bd641df8f8d22ca5a9820507f154014", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 17.0, "max_stars_repo_stars_event_min_datetime": "2017-04-10T16:33:42.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T10:55:03.000Z", "max_issues_repo_path": "src/ted/vted/VoxelMap.c", "max_issues_repo_name": "zrajna/lipsia", "max_issues_repo_head_hexsha": "8e7252653bd641df8f8d22ca5a9820507f154014", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 7.0, "max_issues_repo_issues_event_min_datetime": "2019-11-12T15:47:56.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-16T13:42:05.000Z", "max_forks_repo_path": "src/ted/vted/VoxelMap.c", "max_forks_repo_name": "zrajna/lipsia", "max_forks_repo_head_hexsha": "8e7252653bd641df8f8d22ca5a9820507f154014", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 8.0, "max_forks_repo_forks_event_min_datetime": "2017-09-29T10:33:53.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-22T08:05:46.000Z", "avg_line_length": 26.4418604651, "max_line_length": 92, "alphanum_fraction": 0.6030489592, "num_tokens": 2436, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3775406828054583, "lm_q2_score": 0.031143829972745923, "lm_q1q2_score": 0.011758062833087595}}
{"text": "/* monte/gsl_monte_miser.h\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Michael Booth\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Author: MJB */\n\n#ifndef __GSL_MONTE_MISER_H__\n#define __GSL_MONTE_MISER_H__\n\n#include <gsl/gsl_rng.h>\n#include <gsl/gsl_monte.h>\n#include <gsl/gsl_monte_plain.h>\n\n#undef __BEGIN_DECLS\n#undef __END_DECLS\n#ifdef __cplusplus\n# define __BEGIN_DECLS extern \"C\" {\n# define __END_DECLS }\n#else\n# define __BEGIN_DECLS /* empty */\n# define __END_DECLS /* empty */\n#endif\n\n__BEGIN_DECLS\n\ntypedef struct {\n  size_t min_calls;\n  size_t min_calls_per_bisection;\n  double dither;\n  double estimate_frac;\n  double alpha;\n  size_t dim;\n  int estimate_style;\n  int depth;\n  int verbose;\n  double * x;\n  double * xmid;\n  double * sigma_l;\n  double * sigma_r;\n  double * fmax_l;\n  double * fmax_r;\n  double * fmin_l;\n  double * fmin_r;\n  double * fsum_l;\n  double * fsum_r;\n  double * fsum2_l;\n  double * fsum2_r;\n  size_t * hits_l;\n  size_t * hits_r;\n} gsl_monte_miser_state; \n\nint gsl_monte_miser_integrate(gsl_monte_function * f, \n                              const double xl[], const double xh[], \n                              size_t dim, size_t calls, \n                              gsl_rng *r, \n                              gsl_monte_miser_state* state,\n                              double *result, double *abserr);\n\ngsl_monte_miser_state* gsl_monte_miser_alloc(size_t dim);\n\nint gsl_monte_miser_init(gsl_monte_miser_state* state);\n\nvoid gsl_monte_miser_free(gsl_monte_miser_state* state);\n\n\n__END_DECLS\n\n#endif /* __GSL_MONTE_MISER_H__ */\n", "meta": {"hexsha": "d08cb8c8a883e746a9dfdee8ca759cfa5b56b145", "size": 2254, "ext": "h", "lang": "C", "max_stars_repo_path": "pkgs/libs/gsl/src/monte/gsl_monte_miser.h", "max_stars_repo_name": "manggoguy/parsec-modified", "max_stars_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 64.0, "max_stars_repo_stars_event_min_datetime": "2015-03-06T00:30:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T13:26:53.000Z", "max_issues_repo_path": "pkgs/libs/gsl/src/monte/gsl_monte_miser.h", "max_issues_repo_name": "manggoguy/parsec-modified", "max_issues_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2020-12-15T08:30:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-13T03:54:24.000Z", "max_forks_repo_path": "pkgs/libs/gsl/src/monte/gsl_monte_miser.h", "max_forks_repo_name": "manggoguy/parsec-modified", "max_forks_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 40.0, "max_forks_repo_forks_event_min_datetime": "2015-02-26T15:31:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T23:23:37.000Z", "avg_line_length": 26.8333333333, "max_line_length": 81, "alphanum_fraction": 0.6925465839, "num_tokens": 608, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3629692055196168, "lm_q2_score": 0.03210070463358554, "lm_q1q2_score": 0.011651567257472425}}
{"text": "/* Copyright 2013 Perttu Luukko\n\n * This file is part of libeemd.\n\n * libeemd is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n\n * libeemd is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n * GNU General Public License for more details.\n\n * You should have received a copy of the GNU General Public License\n * along with libeemd.  If not, see <http://www.gnu.org/licenses/>.\n */\n\n#ifndef _EEMD_H_\n#define _EEMD_H_\n\n#ifndef EEMD_DEBUG\n#define EEMD_DEBUG 0\n#endif\n\n#if EEMD_DEBUG == 0\n#ifndef NDEBUG\n#define NDEBUG\n#endif\n#endif\n\n#include <assert.h>\n#include <limits.h>\n#include <string.h>\n#include <math.h>\n#include <stdbool.h>\n#include <gsl/gsl_statistics_double.h>\n#include <gsl/gsl_rng.h>\n#include <gsl/gsl_randist.h>\n#include <gsl/gsl_vector.h>\n#include <gsl/gsl_linalg.h>\n#include <gsl/gsl_poly.h>\n\n#ifdef _OPENMP\n#include <omp.h>\n#endif\n\n// Possible error codes returned by functions eemd, ceemdan and\n// emd_evaluate_spline\ntypedef enum {\n\tEMD_SUCCESS = 0,\n\t// Errors from invalid parameters\n\tEMD_INVALID_ENSEMBLE_SIZE = 1,\n\tEMD_INVALID_NOISE_STRENGTH = 2,\n\tEMD_NOISE_ADDED_TO_EMD = 3,\n\tEMD_NO_NOISE_ADDED_TO_EEMD = 4,\n\tEMD_NO_CONVERGENCE_POSSIBLE = 5,\n\tEMD_NOT_ENOUGH_POINTS_FOR_SPLINE = 6,\n\tEMD_INVALID_SPLINE_POINTS = 7,\n\t// Other errors\n\tEMD_GSL_ERROR = 8\n} libeemd_error_code;\n\n// Helper functions to print an error message if an error occured\nvoid emd_report_if_error(libeemd_error_code err);\nvoid emd_report_to_file_if_error(FILE* file, libeemd_error_code err);\n\n// Main EEMD decomposition routine as described in:\n//   Z. Wu and N. Huang,\n//   Ensemble Empirical Mode Decomposition: A Noise-Assisted Data Analysis\n//   Method, Advances in Adaptive Data Analysis,\n//   Vol. 1, No. 1 (2009) 1–41\n//\n// Parameters 'input' and 'N' denote the input data and its length,\n// respectively. Output from the routine is written to array 'output', which\n// needs to be able to store at least N*M doubles, where M is the number of\n// Intrinsic Mode Functions (IMFs) to compute. If M is set to zero, a value of\n// M = emd_num_imfs(N) will be used, which corresponds to a maximal number of\n// IMFs. Note that the final residual is also counted as an IMF in this\n// respect, so you most likely want at least num_imfs=2. The following\n// parameters are the ensemble size and the relative noise standard deviation,\n// respectively. These are followed by the parameters for the stopping\n// criterion. The stopping parameter can be defined by a S-number (see the\n// article for details) or a fixed number of siftings. If both are specified,\n// the sifting ends when either criterion is fulfilled. The final parameter is\n// the seed given to the random number generator. A value of zero denotes a\n// RNG-specific default value.\nlibeemd_error_code eemd(double const* restrict input, size_t N,\n\t\tdouble* restrict output, size_t M,\n\t\tunsigned int ensemble_size, double noise_strength, unsigned int\n\t\tS_number, unsigned int num_siftings, unsigned long int rng_seed);\n\n// A complete variant of EEMD as described in:\n//   M. Torres et al,\n//   A Complete Ensemble Empirical Mode Decomposition with Adaptive Noise\n//   IEEE Int. Conf. on Acoust., Speech and Signal Proc. ICASSP-11,\n//   (2011) 4144-4147\n//\n// Parameters are identical to routine eemd\nlibeemd_error_code ceemdan(double const* restrict input, size_t N,\n\t\tdouble* restrict output, size_t M,\n\t\tunsigned int ensemble_size, double noise_strength, unsigned int\n\t\tS_number, unsigned int num_siftings, unsigned long int rng_seed);\n\n// A method for finding the local minima and maxima from input data specified\n// with parameters x and N. The memory for storing the coordinates of the\n// extrema and their number are passed as the rest of the parameters. The\n// arrays for the coordinates must be at least size N. The method also counts\n// the number of zero crossings in the data, and saves the results into the\n// pointer given as num_zero_crossings_ptr.\nvoid emd_find_extrema(double const* restrict x, size_t N,\n\t\tdouble* restrict maxx, double* restrict maxy, size_t* num_max_ptr,\n\t\tdouble* restrict minx, double* restrict miny, size_t* num_min_ptr,\n\t\tsize_t* num_zero_crossings_ptr);\n\n// Return the number of IMFs that can be extracted from input data of length N,\n// including the final residual.\nsize_t emd_num_imfs(size_t N);\n\n// This routine evaluates a cubic spline with nodes defined by the arrays x and\n// y, each of length N. The spline is evaluated using the not-a-node end point\n// conditions (same as Matlab). The y values of the spline curve will be\n// evaluated at integer points from 0 to x[N-1], and these y values will be\n// written to the array spline_y. The endpoint x[N-1] is assumed to be an\n// integer, and the x values are assumed to be in ascending order, with x[0]\n// equal to 0. The workspace required is 5*N-10 doubles, except that N==2\n// requires no extra memory. For N<=3 the routine falls back to polynomial\n// interpolation, same as Matlab.\n//\n// This routine is mainly exported so that it can be tested separately to\n// produce identical results to the Matlab routine 'spline'.\nlibeemd_error_code emd_evaluate_spline(double const* restrict x, double const* restrict y,\n\t\tsize_t N, double* restrict spline_y, double* spline_workspace);\n\n#endif // _EEMD_H_\n", "meta": {"hexsha": "303b9bfc6bbcd23bdb601ce2d4fca467a1c4205f", "size": 5553, "ext": "h", "lang": "C", "max_stars_repo_path": "ni/src/lib/nfp/eemd.h", "max_stars_repo_name": "tenomoto/ncl", "max_stars_repo_head_hexsha": "a87114a689a1566e9aa03d85bcf6dc7325b47633", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 210.0, "max_stars_repo_stars_event_min_datetime": "2016-11-24T09:05:08.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T19:15:32.000Z", "max_issues_repo_path": "ni/src/lib/nfp/eemd.h", "max_issues_repo_name": "tenomoto/ncl", "max_issues_repo_head_hexsha": "a87114a689a1566e9aa03d85bcf6dc7325b47633", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 156.0, "max_issues_repo_issues_event_min_datetime": "2017-09-22T09:56:48.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T07:02:21.000Z", "max_forks_repo_path": "ni/src/lib/nfp/eemd.h", "max_forks_repo_name": "tenomoto/ncl", "max_forks_repo_head_hexsha": "a87114a689a1566e9aa03d85bcf6dc7325b47633", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 58.0, "max_forks_repo_forks_event_min_datetime": "2016-12-14T00:15:22.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-15T09:13:00.000Z", "avg_line_length": 40.8308823529, "max_line_length": 90, "alphanum_fraction": 0.7612101567, "num_tokens": 1440, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.399811640739795, "lm_q2_score": 0.028870906215156315, "lm_q1q2_score": 0.011542924383526392}}
{"text": "#include <qdm.h>\n\n#include <gsl/gsl_math.h>\n#include <gsl/gsl_randist.h>\n#include <hdf5.h>\n#include <hdf5_hl.h>\n\nstatic\nvoid\nqdm_mcmc_workspace_init(\n    qdm_mcmc *mcmc\n)\n{\n  mcmc->w.xi      = gsl_vector_calloc(mcmc->p.xi->size);\n  mcmc->w.xi_acc  = gsl_vector_calloc(mcmc->p.xi->size);\n  mcmc->w.xi_p    = gsl_vector_calloc(mcmc->p.xi->size);\n  mcmc->w.xi_tune = gsl_vector_calloc(mcmc->p.xi->size);\n\n  gsl_vector_memcpy(mcmc->w.xi,   mcmc->p.xi);\n  gsl_vector_memcpy(mcmc->w.xi_p, mcmc->p.xi);\n\n  gsl_vector_set_all(mcmc->w.xi_tune, mcmc->p.xi_tune_sd);\n\n  mcmc->w.ll   = gsl_vector_calloc(mcmc->p.ll->size);\n  mcmc->w.ll_p = gsl_vector_calloc(mcmc->p.ll->size);\n\n  gsl_vector_memcpy(mcmc->w.ll,   mcmc->p.ll);\n  gsl_vector_memcpy(mcmc->w.ll_p, mcmc->p.ll);\n\n  mcmc->w.tau   = gsl_vector_calloc(mcmc->p.tau->size);\n  mcmc->w.tau_p = gsl_vector_calloc(mcmc->p.tau->size);\n\n  gsl_vector_memcpy(mcmc->w.tau,   mcmc->p.tau);\n  gsl_vector_memcpy(mcmc->w.tau_p, mcmc->p.tau);\n\n  mcmc->w.theta        = gsl_matrix_calloc(mcmc->p.theta->size1, mcmc->p.theta->size2);\n  mcmc->w.theta_acc    = gsl_matrix_calloc(mcmc->p.theta->size1, mcmc->p.theta->size2);\n  mcmc->w.theta_p      = gsl_matrix_calloc(mcmc->p.theta->size1, mcmc->p.theta->size2);\n  mcmc->w.theta_star   = gsl_matrix_calloc(mcmc->p.theta->size1, mcmc->p.theta->size2);\n  mcmc->w.theta_star_p = gsl_matrix_calloc(mcmc->p.theta->size1, mcmc->p.theta->size2);\n  mcmc->w.theta_tune   = gsl_matrix_calloc(mcmc->p.theta->size1, mcmc->p.theta->size2);\n\n  gsl_matrix_memcpy(mcmc->w.theta,      mcmc->p.theta);\n  gsl_matrix_memcpy(mcmc->w.theta_star, mcmc->p.theta);\n\n  gsl_matrix_set_all(mcmc->w.theta_tune, mcmc->p.theta_tune_sd);\n}\n\nstatic\nvoid\nqdm_mcmc_workspace_fini(\n    qdm_mcmc *mcmc\n)\n{\n  gsl_vector_free(mcmc->w.xi);\n  gsl_vector_free(mcmc->w.xi_acc);\n  gsl_vector_free(mcmc->w.xi_p);\n  gsl_vector_free(mcmc->w.xi_tune);\n\n  gsl_vector_free(mcmc->w.ll);\n  gsl_vector_free(mcmc->w.ll_p);\n\n  gsl_vector_free(mcmc->w.tau);\n  gsl_vector_free(mcmc->w.tau_p);\n\n  gsl_matrix_free(mcmc->w.theta);\n  gsl_matrix_free(mcmc->w.theta_acc);\n  gsl_matrix_free(mcmc->w.theta_p);\n  gsl_matrix_free(mcmc->w.theta_star);\n  gsl_matrix_free(mcmc->w.theta_star_p);\n  gsl_matrix_free(mcmc->w.theta_tune);\n\n  mcmc->w.xi      = NULL;\n  mcmc->w.xi_acc  = NULL;\n  mcmc->w.xi_p    = NULL;\n  mcmc->w.xi_tune = NULL;\n\n  mcmc->w.ll   = NULL;\n  mcmc->w.ll_p = NULL;\n\n  mcmc->w.tau   = NULL;\n  mcmc->w.tau_p = NULL;\n\n  mcmc->w.theta        = NULL;\n  mcmc->w.theta_acc    = NULL;\n  mcmc->w.theta_p      = NULL;\n  mcmc->w.theta_star   = NULL;\n  mcmc->w.theta_star_p = NULL;\n  mcmc->w.theta_tune   = NULL;\n}\n\nstatic\nvoid\nqdm_mcmc_results_init(\n    qdm_mcmc *mcmc\n)\n{\n  mcmc->r.s = mcmc->p.iter / mcmc->p.thin;\n\n  mcmc->r.theta      = qdm_ijk_calloc(mcmc->p.theta->size1, mcmc->p.theta->size2, mcmc->r.s);\n  mcmc->r.theta_star = qdm_ijk_calloc(mcmc->p.theta->size1, mcmc->p.theta->size2, mcmc->r.s);\n\n  mcmc->r.ll  = qdm_ijk_calloc(1, mcmc->p.ll->size, mcmc->r.s);\n  mcmc->r.tau = qdm_ijk_calloc(1, mcmc->p.tau->size, mcmc->r.s);\n\n  mcmc->r.xi = qdm_ijk_calloc(1, mcmc->p.xi->size, mcmc->r.s);\n}\n\nstatic\nvoid\nqdm_mcmc_results_fini(\n    qdm_mcmc *mcmc\n)\n{\n  qdm_ijk_free(mcmc->r.theta);\n  qdm_ijk_free(mcmc->r.theta_star);\n\n  qdm_ijk_free(mcmc->r.ll);\n  qdm_ijk_free(mcmc->r.tau);\n\n  qdm_ijk_free(mcmc->r.xi);\n\n  mcmc->r.theta      = NULL;\n  mcmc->r.theta_star = NULL;\n\n  mcmc->r.ll  = NULL;\n  mcmc->r.tau = NULL;\n\n  mcmc->r.xi = NULL;\n}\n\nqdm_mcmc *\nqdm_mcmc_alloc(\n    qdm_mcmc_parameters p\n)\n{\n  qdm_mcmc *mcmc = malloc(sizeof(qdm_mcmc));\n\n  mcmc->p = p;\n\n  qdm_mcmc_workspace_init(mcmc);\n  qdm_mcmc_results_init(mcmc);\n\n  return mcmc;\n}\n\nvoid\nqdm_mcmc_free(\n    qdm_mcmc *mcmc\n)\n{\n  if (mcmc == NULL) {\n    return;\n  }\n\n  qdm_mcmc_results_fini(mcmc);\n  qdm_mcmc_workspace_fini(mcmc);\n\n  free(mcmc);\n}\n\nint\nqdm_mcmc_run(\n    qdm_mcmc *mcmc\n)\n{\n  int status = 0;\n\n  for (size_t i = 0; i < mcmc->p.burn; i++) {\n    status = qdm_mcmc_next(mcmc);\n    if (status != 0) {\n      goto cleanup;\n    }\n\n    if (i % mcmc->p.acc_check == 0) {\n      qdm_mcmc_update_tune(mcmc);\n    }\n  }\n\n  for (size_t i = 0; i < mcmc->p.iter; i++) {\n    status = qdm_mcmc_next(mcmc);\n    if (status != 0) {\n      goto cleanup;\n    }\n\n    if (i % mcmc->p.thin == 0) {\n      status = qdm_mcmc_save(mcmc, i / mcmc->p.thin);\n      if (status != 0) {\n        goto cleanup;\n      }\n    }\n  }\n\ncleanup:\n  return status;\n}\n\nint\nqdm_mcmc_next(\n    qdm_mcmc *mcmc\n)\n{\n  int status = 0;\n\n  status = qdm_mcmc_update_theta(mcmc);\n  if (status != 0) {\n    goto cleanup;\n  }\n\n  status = qdm_mcmc_update_xi(mcmc);\n  if (status != 0) {\n    goto cleanup;\n  }\n\ncleanup:\n  return status;\n}\n\nvoid\nqdm_mcmc_update_tune(\n    qdm_mcmc *mcmc\n)\n{\n  for (size_t p = 0; p < mcmc->w.theta->size1; p++) {\n    for (size_t m = 0; m < mcmc->w.theta->size2; m++) {\n      if (gsl_matrix_get(mcmc->w.theta_acc, p, m) / (double)mcmc->p.acc_check > 0.5) {\n        gsl_matrix_set(mcmc->w.theta_tune, p, m, gsl_min(gsl_matrix_get(mcmc->w.theta_tune, p, m) * 1.2, 5));\n      }\n\n      if (gsl_matrix_get(mcmc->w.theta_acc, p, m) / (double)mcmc->p.acc_check < 0.3) {\n        gsl_matrix_set(mcmc->w.theta_tune, p, m, gsl_matrix_get(mcmc->w.theta_tune, p, m) * 0.8);\n      }\n    }\n  }\n\n  if (gsl_vector_get(mcmc->w.xi_acc, 0) / mcmc->p.acc_check > 0.5) {\n    gsl_vector_set(mcmc->w.xi_tune, 0, gsl_min(gsl_vector_get(mcmc->w.xi_tune, 0) * 1.2, 5));\n  }\n  if (gsl_vector_get(mcmc->w.xi_acc, 0) / mcmc->p.acc_check < 0.3) {\n    gsl_vector_set(mcmc->w.xi_tune, 0, gsl_vector_get(mcmc->w.xi_tune, 0) * 0.8);\n  }\n\n  if (gsl_vector_get(mcmc->w.xi_acc, 1) / mcmc->p.acc_check > 0.5) {\n    gsl_vector_set(mcmc->w.xi_tune, 1, gsl_min(gsl_vector_get(mcmc->w.xi_tune, 1) * 1.2, 5));\n  }\n  if (gsl_vector_get(mcmc->w.xi_acc, 1) / mcmc->p.acc_check < 0.3) {\n    gsl_vector_set(mcmc->w.xi_tune, 1, gsl_vector_get(mcmc->w.xi_tune, 1) * 0.8);\n  }\n\n  /* Reset the acceptance counter. */\n  gsl_matrix_set_zero(mcmc->w.theta_acc);\n  gsl_vector_set_zero(mcmc->w.xi_acc);\n}\n\nint\nqdm_mcmc_update_theta(\n    qdm_mcmc *mcmc\n)\n{\n  int status = 0;\n\n  /* Update the mth spline. */\n  size_t p_max = mcmc->w.theta->size1;\n  if (mcmc->p.truncate) {\n    p_max = 1;\n  }\n\n  for (size_t p = 0; p < p_max; p++) {\n    for (size_t m = 0; m < mcmc->w.theta->size2; m++) {\n      /* Propose new theta star. */\n      status = gsl_matrix_memcpy(mcmc->w.theta_star_p, mcmc->w.theta_star);\n      if (status != 0) {\n        goto cleanup;\n      }\n\n      double proposal =\n        gsl_matrix_get(mcmc->w.theta_tune, p, m) *\n        gsl_ran_ugaussian(mcmc->p.rng) +\n        gsl_matrix_get(mcmc->w.theta_star, p, m);\n\n      gsl_matrix_set(mcmc->w.theta_star_p, p, m, proposal);\n\n      gsl_matrix_memcpy(mcmc->w.theta_p, mcmc->w.theta_star_p);\n      qdm_theta_matrix_constrain(mcmc->w.theta_p, mcmc->p.theta_min);\n\n      for (size_t i = 0; i < mcmc->p.y->size; i++) {\n        qdm_logl_3(\n            gsl_vector_ptr(mcmc->w.ll_p, i),\n            gsl_vector_ptr(mcmc->w.tau_p, i),\n\n            gsl_vector_get(mcmc->p.x, i),\n            gsl_vector_get(mcmc->p.y, i),\n\n            mcmc->p.t,\n            mcmc->w.xi,\n\n            mcmc->w.theta_p\n        );\n      }\n\n      double ratio = qdm_vector_sum(mcmc->w.ll_p) - qdm_vector_sum(mcmc->w.ll);\n\n      if (log(gsl_rng_uniform(mcmc->p.rng)) < ratio) {\n        status = gsl_matrix_memcpy(mcmc->w.theta_star, mcmc->w.theta_star_p);\n        if (status != 0) {\n          goto cleanup;\n        }\n\n        status = gsl_matrix_memcpy(mcmc->w.theta, mcmc->w.theta_p);\n        if (status != 0) {\n          goto cleanup;\n        }\n\n        status = gsl_vector_memcpy(mcmc->w.ll, mcmc->w.ll_p);\n        if (status != 0) {\n          goto cleanup;\n        }\n\n        status = gsl_vector_memcpy(mcmc->w.tau, mcmc->w.tau_p);\n        if (status != 0) {\n          goto cleanup;\n        }\n\n        gsl_matrix_set(mcmc->w.theta_acc, p, m, gsl_matrix_get(mcmc->w.theta_acc, p, m) + 1);\n      }\n    }\n  }\n\ncleanup:\n  return status;\n}\n\nint\nqdm_mcmc_update_xi(\n    qdm_mcmc *mcmc\n)\n{\n  int status = 0;\n\n  /* Update xi_low. */\n  {\n    double xi_low = gsl_vector_get(mcmc->w.xi, 0);\n    double xi_low_p = exp(log(xi_low) + gsl_vector_get(mcmc->w.xi_tune, 0) * gsl_ran_ugaussian(mcmc->p.rng));\n\n    gsl_vector_memcpy(mcmc->w.xi_p, mcmc->w.xi);\n    gsl_vector_set(mcmc->w.xi_p, 0, xi_low_p);\n\n    for (size_t i = 0; i < mcmc->p.y->size; i++) {\n      qdm_logl_3(\n          gsl_vector_ptr(mcmc->w.ll_p, i),\n          gsl_vector_ptr(mcmc->w.tau_p, i),\n\n          gsl_vector_get(mcmc->p.x, i),\n          gsl_vector_get(mcmc->p.y, i),\n\n          mcmc->p.t,\n          mcmc->w.xi_p,\n\n          mcmc->w.theta\n      );\n    }\n\n    double ratio = -0.5 * (1 / mcmc->p.xi_prior_var) *  pow(log(xi_low_p) - mcmc->p.xi_prior_mean, 2) +\n                    0.5 * (1 / mcmc->p.xi_prior_var) * (pow(log(xi_low  ) - mcmc->p.xi_prior_mean, 2) + qdm_vector_sum(mcmc->w.ll_p) - qdm_vector_sum(mcmc->w.ll));\n    if (log(gsl_rng_uniform(mcmc->p.rng)) < ratio) {\n      gsl_vector_set(mcmc->w.xi, 0, xi_low_p);\n\n      status = gsl_vector_memcpy(mcmc->w.ll, mcmc->w.ll_p);\n      if (status != 0) {\n        goto cleanup;\n      }\n\n      gsl_vector_set(mcmc->w.xi_acc, 0, gsl_vector_get(mcmc->w.xi_acc, 0) + 1);\n    }\n  }\n\n  /* Update xi_high. */\n  {\n    double xi_high = gsl_vector_get(mcmc->w.xi, 1);\n    double xi_high_p = exp(log(xi_high) + gsl_vector_get(mcmc->w.xi_tune, 1) * gsl_ran_ugaussian(mcmc->p.rng));\n\n    gsl_vector_memcpy(mcmc->w.xi_p, mcmc->w.xi);\n    gsl_vector_set(mcmc->w.xi_p, 1, xi_high_p);\n\n    for (size_t i = 0; i < mcmc->p.y->size; i++) {\n      qdm_logl_3(\n          gsl_vector_ptr(mcmc->w.ll_p, i),\n          gsl_vector_ptr(mcmc->w.tau_p, i),\n\n          gsl_vector_get(mcmc->p.x, i),\n          gsl_vector_get(mcmc->p.y, i),\n\n          mcmc->p.t,\n          mcmc->w.xi_p,\n\n          mcmc->w.theta\n      );\n    }\n\n    double ratio = -0.5 * (1 / mcmc->p.xi_prior_var) *  pow(log(xi_high_p) - mcmc->p.xi_prior_mean, 2) +\n                    0.5 * (1 / mcmc->p.xi_prior_var) * (pow(log(xi_high  ) - mcmc->p.xi_prior_mean, 2) + qdm_vector_sum(mcmc->w.ll_p) - qdm_vector_sum(mcmc->w.ll));\n    if (log(gsl_rng_uniform(mcmc->p.rng)) < ratio) {\n      gsl_vector_set(mcmc->w.xi, 1, xi_high_p);\n\n      status = gsl_vector_memcpy(mcmc->w.ll, mcmc->w.ll_p);\n      if (status != 0) {\n        goto cleanup;\n      }\n\n      gsl_vector_set(mcmc->w.xi_acc, 1, gsl_vector_get(mcmc->w.xi_acc, 1) + 1);\n    }\n  }\n\ncleanup:\n  return status;\n}\n\nint\nqdm_mcmc_save(\n    qdm_mcmc *mcmc,\n    size_t k\n)\n{\n  int status = 0;\n\n  {\n    gsl_matrix_view m = qdm_ijk_get_ij(mcmc->r.theta, k);\n\n    status = gsl_matrix_memcpy(&m.matrix, mcmc->w.theta);\n    if (status != 0) {\n      goto cleanup;\n    }\n  }\n\n  {\n    gsl_matrix_view m = qdm_ijk_get_ij(mcmc->r.theta_star, k);\n\n    status = gsl_matrix_memcpy(&m.matrix, mcmc->w.theta_star);\n    if (status != 0) {\n      goto cleanup;\n    }\n  }\n\n  {\n    gsl_matrix_view m = qdm_ijk_get_ij(mcmc->r.ll, k);\n\n    status = gsl_matrix_set_row(&m.matrix, 0, mcmc->w.ll);\n    if (status != 0) {\n      goto cleanup;\n    }\n  }\n\n  {\n    gsl_matrix_view m = qdm_ijk_get_ij(mcmc->r.tau, k);\n\n    status = gsl_matrix_set_row(&m.matrix, 0, mcmc->w.tau);\n    if (status != 0) {\n      goto cleanup;\n    }\n  }\n\n  {\n    gsl_matrix_view m = qdm_ijk_get_ij(mcmc->r.xi, k);\n\n    status = gsl_matrix_set_row(&m.matrix, 0, mcmc->w.xi);\n    if (status != 0) {\n      goto cleanup;\n    }\n  }\n\ncleanup:\n  return status;\n}\n\nint\nqdm_mcmc_write(\n    hid_t id,\n    const qdm_mcmc *mcmc\n)\n{\n  int status = 0;\n\n  status = qdm_ijk_write(id, \"theta\", mcmc->r.theta);\n  if (status != 0) {\n    goto cleanup;\n  }\n\n  status = qdm_ijk_write(id, \"theta_star\", mcmc->r.theta_star);\n  if (status != 0) {\n    goto cleanup;\n  }\n\n  status = qdm_ijk_write(id, \"ll\", mcmc->r.ll);\n  if (status != 0) {\n    goto cleanup;\n  }\n\n  status = qdm_ijk_write(id, \"tau\", mcmc->r.tau);\n  if (status != 0) {\n    goto cleanup;\n  }\n\n  status = qdm_ijk_write(id, \"xi\", mcmc->r.xi);\n  if (status != 0) {\n    goto cleanup;\n  }\n\ncleanup:\n  return status;\n}\n\nint\nqdm_mcmc_read(\n    hid_t id,\n    qdm_mcmc **mcmc\n)\n{\n  int status = 0;\n\n  *mcmc = malloc(sizeof(qdm_mcmc));\n\n  status = qdm_ijk_read(id, \"theta\", &(*mcmc)->r.theta);\n  if (status != 0) {\n    goto cleanup;\n  }\n\n  status = qdm_ijk_read(id, \"theta_star\", &(*mcmc)->r.theta_star);\n  if (status != 0) {\n    goto cleanup;\n  }\n\n  status = qdm_ijk_read(id, \"ll\", &(*mcmc)->r.ll);\n  if (status != 0) {\n    goto cleanup;\n  }\n\n  status = qdm_ijk_read(id, \"tau\", &(*mcmc)->r.tau);\n  if (status != 0) {\n    goto cleanup;\n  }\n\n  status = qdm_ijk_read(id, \"xi\", &(*mcmc)->r.xi);\n  if (status != 0) {\n    goto cleanup;\n  }\n\n  (*mcmc)->r.s = (*mcmc)->r.theta->size3;\n\ncleanup:\n  return status;\n}\n", "meta": {"hexsha": "c9bece99e5317496e5efc4c5a813b9fed28f439e", "size": 12694, "ext": "c", "lang": "C", "max_stars_repo_path": "src/mcmc.c", "max_stars_repo_name": "calebcase/qdm", "max_stars_repo_head_hexsha": "2ee95bec6c8be64f69e231c78f2be5fce3509c67", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/mcmc.c", "max_issues_repo_name": "calebcase/qdm", "max_issues_repo_head_hexsha": "2ee95bec6c8be64f69e231c78f2be5fce3509c67", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2020-03-06T18:09:06.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-22T20:22:53.000Z", "max_forks_repo_path": "src/mcmc.c", "max_forks_repo_name": "calebcase/qdm", "max_forks_repo_head_hexsha": "2ee95bec6c8be64f69e231c78f2be5fce3509c67", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 22.9963768116, "max_line_length": 164, "alphanum_fraction": 0.6002835986, "num_tokens": 4587, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3812195662561499, "lm_q2_score": 0.030214587613180036, "lm_q1q2_score": 0.011518391984504932}}
{"text": "/* ode-initval/odeiv.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n */\n\n/* Author:  G. Jungman\n */\n#include <config.h>\n#include <stdlib.h>\n#include <gsl/gsl_errno.h>\n#include \"gsl_odeiv.h\"\n\ngsl_odeiv_step * \ngsl_odeiv_step_alloc(const gsl_odeiv_step_type * T, size_t dim)\n{\n  gsl_odeiv_step *s = (gsl_odeiv_step *) malloc (sizeof (gsl_odeiv_step));\n\n  if (s == 0)\n    {\n      GSL_ERROR_NULL (\"failed to allocate space for ode struct\", GSL_ENOMEM);\n    };\n\n  s->type = T;\n  s->dimension = dim;\n\n  s->state = s->type->alloc(dim);\n\n  if (s->state == 0)\n    {\n      free (s);\t\t/* exception in constructor, avoid memory leak */\n\n      GSL_ERROR_NULL (\"failed to allocate space for ode state\",\tGSL_ENOMEM);\n    };\n    \n  return s;\n}\n\nconst char *\ngsl_odeiv_step_name(const gsl_odeiv_step * s)\n{\n  return s->type->name;\n}\n\nunsigned int\ngsl_odeiv_step_order(const gsl_odeiv_step * s)\n{\n  return s->type->order(s->state);\n}\n\nint\ngsl_odeiv_step_apply(\n  gsl_odeiv_step * s,\n  double t,\n  double h,\n  double y[],\n  double yerr[],\n  const double dydt_in[],\n  double dydt_out[],\n  const gsl_odeiv_system * dydt)\n{\n  return s->type->apply(s->state, s->dimension, t, h, y, yerr, dydt_in, dydt_out, dydt);\n}\n\nint\ngsl_odeiv_step_reset(gsl_odeiv_step * s)\n{\n  return s->type->reset(s->state, s->dimension);\n}\n\nvoid\ngsl_odeiv_step_free(gsl_odeiv_step * s)\n{\n  s->type->free(s->state);\n  free(s);\n}\n", "meta": {"hexsha": "96999e3acc83410549d6ef7833c06e15ecffc8e3", "size": 2103, "ext": "c", "lang": "C", "max_stars_repo_path": "code/em/treba/gsl-1.0/ode-initval/step.c", "max_stars_repo_name": "ICML14MoMCompare/spectral-learn", "max_stars_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "code/em/treba/gsl-1.0/ode-initval/step.c", "max_issues_repo_name": "ICML14MoMCompare/spectral-learn", "max_issues_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/em/treba/gsl-1.0/ode-initval/step.c", "max_forks_repo_name": "ICML14MoMCompare/spectral-learn", "max_forks_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2015-10-02T01:32:59.000Z", "max_forks_repo_forks_event_max_datetime": "2015-10-02T01:32:59.000Z", "avg_line_length": 23.3666666667, "max_line_length": 88, "alphanum_fraction": 0.6885401807, "num_tokens": 632, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.42250463481418826, "lm_q2_score": 0.027169228434084505, "lm_q1q2_score": 0.011479124937726133}}
{"text": "/* -*- linux-c -*- */\n/* triple.c\n\n   Copyright (C) 2002-2004 John M. Fregeau\n   \n   This program is free software; you can redistribute it and/or modify\n   it under the terms of the GNU General Public License as published by\n   the Free Software Foundation; either version 2 of the License, or\n   (at your option) any later version.\n   \n   This program is distributed in the hope that it will be useful,\n   but WITHOUT ANY WARRANTY; without even the implied warranty of\n   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n   GNU General Public License for more details.\n   \n   You should have received a copy of the GNU General Public License\n   along with this program; if not, write to the Free Software\n   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n*/\n\n#include <stdio.h>\n#include <stddef.h>\n#include <stdlib.h>\n#include <string.h>\n#include <math.h>\n#include <time.h>\n#include <getopt.h>\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_rng.h>\n#include \"fewbody.h\"\n#include \"triple.h\"\n\n/* print the usage */\nvoid print_usage(FILE *stream)\n{\n\tfprintf(stream, \"USAGE:\\n\");\n\tfprintf(stream, \"  triple [options...]\\n\");\n\tfprintf(stream, \"\\n\");\n\tfprintf(stream, \"OPTIONS:\\n\");\n\tfprintf(stream, \"  -m --m000 <m000/MSUN>        : set mass of star 0 of inner binary of triple [%.6g]\\n\", FB_M000/FB_CONST_MSUN);\n\tfprintf(stream, \"  -n --m001 <m001/MSUN>        : set mass of star 1 of inner binary of triple [%.6g]\\n\", FB_M001/FB_CONST_MSUN);\n\tfprintf(stream, \"  -o --m01 <m01/MSUN>          : set mass of outer star of triple [%.6g]\\n\", FB_M01/FB_CONST_MSUN);\n\tfprintf(stream, \"  -r --r000 <r000/RSUN>        : set radius of star 0 of inner binary of triple [%.6g]\\n\", FB_R000/FB_CONST_RSUN);\n\tfprintf(stream, \"  -g --r001 <r001/RSUN>        : set radius of star 1 of inner binary of triple [%.6g]\\n\", FB_R001/FB_CONST_RSUN);\n\tfprintf(stream, \"  -i --r01 <r01/RSUN>          : set radius of outer star of triple [%.6g]\\n\", FB_R01/FB_CONST_RSUN);\n\tfprintf(stream, \"  -a --a00 <a00/AU>            : set inner semimajor axis of triple [%.6g]\\n\", FB_A00/FB_CONST_AU);\n\tfprintf(stream, \"  -Q --a0 <a0/AU>              : set outer semimajor axis of triple [%.6g]\\n\", FB_A0/FB_CONST_AU);\n\tfprintf(stream, \"  -e --e00 <e00>               : set inner eccentricity of triple [%.6g]\\n\", FB_E00);\n\tfprintf(stream, \"  -F --e0 <e0>                 : set outer eccentricity of triple [%.6g]\\n\", FB_E0);\n\tfprintf(stream, \"  -t --tstop <tstop/t_dyn>     : set stopping time [%.6g]\\n\", FB_TSTOP);\n\tfprintf(stream, \"  -D --dt <dt/t_dyn>           : set approximate output dt [%.6g]\\n\", FB_DT);\n\tfprintf(stream, \"  -c --tcpustop <tcpustop/sec> : set cpu stopping time [%.6g]\\n\", FB_TCPUSTOP);\n\tfprintf(stream, \"  -A --absacc <absacc>         : set integrator's absolute accuracy [%.6g]\\n\", FB_ABSACC);\n\tfprintf(stream, \"  -R --relacc <relacc>         : set integrator's relative accuracy [%.6g]\\n\", FB_RELACC);\n\tfprintf(stream, \"  -N --ncount <ncount>         : set number of integration steps between calls\\n\");\n\tfprintf(stream, \"                                 to fb_classify() [%d]\\n\", FB_NCOUNT);\n\tfprintf(stream, \"  -z --tidaltol <tidaltol>     : set tidal tolerance [%.6g]\\n\", FB_TIDALTOL);\n\tfprintf(stream, \"  -x --fexp <f_exp>            : set expansion factor of merger product [%.6g]\\n\", FB_FEXP);\n\tfprintf(stream, \"  -k --ks                      : turn K-S regularization on or off [%d]\\n\", FB_KS);\n\tfprintf(stream, \"  -s --seed                    : set random seed [%ld]\\n\", FB_SEED);\n\tfprintf(stream, \"  -d --debug                   : turn on debugging\\n\");\n\tfprintf(stream, \"  -V --version                 : print version info\\n\");\n\tfprintf(stream, \"  -h --help                    : display this help text\\n\");\n}\n\n/* calculate the units used */\nint calc_units(fb_obj_t *obj[1], fb_units_t *units)\n{\n\tdouble m0, m00, m01, m000, m001, a00, a0;\n\n\tm0 = obj[0]->m;\n\tm00 = obj[0]->obj[0]->m;\n\tm01 = obj[0]->obj[1]->m;\n\tm000 = obj[0]->obj[0]->obj[0]->m;\n\tm001 = obj[0]->obj[0]->obj[1]->m;\n\n\ta0 = obj[0]->a;\n\ta00 = obj[0]->obj[0]->a;\n\t\n\t/* Unit of velocity is approximate relative orbital speed of inner binary,\n\t   unit of length is semimajor axis of inner binary; \n\t   therefore, unit of time is approximately 1 inner orbital period. */\n\tunits->v = sqrt(FB_CONST_G*(m000+m001)/a00);\n\tunits->l = a00;\n\tunits->t = units->l / units->v;\n\tunits->m = units->l * fb_sqr(units->v) / FB_CONST_G;\n\tunits->E = units->m * fb_sqr(units->v);\n\t\n\treturn(0);\n}\n\n/* the main attraction */\nint main(int argc, char *argv[])\n{\n\tint i, j;\n\tunsigned long int seed;\n\tdouble m000, m001, m01, r000, r001, r01, a00, a0, e00, e0;\n\tdouble Ei, Lint[3], Li[3], t;\n\tfb_hier_t hier;\n\tfb_input_t input;\n\tfb_ret_t retval;\n\tfb_units_t units;\n\tchar string1[FB_MAX_STRING_LENGTH], string2[FB_MAX_STRING_LENGTH];\n\tgsl_rng *rng;\n\tconst gsl_rng_type *rng_type=gsl_rng_mt19937;\n\tconst char *short_opts = \"m:n:o:r:g:i:a:Q:e:F:t:D:c:A:R:N:z:x:k:s:dVh\";\n\tconst struct option long_opts[] = {\n\t\t{\"m000\", required_argument, NULL, 'm'},\n\t\t{\"m001\", required_argument, NULL, 'n'},\n\t\t{\"m01\", required_argument, NULL, 'o'},\n\t\t{\"r000\", required_argument, NULL, 'r'},\n\t\t{\"r001\", required_argument, NULL, 'g'},\n\t\t{\"r01\", required_argument, NULL, 'i'},\n\t\t{\"a00\", required_argument, NULL, 'a'},\n\t\t{\"a0\", required_argument, NULL, 'Q'},\n\t\t{\"e00\", required_argument, NULL, 'e'},\n\t\t{\"e0\", required_argument, NULL, 'F'},\n\t\t{\"tstop\", required_argument, NULL, 't'},\n\t\t{\"dt\", required_argument, NULL, 'D'},\n\t\t{\"tcpustop\", required_argument, NULL, 'c'},\n\t\t{\"absacc\", required_argument, NULL, 'A'},\n\t\t{\"relacc\", required_argument, NULL, 'R'},\n\t\t{\"ncount\", required_argument, NULL, 'N'},\n\t\t{\"tidaltol\", required_argument, NULL, 'z'},\n\t\t{\"fexp\", required_argument, NULL, 'x'},\n\t\t{\"ks\", required_argument, NULL, 'k'},\n\t\t{\"seed\", required_argument, NULL, 's'},\n\t\t{\"debug\", no_argument, NULL, 'd'},\n\t\t{\"version\", no_argument, NULL, 'V'},\n\t\t{\"help\", no_argument, NULL, 'h'},\n\t\t{NULL, 0, NULL, 0}\n\t};\n\n\t/* set parameters to default values */\n\tm000 = FB_M000;\n\tm001 = FB_M001;\n\tm01 = FB_M01;\n\tr000 = FB_R000;\n\tr001 = FB_R001;\n\tr01 = FB_R01;\n\ta00 = FB_A00;\n\ta0 = FB_A0;\n\te00 = FB_E00;\n\te0 = FB_E0;\n\tinput.ks = FB_KS;\n\tinput.tstop = FB_TSTOP;\n\tinput.Dflag = 0;\n\tinput.dt = FB_DT;\n\tinput.tcpustop = FB_TCPUSTOP;\n\tinput.absacc = FB_ABSACC;\n\tinput.relacc = FB_RELACC;\n\tinput.ncount = FB_NCOUNT;\n\tinput.tidaltol = FB_TIDALTOL;\n\tinput.fexp = FB_FEXP;\n\tseed = FB_SEED;\n\tfb_debug = FB_DEBUG;\n\t\n\twhile ((i = getopt_long(argc, argv, short_opts, long_opts, NULL)) != -1) {\n\t\tswitch (i) {\n\t\tcase 'm':\n\t\t\tm000 = atof(optarg) * FB_CONST_MSUN;\n\t\t\tbreak;\n\t\tcase 'n':\n\t\t\tm001 = atof(optarg) * FB_CONST_MSUN;\n\t\t\tbreak;\n\t\tcase 'o':\n\t\t\tm01 = atof(optarg) * FB_CONST_MSUN;\n\t\t\tbreak;\n\t\tcase 'r':\n\t\t\tr000 = atof(optarg) * FB_CONST_RSUN;\n\t\t\tbreak;\n\t\tcase 'g':\n\t\t\tr001 = atof(optarg) * FB_CONST_RSUN;\n\t\t\tbreak;\n\t\tcase 'i':\n\t\t\tr01 = atof(optarg) * FB_CONST_RSUN;\n\t\t\tbreak;\n\t\tcase 'a':\n\t\t\ta00 = atof(optarg) * FB_CONST_AU;\n\t\t\tbreak;\n\t\tcase 'Q':\n\t\t\ta0 = atof(optarg) * FB_CONST_AU;\n\t\t\tbreak;\n\t\tcase 'e':\n\t\t\te00 = atof(optarg);\n\t\t\tif (e00 >= 1.0) {\n\t\t\t\tfprintf(stderr, \"e00 must be less than 1\\n\");\n\t\t\t\treturn(1);\n\t\t\t}\n\t\t\tbreak;\n\t\tcase 'F':\n\t\t\te0 = atof(optarg);\n\t\t\tif (e0 >= 1.0) {\n\t\t\t\tfprintf(stderr, \"e0 must be less than 1\\n\");\n\t\t\t\treturn(1);\n\t\t\t}\n\t\t\tbreak;\n\t\tcase 't':\n\t\t\tinput.tstop = atof(optarg);\n\t\t\tbreak;\n\t\tcase 'D':\n\t\t\tinput.Dflag = 1;\n\t\t\tinput.dt = atof(optarg);\n\t\t\tbreak;\n\t\tcase 'c':\n\t\t\tinput.tcpustop = atof(optarg);\n\t\t\tbreak;\n\t\tcase 'A':\n\t\t\tinput.absacc = atof(optarg);\n\t\t\tbreak;\n\t\tcase 'R':\n\t\t\tinput.relacc = atof(optarg);\n\t\t\tbreak;\n\t\tcase 'N':\n\t\t\tinput.ncount = atoi(optarg);\n\t\t\tbreak;\n\t\tcase 'z':\n\t\t\tinput.tidaltol = atof(optarg);\n\t\t\tbreak;\n\t\tcase 'x':\n\t\t\tinput.fexp = atof(optarg);\n\t\t\tbreak;\n\t\tcase 'k':\n\t\t\tinput.ks = atoi(optarg);\n\t\t\tbreak;\n\t\tcase 's':\n\t\t\tseed = atol(optarg);\n\t\t\tbreak;\n\t\tcase 'd':\n\t\t\tfb_debug = 1;\n\t\t\tbreak;\n\t\tcase 'V':\n\t\t\tfb_print_version(stdout);\n\t\t\treturn(0);\n\t\tcase 'h':\n\t\t\tfb_print_version(stdout);\n\t\t\tfprintf(stdout, \"\\n\");\n\t\t\tprint_usage(stdout);\n\t\t\treturn(0);\n\t\tdefault:\n\t\t\tbreak;\n\t\t}\n\t}\n\t\n\t/* check to make sure there was nothing crazy on the command line */\n\tif (optind < argc) {\n\t\tprint_usage(stdout);\n\t\treturn(1);\n\t}\n\n\t/* initialize a few things for integrator */\n\tt = 0.0;\n\thier.nstarinit = 3;\n\thier.nstar = 3;\n\tfb_malloc_hier(&hier);\n\tfb_init_hier(&hier);\n\n\t/* put stuff in log entry */\n\tsnprintf(input.firstlogentry, FB_MAX_LOGENTRY_LENGTH, \"  command line:\");\n\tfor (i=0; i<argc; i++) {\n\t\tsnprintf(&(input.firstlogentry[strlen(input.firstlogentry)]), \n\t\t\t FB_MAX_LOGENTRY_LENGTH-strlen(input.firstlogentry), \" %s\", argv[i]);\n\t}\n\tsnprintf(&(input.firstlogentry[strlen(input.firstlogentry)]),\n\t\t FB_MAX_LOGENTRY_LENGTH-strlen(input.firstlogentry), \"\\n\");\n\t\n\t/* print out values of paramaters */\n\tfprintf(stderr, \"PARAMETERS:\\n\");\n\tfprintf(stderr, \"  ks=%d  seed=%ld\\n\", input.ks, seed);\n\tfprintf(stderr, \"  a00=%.6g AU  e00=%.6g  m000=%.6g MSUN  m001=%.6g MSUN  r000=%.6g RSUN  r001=%.6g RSUN\\n\", \\\n\t\ta00/FB_CONST_AU, e00, m000/FB_CONST_MSUN, m001/FB_CONST_MSUN, r000/FB_CONST_RSUN, r001/FB_CONST_RSUN);\n\tfprintf(stderr, \"  a0=%.6g AU  e0=%.6g  m01=%.6g MSUN  r01=%.6g RSUN\\n\", \\\n\t\ta0/FB_CONST_AU, e0, m01/FB_CONST_MSUN, r01/FB_CONST_RSUN);\n\tfprintf(stderr, \"  tstop=%.6g  tcpustop=%.6g\\n\", \\\n\t\tinput.tstop, input.tcpustop);\n\tfprintf(stderr, \"  tidaltol=%.6g  abs_acc=%.6g  rel_acc=%.6g  ncount=%d  fexp=%.6g\\n\\n\", \\\n\t\tinput.tidaltol, input.absacc, input.relacc, input.ncount, input.fexp);\n\n\t/* initialize GSL rng */\n\tgsl_rng_env_setup();\n\trng = gsl_rng_alloc(rng_type);\n\tgsl_rng_set(rng, seed);\n\n\t/* create hierarchies */\n\thier.narr[2] = 1;\n\thier.narr[3] = 1;\n\t/* inner binary of triple */\n\thier.hier[hier.hi[2]+0].obj[0] = &(hier.hier[hier.hi[1]+0]);\n\thier.hier[hier.hi[2]+0].obj[1] = &(hier.hier[hier.hi[1]+1]);\n\thier.hier[hier.hi[2]+0].t = t;\n\t/* outer binary of triple */\n\thier.hier[hier.hi[3]+0].obj[0] = &(hier.hier[hier.hi[2]+0]);\n\thier.hier[hier.hi[3]+0].obj[1] = &(hier.hier[hier.hi[1]+2]);\n\thier.hier[hier.hi[3]+0].t = t;\n\n\t/* give the objects some properties */\n\tfor (j=0; j<hier.nstar; j++) {\n\t\thier.hier[hier.hi[1]+j].ncoll = 1;\n\t\thier.hier[hier.hi[1]+j].id[0] = j;\n\t\tsnprintf(hier.hier[hier.hi[1]+j].idstring, FB_MAX_STRING_LENGTH, \"%d\", j);\n\t\thier.hier[hier.hi[1]+j].n = 1;\n\t\thier.hier[hier.hi[1]+j].obj[0] = NULL;\n\t\thier.hier[hier.hi[1]+j].obj[1] = NULL;\n\t\thier.hier[hier.hi[1]+j].Eint = 0.0;\n\t\thier.hier[hier.hi[1]+j].Lint[0] = 0.0;\n\t\thier.hier[hier.hi[1]+j].Lint[1] = 0.0;\n\t\thier.hier[hier.hi[1]+j].Lint[2] = 0.0;\n\t}\n\n\thier.hier[hier.hi[1]+0].R = r000;\n\thier.hier[hier.hi[1]+1].R = r001;\n\thier.hier[hier.hi[1]+2].R = r01;\n\n\thier.hier[hier.hi[1]+0].m = m000;\n\thier.hier[hier.hi[1]+1].m = m001;\n\thier.hier[hier.hi[1]+2].m = m01;\n\n\thier.hier[hier.hi[2]+0].m = m000 + m001;\n\thier.hier[hier.hi[3]+0].m = m000 + m001 + m01;\n\n\thier.hier[hier.hi[2]+0].a = a00;\n\thier.hier[hier.hi[3]+0].a = a0;\n\t\n\thier.hier[hier.hi[2]+0].e = e00;\n\thier.hier[hier.hi[3]+0].e = e0;\n\n\thier.nobj = 1;\n\thier.obj[0] = &(hier.hier[hier.hi[3]+0]);\n\thier.obj[1] = NULL;\n\thier.obj[2] = NULL;\n\n\t/* get the units and normalize */\n\tcalc_units(hier.obj, &units);\n\tfb_normalize(&hier, units);\n\t\n\t/* place triple at origin */\n\tfor (j=0; j<3; j++) {\n\t\thier.obj[0]->x[j] = 0.0;\n\t\thier.obj[0]->v[j] = 0.0;\n\t}\n\n\t/* randomize binary orientations and downsync */\n\tfb_randorient(&(hier.hier[hier.hi[3]+0]), rng);\n\tfb_downsync(&(hier.hier[hier.hi[3]+0]), t);\n\tfb_randorient(&(hier.hier[hier.hi[2]+0]), rng);\n\tfb_downsync(&(hier.hier[hier.hi[2]+0]), t);\n\n\tfprintf(stderr, \"UNITS:\\n\");\n\tfprintf(stderr, \"  v=%.6g km/s  l=%.6g AU  t=t_dyn=%.6g yr\\n\", \\\n\t\tunits.v/1.0e5, units.l/FB_CONST_AU, units.t/FB_CONST_YR);\n\tfprintf(stderr, \"  M=%.6g M_sun  E=%.6g erg\\n\\n\", units.m/FB_CONST_MSUN, units.E);\n\t\n\t/* trickle down properties (not sure if this is actually needed here, but it doesn't harm anything) */\n\tfb_trickle(&hier, t);\n\n\t/* store the initial energy and angular momentum*/\n\tEi = fb_petot(&(hier.hier[hier.hi[1]]), hier.nstar) + fb_ketot(&(hier.hier[hier.hi[1]]), hier.nstar) +\n\t\tfb_einttot(&(hier.hier[hier.hi[1]]), hier.nstar);\n\tfb_angmom(&(hier.hier[hier.hi[1]]), hier.nstar, Li);\n\tfb_angmomint(&(hier.hier[hier.hi[1]]), hier.nstar, Lint);\n\tfor (j=0; j<3; j++) {\n\t\tLi[j] += Lint[j];\n\t}\n\n\t/* integrate along */\n\tfb_dprintf(\"calling fewbody()...\\n\");\n\t\n\t/* call fewbody! */\n\tretval = fewbody(input, &hier, &t);\n\n\t/* print information to screen */\n\tfprintf(stderr, \"OUTCOME:\\n\");\n\tif (retval.retval == 1) {\n\t\tfprintf(stderr, \"  encounter complete:  t=%.6g (%.6g yr)  %s  (%s)\\n\\n\",\n\t\t\tt, t * units.t/FB_CONST_YR,\n\t\t\tfb_sprint_hier(hier, string1),\n\t\t\tfb_sprint_hier_hr(hier, string2));\n\t} else {\n\t\tfprintf(stderr, \"  encounter NOT complete:  t=%.6g (%.6g yr)  %s  (%s)\\n\\n\",\n\t\t\tt, t * units.t/FB_CONST_YR,\n\t\t\tfb_sprint_hier(hier, string1),\n\t\t\tfb_sprint_hier_hr(hier, string2));\n\t}\n\n\tfb_dprintf(\"there were %ld integration steps\\n\", retval.count);\n\tfb_dprintf(\"fb_classify() was called %ld times\\n\", retval.iclassify);\n\t\n\tfprintf(stderr, \"FINAL:\\n\");\n\tfprintf(stderr, \"  t_final=%.6g (%.6g yr)  t_cpu=%.6g s\\n\", \\\n\t\tt, t*units.t/FB_CONST_YR, retval.tcpu);\n\n\tfprintf(stderr, \"  L0=%.6g  DeltaL/L0=%.6g  DeltaL=%.6g\\n\", fb_mod(Li), retval.DeltaLfrac, retval.DeltaL);\n\tfprintf(stderr, \"  E0=%.6g  DeltaE/E0=%.6g  DeltaE=%.6g\\n\", Ei, retval.DeltaEfrac, retval.DeltaE);\n\tfprintf(stderr, \"  Rmin=%.6g (%.6g RSUN)  Rmin_i=%d  Rmin_j=%d\\n\", \\\n\t\tretval.Rmin, retval.Rmin*units.l/FB_CONST_RSUN, retval.Rmin_i, retval.Rmin_j);\n\tfprintf(stderr, \"  Nosc=%d (%s)\\n\", retval.Nosc, (retval.Nosc>=1?\"resonance\":\"non-resonance\"));\n\t\n\t/* free GSL stuff */\n\tgsl_rng_free(rng);\n\n\t/* free our own stuff */\n\tfb_free_hier(hier);\n\n\t/* done! */\n\treturn(0);\n}\n", "meta": {"hexsha": "121c82a7c67101757b39ce356a314ad15261a818", "size": 13673, "ext": "c", "lang": "C", "max_stars_repo_path": "ext/fewbod/fewbody-0.26/triple.c", "max_stars_repo_name": "gnodvi/cosmos", "max_stars_repo_head_hexsha": "3612456fc2042519f96a49e4d4cc6d3c1f41de7c", "max_stars_repo_licenses": ["PSF-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "ext/fewbod/fewbody-0.26/triple.c", "max_issues_repo_name": "gnodvi/cosmos", "max_issues_repo_head_hexsha": "3612456fc2042519f96a49e4d4cc6d3c1f41de7c", "max_issues_repo_licenses": ["PSF-2.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-12-13T20:35:46.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-13T20:35:46.000Z", "max_forks_repo_path": "ext/fewbod/fewbody-0.26/triple.c", "max_forks_repo_name": "gnodvi/cosmos", "max_forks_repo_head_hexsha": "3612456fc2042519f96a49e4d4cc6d3c1f41de7c", "max_forks_repo_licenses": ["PSF-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.5945945946, "max_line_length": 132, "alphanum_fraction": 0.624734879, "num_tokens": 4787, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3960681662740417, "lm_q2_score": 0.02887090882634064, "lm_q1q2_score": 0.011434847917513782}}
{"text": "/* -*- linux-c -*- */\n/* fewbody.h\n\n   Copyright (C) 2002-2004 John M. Fregeau\n   \n   This program is free software; you can redistribute it and/or modify\n   it under the terms of the GNU General Public License as published by\n   the Free Software Foundation; either version 2 of the License, or\n   (at your option) any later version.\n   \n   This program is distributed in the hope that it will be useful,\n   but WITHOUT ANY WARRANTY; without even the implied warranty of\n   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n   GNU General Public License for more details.\n   \n   You should have received a copy of the GNU General Public License\n   along with this program; if not, write to the Free Software\n   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n*/\n\n#ifndef _FEWBODY_H\n#define _FEWBODY_H 1\n\n#include <stdio.h>\n#include <gsl/gsl_nan.h>\n#include <gsl/gsl_rng.h>\n\n/* version information */\n#define FB_VERSION \"0.26\"\n#define FB_NICK \"Oblivion\"\n#define FB_DATE \"Mon Sep  6 09:05:47 EDT 2010\"\n\n/* dimensionless constants */\n#define FB_CONST_PI 3.141592653589793238462643\n\n/* constants, in cgs units */\n#define FB_CONST_MSUN 1.989e+33\n#define FB_CONST_RSUN 6.9599e+10\n#define FB_CONST_C 2.99792458e+10\n#define FB_CONST_G 6.67259e-8\n#define FB_CONST_AU 1.496e+13\n#define FB_CONST_PARSEC 3.0857e+18\n#define FB_CONST_YR 3.155693e+7\n\n/* these usually shouldn't need to be changed */\n#define FB_H 1.0e-2\n#define FB_SSTOP GSL_POSINF\n#define FB_AMIN GSL_POSINF\n#define FB_RMIN GSL_POSINF\n#define FB_ROOTSOLVER_MAX_ITER 100\n#define FB_ROOTSOLVER_ABS_ACC 1.0e-11\n#define FB_ROOTSOLVER_REL_ACC 1.0e-11\n#define FB_MAX_STRING_LENGTH 2048\n#define FB_MAX_LOGENTRY_LENGTH (32 * FB_MAX_STRING_LENGTH)\n\n/* a struct containing the units used */\ntypedef struct{\n\tdouble v; /* velocity */\n\tdouble l; /* length */\n\tdouble t; /* time */\n\tdouble m; /* mass */\n\tdouble E; /* energy */\n} fb_units_t;\n\n/* the fundamental object */\ntypedef struct fb_obj{\n\tint ncoll; /* total number of stars collided together in this star */\n\tlong *id; /* numeric id array */\n\tchar idstring[FB_MAX_STRING_LENGTH]; /* string id */\n\tdouble m; /* mass */\n\tdouble R; /* radius */\n\tdouble Eint; /* internal energy (used to check energy conservation) */\n\tdouble Lint[3]; /* internal ang mom (used to check ang mom conservation) */\n\tdouble x[3]; /* position */\n\tdouble v[3]; /* velocity */\n\tint n; /* total number of stars in hierarchy */\n\tstruct fb_obj *obj[2]; /* pointers to children */\n\tdouble a; /* semimajor axis */\n\tdouble e; /* eccentricity */\n\tdouble Lhat[3]; /* angular momentum vector */\n\tdouble Ahat[3]; /* Runge-Lenz vector */\n\tdouble t; /* time at which node was upsynced */\n\tdouble mean_anom; /* mean anomaly when node was upsynced */\n} fb_obj_t;\n\n/* parameters for the K-S integrator */\ntypedef struct{\n\tint nstar; /* number of actual stars */\n\tint kstar; /* nstar*(nstar-1)/2, number of separations */\n\tdouble *m; /* m[nstar] */\n\tdouble *M; /* M[kstar] */\n\tdouble **amat; /* amat[nstar][kstar] */\n\tdouble **Tmat; /* Tmat[kstar][kstar] */\n\tdouble Einit; /* initial energy used in integration scheme */\n} fb_ks_params_t;\n\n/* parameters for the non-regularized integrator */\ntypedef struct{\n\tint nstar; /* number of actual stars */\n\tdouble *m; /* m[nstar] */\n} fb_nonks_params_t;\n\n/* the hierarchy data structure */\ntypedef struct{\n\tint nstarinit; /* initial number of stars (may not equal nstar if there are collisions) */\n\tint nstar; /* number of stars */\n\tint nobj; /* number of binary trees */\n\tint *hi; /* hierarchical index array */\n\tint *narr; /* narr[i] = number of hierarchical objects with i elements */\n\tfb_obj_t *hier; /* memory location of hierarchy information */\n\tfb_obj_t **obj; /* array of pointers to top nodes of binary trees */\n} fb_hier_t;\n\n/* input parameters */\ntypedef struct{\n\tint ks; /* 0=no regularization, 1=K-S regularization */\n\tdouble tstop; /* stopping time, in units of t_dyn */\n\tint Dflag; /* 0=don't print to stdout, 1=print to stdout */\n\tdouble dt; /* time interval between printouts will always be greater than this value */\n\tdouble tcpustop; /* cpu stopping time, in units of seconds */\n\tdouble absacc; /* absolute accuracy of the integrator */\n\tdouble relacc; /* relative accuracy of the integrator */\n\tint ncount; /* number of integration steps between each call to fb_classify() */\n\tdouble tidaltol; /* tidal tolerance */\n\tchar firstlogentry[FB_MAX_LOGENTRY_LENGTH]; /* first entry to put in printout log */\n\tdouble fexp; /* expansion factor for a merger product: R = f_exp (R_1+R_2) */\n} fb_input_t;\n\n/* return parameters */\ntypedef struct{\n\tlong count; /* number of integration steps */\n\tint retval; /* return value; 1=success, 0=failure */\n\tlong iclassify; /* number of times classify was called */\n\tdouble tcpu; /* cpu time taken */\n\tdouble DeltaE; /* change in energy */\n\tdouble DeltaEfrac; /* change in energy, as a fraction of initial energy */\n\tdouble DeltaL; /* change in ang. mom. */\n\tdouble DeltaLfrac; /* change in ang. mom., as a fraction of initial ang. mom. */\n\tdouble Rmin; /* minimum distance of close approach during interaction */\n\tint Rmin_i; /* index of star i participating in minimum close approach */\n\tint Rmin_j; /* index of star j participating in minimum close approach */\n\tint Nosc; /* number of oscillations of the quantity s^2 (McMillan & Hut 1996) (Nosc=Nmin-1, so resonance if Nosc>=1) */\n} fb_ret_t;\n\n/* fewbody.c */\nfb_ret_t fewbody(fb_input_t input, fb_hier_t *hier, double *t);\n\n/* fewbody_classify.c */\nint fb_classify(fb_hier_t *hier, double t, double tidaltol);\nint fb_is_stable(fb_obj_t *obj);\nint fb_is_stable_binary(fb_obj_t *obj);\nint fb_is_stable_triple(fb_obj_t *obj);\nint fb_is_stable_quad(fb_obj_t *obj);\nint fb_mardling(fb_obj_t *obj, int ib, int is);\n\n/* fewbody_coll.c */\nint fb_is_collision(double r, double R1, double R2);\nint fb_collide(fb_hier_t *hier, double f_exp);\nvoid fb_merge(fb_obj_t *obj1, fb_obj_t *obj2, int nstarinit, double f_exp);\n\n/* fewbody_hier.c */\nvoid fb_malloc_hier(fb_hier_t *hier);\nvoid fb_init_hier(fb_hier_t *hier);\nvoid fb_free_hier(fb_hier_t hier);\nvoid fb_trickle(fb_hier_t *hier, double t);\nvoid fb_elkcirt(fb_hier_t *hier, double t);\nint fb_create_indices(int *hi, int nstar);\nint fb_n_hier(fb_obj_t *obj);\nchar *fb_sprint_hier(fb_hier_t hier, char string[FB_MAX_STRING_LENGTH]);\nchar *fb_sprint_hier_hr(fb_hier_t hier, char string[FB_MAX_STRING_LENGTH]);\nvoid fb_upsync(fb_obj_t *obj, double t);\nvoid fb_randorient(fb_obj_t *obj, gsl_rng *rng);\nvoid fb_downsync(fb_obj_t *obj, double t);\nvoid fb_objcpy(fb_obj_t *obj1, fb_obj_t *obj2);\n\n/* fewbody_int.c */\nvoid fb_malloc_ks_params(fb_ks_params_t *ks_params);\nvoid fb_init_ks_params(fb_ks_params_t *ks_params, fb_hier_t hier);\nvoid fb_free_ks_params(fb_ks_params_t ks_params);\nvoid fb_malloc_nonks_params(fb_nonks_params_t *nonks_params);\nvoid fb_init_nonks_params(fb_nonks_params_t *nonks_params, fb_hier_t hier);\nvoid fb_free_nonks_params(fb_nonks_params_t nonks_params);\n\n/* fewbody_io.c */\nvoid fb_print_version(FILE *stream);\nvoid fb_print_story(fb_obj_t *star, int nstar, double t, char *logentry);\n\n/* fewbody_isolate.c */\nint fb_collapse(fb_hier_t *hier, double t, double tidaltol);\nint fb_expand(fb_hier_t *hier, double t, double tidaltol);\n\n/* fewbody_ks.c */\ndouble fb_ks_dot(double x[4], double y[4]);\ndouble fb_ks_mod(double x[4]);\nvoid fb_calc_Q(double q[4], double Q[4]);\nvoid fb_calc_ksmat(double Q[4], double Qmat[4][4]);\nvoid fb_calc_amat(double **a, int nstar, int kstar);\nvoid fb_calc_Tmat(double **a, double *m, double **T, int nstar, int kstar);\nint fb_ks_func(double s, const double *y, double *f, void *params);\ndouble fb_ks_Einit(const double *y, fb_ks_params_t params);\nvoid fb_euclidean_to_ks(fb_obj_t **star, double *y, int nstar, int kstar);\nvoid fb_ks_to_euclidean(double *y, fb_obj_t **star, int nstar, int kstar);\n\n/* fewbody_nonks.c */\nint fb_nonks_func(double t, const double *y, double *f, void *params);\nint fb_nonks_jac(double t, const double *y, double *dfdy, double *dfdt, void *params);\nvoid fb_euclidean_to_nonks(fb_obj_t **star, double *y, int nstar);\nvoid fb_nonks_to_euclidean(double *y, fb_obj_t **star, int nstar);\n\n/* fewbody_scat.c */\nvoid fb_init_scattering(fb_obj_t *obj0, fb_obj_t *obj1, double vinf, double b, double rtid);\nvoid fb_normalize(fb_hier_t *hier, fb_units_t units);\n\n/* fewbody_utils.c */\ndouble *fb_malloc_vector(int n);\ndouble **fb_malloc_matrix(int nr, int nc);\nvoid fb_free_vector(double *v);\nvoid fb_free_matrix(double **m);\ndouble fb_sqr(double x);\ndouble fb_cub(double x);\ndouble fb_dot(double x[3], double y[3]);\ndouble fb_mod(double x[3]);\nint fb_cross(double x[3], double y[3], double z[3]);\nint fb_angmom(fb_obj_t *star, int nstar, double L[3]);\nvoid fb_angmomint(fb_obj_t *star, int nstar, double L[3]);\ndouble fb_einttot(fb_obj_t *star, int nstar);\ndouble fb_petot(fb_obj_t *star, int nstar);\ndouble fb_ketot(fb_obj_t *star, int nstar);\ndouble fb_outerpetot(fb_obj_t **obj, int nobj);\ndouble fb_outerketot(fb_obj_t **obj, int nobj);\ndouble fb_kepler(double e, double mean_anom);\ndouble fb_keplerfunc(double mean_anom, void *params);\ndouble fb_reltide(fb_obj_t *bin, fb_obj_t *single, double r);\n\n/* fewbody_ui.c */\nint fbui_new_hier(fb_hier_t *hier, int n);\nint fbui_delete_hier(fb_hier_t *hier);\nfb_obj_t *fbui_hierarchy_element(fb_hier_t *hier, int n, int m);\nfb_obj_t *fbui_hierarchy_single(fb_hier_t *hier, int m);\nfb_obj_t *fbui_hierarchy_binary(fb_hier_t *hier, int m);\nfb_obj_t *fbui_hierarchy_triple(fb_hier_t *hier, int m);\nfb_obj_t *fbui_hierarchy_quadruple(fb_hier_t *hier, int m);\nfb_obj_t *fbui_hierarchy_quintuple(fb_hier_t *hier, int m);\nfb_obj_t *fbui_hierarchy_sextuple(fb_hier_t *hier, int m);\nfb_obj_t *fbui_hierarchy_septuple(fb_hier_t *hier, int m);\nfb_obj_t *fbui_hierarchy_octuple(fb_hier_t *hier, int m);\nfb_obj_t *fbui_hierarchy_nonuple(fb_hier_t *hier, int m);\nfb_obj_t *fbui_hierarchy_decuple(fb_hier_t *hier, int m);\nint fbui_make_pair(fb_obj_t *parentobj, fb_obj_t *obj1, fb_obj_t *obj2);\nint fbui_initialize_single(fb_obj_t *single, long id, char idstring[FB_MAX_STRING_LENGTH]);\nfb_obj_t *fbui_tree(fb_hier_t *hier, int n);\nint fbui_obj_ncoll_set(fb_obj_t *obj, int ncoll);\nint fbui_obj_ncoll_get(fb_obj_t *obj);\nint fbui_obj_id_set(fb_obj_t *obj, int index, long id);\nlong fbui_obj_id_get(fb_obj_t *obj, int index);\nint fbui_obj_idstring_set(fb_obj_t *obj, char idstring[FB_MAX_STRING_LENGTH]);\nchar *fbui_obj_idstring_get(fb_obj_t *obj);\nint fbui_obj_mass_set(fb_obj_t *obj, double mass);\ndouble fbui_obj_mass_get(fb_obj_t *obj);\nint fbui_obj_radius_set(fb_obj_t *obj, double radius);\ndouble fbui_obj_radius_get(fb_obj_t *obj);\nint fbui_obj_Eint_set(fb_obj_t *obj, double Eint);\ndouble fbui_obj_Eint_get(fb_obj_t *obj);\nint fbui_obj_Lint_set(fb_obj_t *obj, double Lint[3]);\nint fbui_obj_Linti_set(fb_obj_t *obj, double Lint0, double Lint1, double Lint2);\ndouble *fbui_obj_Lint_get(fb_obj_t *obj);\nint fbui_obj_x_set(fb_obj_t *obj, double x[3]);\nint fbui_obj_xi_set(fb_obj_t *obj, double x0, double x1, double x2);\ndouble *fbui_obj_x_get(fb_obj_t *obj);\nint fbui_obj_v_set(fb_obj_t *obj, double v[3]);\nint fbui_obj_vi_set(fb_obj_t *obj, double v0, double v1, double v2);\ndouble *fbui_obj_v_get(fb_obj_t *obj);\nint fbui_obj_n_set(fb_obj_t *obj, int n);\nint fbui_obj_n_get(fb_obj_t *obj);\nint fbui_obj_obj_set(fb_obj_t *obj, int i, fb_obj_t *objtopointto);\nint fbui_obj_left_child_set(fb_obj_t *obj, fb_obj_t *objtopointto);\nint fbui_obj_right_child_set(fb_obj_t *obj, fb_obj_t *objtopointto);\nfb_obj_t *fbui_obj_obj_get(fb_obj_t *obj, int i);\nfb_obj_t *fbui_obj_left_child_get(fb_obj_t *obj);\nfb_obj_t *fbui_obj_right_child_get(fb_obj_t *obj);\nint fbui_obj_a_set(fb_obj_t *obj, double a);\ndouble fbui_obj_a_get(fb_obj_t *obj);\nint fbui_obj_e_set(fb_obj_t *obj, double e);\ndouble fbui_obj_e_get(fb_obj_t *obj);\nint fbui_obj_Lhat_set(fb_obj_t *obj, double Lhat[3]);\nint fbui_obj_Lhati_set(fb_obj_t *obj, double Lhat0, double Lhat1, double Lhat2);\ndouble *fbui_obj_Lhat_get(fb_obj_t *obj);\nint fbui_obj_Ahat_set(fb_obj_t *obj, double Ahat[3]);\nint fbui_obj_Ahati_set(fb_obj_t *obj, double Ahat0, double Ahat1, double Ahat2);\ndouble *fbui_obj_Ahat_get(fb_obj_t *obj);\nint fbui_obj_t_set(fb_obj_t *obj, double t);\ndouble fbui_obj_t_get(fb_obj_t *obj);\nint fbui_obj_mean_anom_set(fb_obj_t *obj, double mean_anom);\ndouble fbui_obj_mean_anom_get(fb_obj_t *obj);\n\n/* macros */\n/* The variadic macro syntax here conforms to the C99 standard, but for some\n   reason won't compile on Mac OSX with gcc. */\n/* #define fb_dprintf(...) if (fb_debug) fprintf(stderr, __VA_ARGS__) */\n/* The variadic macro syntax here is the old gcc standard, and compiles on\n   Mac OSX with gcc. */\n#define fb_dprintf(args...) if (fb_debug) fprintf(stderr, args)\n#define FB_MIN(a, b) ((a)<=(b)?(a):(b))\n#define FB_MAX(a, b) ((a)>=(b)?(a):(b))\n#define FB_DELTA(i, j) ((i)==(j)?1:0)\n#define FB_KS_K(i, j, nstar) ((i)*(nstar)-((i)+1)*((i)+2)/2+(j))\n\n/* there is just one global variable */\nextern int fb_debug;\n\n#endif /* fewbody.h */\n", "meta": {"hexsha": "a4b4a5dcef440b54f73a6fa2831aca74a7887d88", "size": 12990, "ext": "h", "lang": "C", "max_stars_repo_path": "ext/fewbod/fewbody-0.26/fewbody.h", "max_stars_repo_name": "gnodvi/cosmos", "max_stars_repo_head_hexsha": "3612456fc2042519f96a49e4d4cc6d3c1f41de7c", "max_stars_repo_licenses": ["PSF-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "ext/fewbod/fewbody-0.26/fewbody.h", "max_issues_repo_name": "gnodvi/cosmos", "max_issues_repo_head_hexsha": "3612456fc2042519f96a49e4d4cc6d3c1f41de7c", "max_issues_repo_licenses": ["PSF-2.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-12-13T20:35:46.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-13T20:35:46.000Z", "max_forks_repo_path": "ext/fewbod/fewbody-0.26/fewbody.h", "max_forks_repo_name": "gnodvi/cosmos", "max_forks_repo_head_hexsha": "3612456fc2042519f96a49e4d4cc6d3c1f41de7c", "max_forks_repo_licenses": ["PSF-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.6346153846, "max_line_length": 120, "alphanum_fraction": 0.7469591994, "num_tokens": 3867, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4726834766204328, "lm_q2_score": 0.024053552938151732, "lm_q1q2_score": 0.011369717027879186}}
{"text": "/* -*- linux-c -*- */\n/* cluster.c\n\n   Copyright (C) 2002-2004 John M. Fregeau\n   \n   This program is free software; you can redistribute it and/or modify\n   it under the terms of the GNU General Public License as published by\n   the Free Software Foundation; either version 2 of the License, or\n   (at your option) any later version.\n   \n   This program is distributed in the hope that it will be useful,\n   but WITHOUT ANY WARRANTY; without even the implied warranty of\n   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n   GNU General Public License for more details.\n   \n   You should have received a copy of the GNU General Public License\n   along with this program; if not, write to the Free Software\n   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\n*/\n\n#include <stdio.h>\n#include <stddef.h>\n#include <stdlib.h>\n#include <string.h>\n#include <math.h>\n#include <time.h>\n#include <getopt.h>\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_rng.h>\n#include <gsl/gsl_roots.h>\n#include \"fewbody.h\"\n#include \"cluster.h\"\n\n/* print the usage */\nvoid print_usage(FILE *stream)\n{\n\tfprintf(stream, \"USAGE:\\n\");\n\tfprintf(stream, \"  cluster [options...]\\n\");\n\tfprintf(stream, \"\\n\");\n\tfprintf(stream, \"OPTIONS:\\n\");\n\tfprintf(stream, \"  -n --n <n>                    : set number of stars in cluster [%d]\\n\", FB_N);\n\tfprintf(stream, \"  -m --m <m/MSUN>               : set mass of each star [%.6g]\\n\", FB_M/FB_CONST_MSUN);\n\tfprintf(stream, \"  -r --r <r/RSUN>               : set radius of each star [%.6g]\\n\", FB_R/FB_CONST_RSUN);\n\tfprintf(stream, \"  -S --sigma <sigma/(km/s)>     : set central velocity dispersion [%.6g]\\n\", FB_SIGMA/1.0e5);\n\tfprintf(stream, \"  -T --rmax <rmax/PARSEC>       : set truncation radius [%.6g]\\n\", FB_RMAX/FB_CONST_PARSEC);\n\tfprintf(stream, \"  -t --tstop <tstop/t_dyn>      : set stopping time [%.6g]\\n\", FB_TSTOP);\n\tfprintf(stream, \"  -P --tphysstop <tphysstop/yr> : set physical stopping time [%.6g]\\n\", FB_TPHYSSTOP/FB_CONST_YR);\n\tfprintf(stream, \"  -D --dt <dt/t_dyn>            : set approximate output dt [%.6g]\\n\", FB_DT);\n\tfprintf(stream, \"  -c --tcpustop <tcpustop/sec>  : set cpu stopping time [%.6g]\\n\", FB_TCPUSTOP);\n\tfprintf(stream, \"  -A --absacc <absacc>          : set integrator's absolute accuracy [%.6g]\\n\", FB_ABSACC);\n\tfprintf(stream, \"  -R --relacc <relacc>          : set integrator's relative accuracy [%.6g]\\n\", FB_RELACC);\n\tfprintf(stream, \"  -N --ncount <ncount>          : set number of integration steps between calls\\n\");\n\tfprintf(stream, \"                                  to fb_classify() [%d]\\n\", FB_NCOUNT);\n\tfprintf(stream, \"  -z --tidaltol <tidaltol>      : set tidal tolerance [%.6g]\\n\", FB_TIDALTOL);\n\tfprintf(stream, \"  -x --fexp <f_exp>             : set expansion factor of merger product [%.6g]\\n\", FB_FEXP);\n\tfprintf(stream, \"  -k --ks                       : turn K-S regularization on or off [%d]\\n\", FB_KS);\n\tfprintf(stream, \"  -s --seed                     : set random seed [%ld]\\n\", FB_SEED);\n\tfprintf(stream, \"  -d --debug                    : turn on debugging\\n\");\n\tfprintf(stream, \"  -V --version                  : print version info\\n\");\n\tfprintf(stream, \"  -h --help                     : display this help text\\n\");\n}\n\n/* calculate the units used (N-body units) */\nvoid calc_units(fb_hier_t hier, fb_units_t *units)\n{\n\tint i, j, k;\n\tdouble petot, ketot, r[3];\n\n\t/* the unit of mass is defined so that M_tot=1 */\n\tunits->m = 0.0;\n\tfor (i=0; i<hier.nstar; i++) {\n\t\tunits->m += hier.hier[hier.hi[1]+i].m;\n\t}\n\n\t/* calculate total potential and kinetic energy */\n\tpetot = 0.0;\n\tfor (i=0; i<hier.nstar-1; i++) {\n\t\tfor (j=i+1; j<hier.nstar; j++) {\n\t\t\tfor (k=0; k<3; k++) {\n\t\t\t\tr[k] = hier.hier[hier.hi[1]+j].x[k] - hier.hier[hier.hi[1]+i].x[k];\n\t\t\t}\n\t\t\tpetot += - FB_CONST_G * hier.hier[hier.hi[1]+i].m * hier.hier[hier.hi[1]+j].m / fb_mod(r);\n\t\t}\n\t}\n\n\tketot = 0.0;\n\tfor (i=0; i<hier.nstar; i++) {\n\t\tketot += 0.5 * hier.hier[hier.hi[1]+i].m * fb_dot(hier.hier[hier.hi[1]+i].v, hier.hier[hier.hi[1]+i].v);\n\t}\n\t\n\t/* the unit of energy is defined so that E=-1/4 */\n\tunits->E = -4.0 * (petot + ketot);\n\t\n\t/* with G=1, all other units are derived */\n\tunits->t = FB_CONST_G * pow(units->m, 2.5) * pow(units->E, -1.5);\n\tunits->l = FB_CONST_G * fb_sqr(units->m) / units->E;\n\tunits->v = units->l / units->t;\n}\n\n/* f_0-f(v/v_esc) for the Plummer model */\ndouble fv(double v, void *params)\n{\n\tdouble f;\n\t\n\tf = ((double *)params)[0];\n\treturn(f - 512.0/(7.0*FB_CONST_PI) * (sqrt(1.0-fb_sqr(v))*(-7.0*v/256.0 + 121.0*fb_cub(v)/384.0 - 263.0*fb_sqr(v)*fb_cub(v)/480.0 + 31.0*v*fb_sqr(fb_cub(v))/80.0 - fb_cub(fb_cub(v))/10.0) + 7.0*asin(v)/256.0));\n}\n\n/* get speed from Plummer distribution */\ndouble vf(double f)\n{\n\tint status, iter;\n\tdouble v, params[1];\n\tgsl_function F;\n\tconst gsl_root_fsolver_type *T;\n\tgsl_root_fsolver *s;\n\t\n\t/* set up the root solver */\n\tF.function = &fv;\n\tF.params = &params;\n\n\t/* set the parameters */\n\tparams[0] = f;\n\n\tT = gsl_root_fsolver_brent;\n\ts = gsl_root_fsolver_alloc(T);\n\tgsl_root_fsolver_set(s, &F, 0.0, 1.0);\n\t\n\t/* get v/v_esc by root-finding */\n\titer = 0;\n\tdo {\n\t\titer++;\n\t\tgsl_root_fsolver_iterate(s);\n\t\tstatus = gsl_root_test_interval(gsl_root_fsolver_x_lower(s), gsl_root_fsolver_x_upper(s), \\\n\t\t\t\t\t\tFB_ROOTSOLVER_ABS_ACC, FB_ROOTSOLVER_REL_ACC);\n\t} while (status == GSL_CONTINUE && iter < FB_ROOTSOLVER_MAX_ITER);\n\n\tif (iter >= FB_ROOTSOLVER_MAX_ITER) {\n\t\tfprintf(stderr, \"Root finder failed to converge.\\n\");\n\t\texit(1);\n\t}\n\n\t/* we've got the root */\n\tv = gsl_root_fsolver_root(s);\n\t\n\t/* free memory associated with root solver */\n\tgsl_root_fsolver_free(s);\n\n\treturn(v);\n}\n\n/* the main attraction */\nint main(int argc, char *argv[])\n{\n\tint i, j, n;\n\tunsigned long int seed;\n\tdouble tphysstop, m, r, Ei, Li[3], Lint[3], t, M, a, sigma, rmax, Xmax, radius, v, theta, phi, xcm[3], vcm[3];\n\tfb_hier_t hier;\n\tfb_input_t input;\n\tfb_ret_t retval;\n\tfb_units_t units;\n\tchar string1[FB_MAX_STRING_LENGTH], string2[FB_MAX_STRING_LENGTH];\n\tgsl_rng *rng;\n\tconst gsl_rng_type *rng_type=gsl_rng_mt19937;\n\tconst char *short_opts = \"n:m:r:S:T:t:P:D:c:A:R:N:z:x:k:s:dVh\";\n\tconst struct option long_opts[] = {\n\t\t{\"n\", required_argument, NULL, 'n'},\n\t\t{\"m\", required_argument, NULL, 'm'},\n\t\t{\"r\", required_argument, NULL, 'r'},\n\t\t{\"sigma\", required_argument, NULL, 'S'},\n\t\t{\"rmax\", required_argument, NULL, 'T'},\n\t\t{\"tstop\", required_argument, NULL, 't'},\n\t\t{\"tphysstop\", required_argument, NULL, 'P'},\n\t\t{\"dt\", required_argument, NULL, 'D'},\n\t\t{\"tcpustop\", required_argument, NULL, 'c'},\n\t\t{\"absacc\", required_argument, NULL, 'A'},\n\t\t{\"relacc\", required_argument, NULL, 'R'},\n\t\t{\"ncount\", required_argument, NULL, 'N'},\n\t\t{\"tidaltol\", required_argument, NULL, 'z'},\n\t\t{\"fexp\", required_argument, NULL, 'x'},\n\t\t{\"ks\", required_argument, NULL, 'k'},\n\t\t{\"seed\", required_argument, NULL, 's'},\n\t\t{\"debug\", no_argument, NULL, 'd'},\n\t\t{\"version\", no_argument, NULL, 'V'},\n\t\t{\"help\", no_argument, NULL, 'h'},\n\t\t{NULL, 0, NULL, 0}\n\t};\n\n\t/* set parameters to default values */\n\tn = FB_N;\n\tm = FB_M;\n\tr = FB_R;\n\tsigma = FB_SIGMA;\n\trmax = FB_RMAX;\n\tinput.ks = FB_KS;\n\tinput.tstop = FB_TSTOP;\n\ttphysstop = FB_TPHYSSTOP;\n\tinput.Dflag = 0;\n\tinput.dt = FB_DT;\n\tinput.tcpustop = FB_TCPUSTOP;\n\tinput.absacc = FB_ABSACC;\n\tinput.relacc = FB_RELACC;\n\tinput.ncount = FB_NCOUNT;\n\tinput.tidaltol = FB_TIDALTOL;\n\tinput.fexp = FB_FEXP;\n\tseed = FB_SEED;\n\tfb_debug = FB_DEBUG;\n\t\n\twhile ((i = getopt_long(argc, argv, short_opts, long_opts, NULL)) != -1) {\n\t\tswitch (i) {\n\t\tcase 'n':\n\t\t\tn = atoi(optarg);\n\t\t\tbreak;\n\t\tcase 'm':\n\t\t\tm = atof(optarg) * FB_CONST_MSUN;\n\t\t\tbreak;\n\t\tcase 'r':\n\t\t\tr = atof(optarg) * FB_CONST_RSUN;\n\t\t\tbreak;\n\t\tcase 'S':\n\t\t\tsigma = atof(optarg) * 1.0e5;\n\t\t\tbreak;\n\t\tcase 'T':\n\t\t\trmax = atof(optarg) * FB_CONST_PARSEC;\n\t\t\tbreak;\n\t\tcase 't':\n\t\t\tinput.tstop = atof(optarg);\n\t\t\tbreak;\n\t\tcase 'P':\n\t\t\ttphysstop = atof(optarg) * FB_CONST_YR;\n\t\t\tbreak;\n\t\tcase 'D':\n\t\t\tinput.Dflag = 1;\n\t\t\tinput.dt = atof(optarg);\n\t\t\tbreak;\n\t\tcase 'c':\n\t\t\tinput.tcpustop = atof(optarg);\n\t\t\tbreak;\n\t\tcase 'A':\n\t\t\tinput.absacc = atof(optarg);\n\t\t\tbreak;\n\t\tcase 'R':\n\t\t\tinput.relacc = atof(optarg);\n\t\t\tbreak;\n\t\tcase 'N':\n\t\t\tinput.ncount = atoi(optarg);\n\t\t\tbreak;\n\t\tcase 'z':\n\t\t\tinput.tidaltol = atof(optarg);\n\t\t\tbreak;\n\t\tcase 'x':\n\t\t\tinput.fexp = atof(optarg);\n\t\t\tbreak;\n\t\tcase 'k':\n\t\t\tinput.ks = atoi(optarg);\n\t\t\tbreak;\n\t\tcase 's':\n\t\t\tseed = atol(optarg);\n\t\t\tbreak;\n\t\tcase 'd':\n\t\t\tfb_debug = 1;\n\t\t\tbreak;\n\t\tcase 'V':\n\t\t\tfb_print_version(stdout);\n\t\t\treturn(0);\n\t\tcase 'h':\n\t\t\tfb_print_version(stdout);\n\t\t\tfprintf(stdout, \"\\n\");\n\t\t\tprint_usage(stdout);\n\t\t\treturn(0);\n\t\tdefault:\n\t\t\tbreak;\n\t\t}\n\t}\n\t\n\t/* check to make sure there was nothing crazy on the command line */\n\tif (optind < argc) {\n\t\tprint_usage(stdout);\n\t\treturn(1);\n\t}\n\n\t/* set up parameters for Plummer model */\n\tM = ((double) n) * m;\n\ta = FB_CONST_G * M / (6.0*fb_sqr(sigma));\n\tXmax = pow(1.0+fb_sqr(a/rmax), -1.5);\n\t\n\t/* initialize a few things for integrator */\n\tt = 0.0;\n\thier.nstarinit = n;\n\thier.nstar = n;\n\tfb_malloc_hier(&hier);\n\tfb_init_hier(&hier);\n\n\t/* put stuff in log entry */\n\tsnprintf(input.firstlogentry, FB_MAX_LOGENTRY_LENGTH, \"  command line:\");\n\tfor (i=0; i<argc; i++) {\n\t\tsnprintf(&(input.firstlogentry[strlen(input.firstlogentry)]), \n\t\t\t FB_MAX_LOGENTRY_LENGTH-strlen(input.firstlogentry), \" %s\", argv[i]);\n\t}\n\tsnprintf(&(input.firstlogentry[strlen(input.firstlogentry)]),\n\t\t FB_MAX_LOGENTRY_LENGTH-strlen(input.firstlogentry), \"\\n\");\n\t\n\t/* print out values of paramaters */\n\tfprintf(stderr, \"PARAMETERS:\\n\");\n\tfprintf(stderr, \"  ks=%d  seed=%ld\\n\", input.ks, seed);\n\tfprintf(stderr, \"  M=%.6g MSUN  sigma=%.6g km/s  a=%.6g PARSEC  rmax=%.6g PARSEC  rmax/a=%.6g\\n\",\n\t\tM/FB_CONST_MSUN, sigma/1.0e5, a/FB_CONST_PARSEC, rmax/FB_CONST_PARSEC, rmax/a);\n\tfprintf(stderr, \"  n=%d  m=%.6g MSUN  r=%.6g RSUN  tstop=%.6g  tphysstop=%.6g yr  tcpustop=%.6g\\n\", \\\n\t\tn, m/FB_CONST_MSUN, r/FB_CONST_RSUN, input.tstop, tphysstop/FB_CONST_YR, input.tcpustop);\n\tfprintf(stderr, \"  tidaltol=%.6g  abs_acc=%.6g  rel_acc=%.6g  ncount=%d  fexp=%.6g\\n\\n\", \\\n\t\tinput.tidaltol, input.absacc, input.relacc, input.ncount, input.fexp);\n\n\t/* initialize GSL rng */\n\tgsl_rng_env_setup();\n\trng = gsl_rng_alloc(rng_type);\n\tgsl_rng_set(rng, seed);\n\n\t/* prepare to calculate the center of mass position and velocity */\n\tfor (i=0; i<3; i++) {\n\t\txcm[i] = 0.0;\n\t\tvcm[i] = 0.0;\n\t}\n\n\t/* give the objects some properties */\n\tfor (j=0; j<hier.nstar; j++) {\n\t\thier.hier[hier.hi[1]+j].ncoll = 1;\n\t\thier.hier[hier.hi[1]+j].id[0] = j;\n\t\tsnprintf(hier.hier[hier.hi[1]+j].idstring, FB_MAX_STRING_LENGTH, \"%d\", j);\n\t\thier.hier[hier.hi[1]+j].n = 1;\n\t\thier.hier[hier.hi[1]+j].obj[0] = NULL;\n\t\thier.hier[hier.hi[1]+j].obj[1] = NULL;\n\t\thier.hier[hier.hi[1]+j].Eint = 0.0;\n\t\thier.hier[hier.hi[1]+j].Lint[0] = 0.0;\n\t\thier.hier[hier.hi[1]+j].Lint[1] = 0.0;\n\t\thier.hier[hier.hi[1]+j].Lint[2] = 0.0;\n\t\thier.hier[hier.hi[1]+j].m = m;\n\t\thier.hier[hier.hi[1]+j].R = r;\n\t\t\n\t\t/* draw radius from Plummer distribution */\n\t\tradius = a / sqrt(pow(Xmax*gsl_rng_uniform(rng), -2.0/3.0)-1.0);\n\t\ttheta = acos(2.0 * gsl_rng_uniform(rng) - 1.0);\n\t\tphi = 2.0 * FB_CONST_PI * gsl_rng_uniform(rng);\n\t\thier.hier[hier.hi[1]+j].x[0] = radius * sin(theta) * cos(phi);\n\t\thier.hier[hier.hi[1]+j].x[1] = radius * sin(theta) * sin(phi);\n\t\thier.hier[hier.hi[1]+j].x[2] = radius * cos(theta);\n\n\t\t/* draw velocity from Plummer distribution */\n\t\tv = vf(gsl_rng_uniform(rng)) * sqrt(2.0*FB_CONST_G*M/(a*sqrt(1.0+fb_sqr(radius/a))));\n\t\ttheta = acos(2.0 * gsl_rng_uniform(rng) - 1.0);\n\t\tphi = 2.0 * FB_CONST_PI * gsl_rng_uniform(rng);\n\t\thier.hier[hier.hi[1]+j].v[0] = v * sin(theta) * cos(phi);\n\t\thier.hier[hier.hi[1]+j].v[1] = v * sin(theta) * sin(phi);\n\t\thier.hier[hier.hi[1]+j].v[2] = v * cos(theta);\n\t\t\n\t\t/* calculate center of mass position and velocity */\n\t\tfor (i=0; i<3; i++) {\n\t\t\txcm[i] += hier.hier[hier.hi[1]+j].x[i] / ((double) n);\n\t\t\tvcm[i] += hier.hier[hier.hi[1]+j].v[i] / ((double) n);\n\t\t}\n\t}\n\t\n\t/* transform to center of mass frame */\n\tfor (j=0; j<hier.nstar; j++) {\n\t\tfor (i=0; i<3; i++) {\n\t\t\thier.hier[hier.hi[1]+j].x[i] -= xcm[i];\n\t\t\thier.hier[hier.hi[1]+j].v[i] -= vcm[i];\n\t\t}\n\t}\n\n\t/* get the units and normalize */\n\tcalc_units(hier, &units);\n\tfb_normalize(&hier, units);\n\t\n\t/* reset input.tstop if necessary, based on the value of tphysstop */\n\tif (tphysstop/units.t < input.tstop) {\n\t\tinput.tstop = tphysstop/units.t;\n\t\tfb_dprintf(\"decreasing tstop in accord with tphysstop: tstop=%.6g\\n\", input.tstop);\n\t}\n\n\tfb_dprintf(\"virial ratio: q=%.6g\\n\", -fb_ketot(&(hier.hier[hier.hi[1]]), hier.nstar)/fb_petot(&(hier.hier[hier.hi[1]]), hier.nstar));\n\n\tfprintf(stderr, \"UNITS:\\n\");\n\tfprintf(stderr, \"  v=%.6g km/s  l=%.6g AU  t=t_dyn=%.6g yr\\n\", \\\n\t\tunits.v/1.0e5, units.l/FB_CONST_AU, units.t/FB_CONST_YR);\n\tfprintf(stderr, \"  M=%.6g M_sun  E=%.6g erg\\n\\n\", units.m/FB_CONST_MSUN, units.E);\n\n\t/* calculate the initial energy and angular momentum, for bookkeeping */\n\tEi = fb_petot(&(hier.hier[hier.hi[1]]), hier.nstar) + fb_ketot(&(hier.hier[hier.hi[1]]), hier.nstar) +\n\t\tfb_einttot(&(hier.hier[hier.hi[1]]), hier.nstar);\n\tfb_angmom(&(hier.hier[hier.hi[1]]), hier.nstar, Li);\n\tfb_angmomint(&(hier.hier[hier.hi[1]]), hier.nstar, Lint);\n\tfor (j=0; j<3; j++) {\n\t\tLi[j] += Lint[j];\n\t}\n\n\t/* integrate along */\n\tfb_dprintf(\"calling fewbody()...\\n\");\n\t\n\t/* call fewbody! */\n\tretval = fewbody(input, &hier, &t);\n\n\t/* print information to screen */\n\tfprintf(stderr, \"OUTCOME:\\n\");\n\tif (retval.retval == 1) {\n\t\tfprintf(stderr, \"  encounter complete:  t=%.6g (%.6g yr)  %s  (%s)\\n\\n\",\n\t\t\tt, t * units.t/FB_CONST_YR,\n\t\t\tfb_sprint_hier(hier, string1),\n\t\t\tfb_sprint_hier_hr(hier, string2));\n\t} else {\n\t\tfprintf(stderr, \"  encounter NOT complete:  t=%.6g (%.6g yr)  %s  (%s)\\n\\n\",\n\t\t\tt, t * units.t/FB_CONST_YR,\n\t\t\tfb_sprint_hier(hier, string1),\n\t\t\tfb_sprint_hier_hr(hier, string2));\n\t}\n\n\tfb_dprintf(\"there were %ld integration steps\\n\", retval.count);\n\tfb_dprintf(\"fb_classify() was called %ld times\\n\", retval.iclassify);\n\t\n\tfprintf(stderr, \"FINAL:\\n\");\n\tfprintf(stderr, \"  t_final=%.6g (%.6g yr)  t_cpu=%.6g s\\n\", \\\n\t\tt, t*units.t/FB_CONST_YR, retval.tcpu);\n\n\tfprintf(stderr, \"  L0=%.6g  DeltaL/L0=%.6g  DeltaL=%.6g\\n\", fb_mod(Li), retval.DeltaLfrac, retval.DeltaL);\n\tfprintf(stderr, \"  E0=%.6g  DeltaE/E0=%.6g  DeltaE=%.6g\\n\", Ei, retval.DeltaEfrac, retval.DeltaE);\n\tfprintf(stderr, \"  Rmin=%.6g (%.6g RSUN)  Rmin_i=%d  Rmin_j=%d\\n\", \\\n\t\tretval.Rmin, retval.Rmin*units.l/FB_CONST_RSUN, retval.Rmin_i, retval.Rmin_j);\n\tfprintf(stderr, \"  Nosc=%d (%s)\\n\", retval.Nosc, (retval.Nosc>=1?\"resonance\":\"non-resonance\"));\n\t\n\t/* free GSL stuff */\n\tgsl_rng_free(rng);\n\n\t/* free our own stuff */\n\tfb_free_hier(hier);\n\n\t/* done! */\n\treturn(0);\n}\n", "meta": {"hexsha": "c8f3d1f8bd175a8ec2e0a3af02c0698dc93d7964", "size": 14612, "ext": "c", "lang": "C", "max_stars_repo_path": "ext/fewbod/fewbody-0.26/cluster.c", "max_stars_repo_name": "gnodvi/cosmos", "max_stars_repo_head_hexsha": "3612456fc2042519f96a49e4d4cc6d3c1f41de7c", "max_stars_repo_licenses": ["PSF-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "ext/fewbod/fewbody-0.26/cluster.c", "max_issues_repo_name": "gnodvi/cosmos", "max_issues_repo_head_hexsha": "3612456fc2042519f96a49e4d4cc6d3c1f41de7c", "max_issues_repo_licenses": ["PSF-2.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-12-13T20:35:46.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-13T20:35:46.000Z", "max_forks_repo_path": "ext/fewbod/fewbody-0.26/cluster.c", "max_forks_repo_name": "gnodvi/cosmos", "max_forks_repo_head_hexsha": "3612456fc2042519f96a49e4d4cc6d3c1f41de7c", "max_forks_repo_licenses": ["PSF-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.3607305936, "max_line_length": 211, "alphanum_fraction": 0.6272926362, "num_tokens": 5080, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.41111086923216794, "lm_q2_score": 0.027585280627935107, "lm_q1q2_score": 0.011340608696963685}}
{"text": "#include <stdio.h>\n#include <cblas.h>\n#include <sys/time.h>\n#include <stdlib.h>\n#include <omp.h>\n\n\n#define NUM 64\n\n#define GEMM_K 320\n#define GEMM_N 4096\n#define GEMM_M 256\n\nvoid PACKA(float* A, float* Ac, long M, long K, long LK)\n{\n\tlong ii, jj, kk;\n\tfor( ii = 0 ; ii < M; ii = ii + 8)\n\t{\n\n\n\t\tfloat *temp = A + ii * LK + kk;\n\n\t\tasm volatile(\n\t\t\t\t\"\tldr\t\tx0, %[Ac]\t\t\t\t\t\t\t\\n\"\n\t\t\t\t\"\tldr\t\tx1, %[K]\t\t\t\t\t\t\t\\n\"\n\t\t\t\t\"\tldr\t\tx2, %[temp]\t\t\t\t\t\t\\n\"\n\t\t\t\t\"\tldr\t\tx30, %[LK]\t\t\t\t\t\t\\n\"\n\n\t\t\t\t\"\tadd\t\tx3, x2, x30, lsl #2\t\t\\n\"\n\t\t\t\t\"\tadd\t\tx4, x2, x30, lsl #3\t\t\\n\"\n\t\t\t\t\"\tadd\t\tx5, x3, x30, lsl #3\t\t\\n\"\n\t\t\t\t\"\tadd\t\tx6, x4, x30, lsl #3\t\t\\n\"\n\t\t\t\t\"\tadd\t\tx7, x5, x30, lsl #3\t\t\\n\"\n\t\t\t\t\"\tadd\t\tx8, x6, x30, lsl #3\t\t\\n\"\n\t\t\t\t\"\tadd\t\tx9, x7, x30, lsl #3\t\t\\n\"\n\n\n\n\t\t\t\t\"\tlsr\t\tx21, x1, #3\t\t\t\t\t\t\\n\"\n\t\t\t\t\"\tcmp\t\tx21, #0\t\t\t\t\t\t\t\t\\n\"\n\t\t\t\t\"\tbeq\t\tPACKA_END\t\t\t\t\t\t\t\\n\"\n\n\t\t\t\t\"PACKA:\t\t\t\t\t\t\t\t\t\t\t\t\\n\"\n\n\t\t\t\t\"\tprfm\tPLDL1KEEP, [x2, #128]\t\\n\"\n\t\t\t\t\"\tprfm\tPLDL1KEEP, [x3, #128]\t\\n\"\n\n\t\t\t\t\"\tldr\t\tq0, [x2], #16\t\t\t\t\t\\n\"\n\t\t\t\t\"\tldr\t\tq1, [x3], #16\t\t\t\t\t\\n\"\n\t\t\t\t\"\tldr\t\tq2, [x4], #16\t\t\t\t\t\\n\"\n\t\t\t\t\"\tldr\t\tq3, [x5], #16\t\t\t\t\t\\n\"\n\n\t\t\t\t\"\tprfm\tPLDL1KEEP, [x4, #128]\t\\n\"\n\t\t\t\t\"\tprfm\tPLDL1KEEP, [x5, #128]\t\\n\"\n\n\t\t\t\t\"\tst4\t\t{v0.s, v1.s, v2.s, v3.s}[0], [x0], #16\t\\n\"\n\n\t\t\t\t\"\tldr\t\tq4, [x6], #16\t\t\t\t\t\\n\"\n\t\t\t\t\"\tldr\t\tq5, [x7], #16\t\t\t\t\t\\n\"\n\t\t\t\t\"\tldr\t\tq6, [x8], #16\t\t\t\t\t\\n\"\n\t\t\t\t\"\tldr\t\tq7, [x9], #16\t\t\t\t\t\\n\"\n\n\t\t\t\t\"\tst4\t\t{v4.s, v5.s, v6.s, v7.s}[0], [x0], #16\t\\n\"\n\n\t\t\t\t\"\tprfm\tPLDL1KEEP, [x6, #128]\t\\n\"\n\t\t\t\t\"\tprfm\tPLDL1KEEP, [x7, #128]\t\\n\"\n\n\t\t\t\t\"\tldr\t\tq8, [x2], #16\t\t\t\t\t\\n\"\n\t\t\t\t\"\tst4\t\t{v0.s, v1.s, v2.s, v3.s}[1], [x0], #16\t\\n\"\n\t\t\t\t\"\tldr\t\tq9, [x3], #16\t\t\t\t\t\\n\"\n\t\t\t\t\"\tst4\t\t{v4.s, v5.s, v6.s, v7.s}[1], [x0], #16\t\\n\"\n\t\t\t\t\"\tldr\t\tq10, [x4], #16\t\t\t\t\\n\"\n\t\t\t\t\"\tst4\t\t{v0.s, v1.s, v2.s, v3.s}[2], [x0], #16\t\\n\"\n\t\t\t\t\"\tldr\t\tq11, [x5], #16\t\t\t\t\\n\"\n\t\t\t\t\"\tst4\t\t{v4.s, v5.s, v6.s, v7.s}[2], [x0], #16\t\\n\"\n\n\t\t\t\t\"\tprfm\tPLDL1KEEP, [x8, #128]\t\\n\"\n\t\t\t\t\"\tprfm\tPLDL1KEEP, [x9, #128]\t\\n\"\n\n\n\t\t\t\t\"\tldr\t\tq12, [x6], #16\t\t\t\t\\n\"\n\t\t\t\t\"\tst4\t\t{v0.s, v1.s, v2.s, v3.s}[3], [x0], #16\t\t\\n\"\n\t\t\t\t\"\tldr\t\tq13, [x7], #16\t\t\t\t\\n\"\n\t\t\t\t\"\tst4\t\t{v4.s, v5.s, v6.s, v7.s}[3], [x0], #16\t\t\\n\"\n\t\t\t\t\"\tldr\t\tq14, [x8], #16\t\t\t\t\\n\"\n\t\t\t\t\"\tst4\t\t{v8.s, v9.s, v10.s, v11.s}[0], [x0], #16\t\\n\"\n\t\t\t\t\"\tldr\t\tq15, [x9], #16\t\t\t\t\\n\"\n\t\t\t\t\"\tst4\t\t{v12.s, v13.s, v14.s, v15.s}[0], [x0], #16\t\\n\"\n\n\t\t\t\t\"\tsubs\tx21, x21, #1\t\t\t\t\t\\n\"\n\n\t\t\t\t\"\tst4\t\t{v8.s, v9.s, v10.s, v11.s}[1], [x0], #16\t\\n\"\n\t\t\t\t\"\tst4\t\t{v12.s, v13.s, v14.s, v15.s}[1], [x0], #16\t\\n\"\n\t\t\t\t\"\tst4\t\t{v8.s, v9.s, v10.s, v11.s}[2], [x0], #16\t\\n\"\n\t\t\t\t\"\tst4\t\t{v12.s, v13.s, v14.s, v15.s}[2], [x0], #16\t\\n\"\n\t\t\t\t\"\tst4\t\t{v8.s, v9.s, v10.s, v11.s}[3], [x0], #16\t\\n\"\n\t\t\t\t\"\tst4\t\t{v12.s, v13.s, v14.s, v15.s}[3], [x0], #16\t\\n\"\n\n\t\t\t\t\"\tbgt\t\tPACKA \t\t\t\t\t\t\\n\"\n\n\t\t\t\t\"\tands\tx22, x1, #7\t\t\t\t\\n\"\n\t\t\t\t\"\tbeq\t\tPACKA_END\t\t\t\t\t\\n\"\n\n\t\t\t\t\"\tcmp\t\tx22, #4\t\t\t\t\t\t\\n\"\n\t\t\t\t\"\tblt \tK1_PACKA\t\t\t\t\t\\n\"\n\n\n\t\t\t\t\"K4_PACKA:\t\t\t\t\t\t\t\t\\n\"\n\n\t\t\t\t\"\tldr\t\tq0, [x2], #16\t\t\t\\n\"\n\t\t\t\t\"\tldr\t\tq1, [x3], #16\t\t\t\\n\"\n\t\t\t\t\"\tldr\t\tq2, [x4], #16\t\t\t\\n\"\n\t\t\t\t\"\tldr\t\tq3, [x5], #16\t\t\t\\n\"\n\n\t\t\t\t\"\tst4\t\t{v0.s, v1.s, v2.s, v3.s}[0], [x0], #16\t\\n\"\n\t\t\t\t\"\tldr\t\tq4, [x6], #16\t\t\t\\n\"\n\t\t\t\t\"\tst4\t\t{v0.s, v1.s, v2.s, v3.s}[1], [x0], #16\t\\n\"\n\t\t\t\t\"\tldr\t\tq5, [x7], #16\t\t\t\\n\"\n\t\t\t\t\"\tst4\t\t{v0.s, v1.s, v2.s, v3.s}[2], [x0], #16\t\\n\"\n\t\t\t\t\"\tldr\t\tq6, [x8], #16\t\t\t\\n\"\n\t\t\t\t\"\tst4\t\t{v0.s, v1.s, v2.s, v3.s}[3], [x0], #16\t\\n\"\n\t\t\t\t\"\tldr\t\tq7, [x9], #16\t\t\t\\n\"\n\n\t\t\t\t\"\tst4\t\t{v4.s, v5.s, v6.s, v7.s}[0], [x0], #16\t\\n\"\n\t\t\t\t\"\tst4\t\t{v4.s, v5.s, v6.s, v7.s}[1], [x0], #16\t\\n\"\n\t\t\t\t\"\tst4\t\t{v4.s, v5.s, v6.s, v7.s}[2], [x0], #16\t\\n\"\n\t\t\t\t\"\tst4\t\t{v4.s, v5.s, v6.s, v7.s}[3], [x0], #16\t\\n\"\n\n\t\t\t\t\"\tsubs\tx22, x22, #4\t\t\t\\n\"\n\t\t\t\t\"\tbeq\t\tPACKA_END\t\t\t\t\t\\n\"\n\n\t\t\t\t\"K1_PACKA:\t\t\t\t\t\t\t\t\\n\"\n\n\t\t\t\t\"\tldr\t\ts0, [x2], #4\t\t\t\\n\"\n\t\t\t\t\"\tldr\t\ts1, [x3], #4\t\t\t\\n\"\n\t\t\t\t\"\tldr\t\ts2, [x4], #4\t\t\t\\n\"\n\t\t\t\t\"\tldr\t\ts3, [x5], #4\t\t\t\\n\"\n\n\t\t\t\t\"\tsubs \tx22, x22, #1\t\t\t\\n\"\n\n\t\t\t\t\"\tst4\t\t{v0.s, v1.s, v2.s, v3.s}[0], [x0], #16\t\\n\"\n\t\t\t\t\"\tldr\t\ts4, [x6], #4\t\t\t\\n\"\n\t\t\t\t\"\tldr\t\ts5, [x7], #4\t\t\t\\n\"\n\t\t\t\t\"\tldr\t\ts6, [x8], #4\t\t\t\\n\"\n\t\t\t\t\"\tldr\t\ts7, [x9], #4\t\t\t\\n\"\n\n\t\t\t\t\"\tst4\t\t{v4.s, v5.s, v6.s, v7.s}[0], [x0], #16\t\\n\"\n\n\t\t\t\t\"\tbgt\t\tK1_PACKA\t\t\t\t\\n\"\n\n\n\n\t\t\t\t\"PACKA_END:\t\t\t\t\t\t\t\\n\"\n\n\t\t\t\t:\n\t\t\t\t:\n\t\t\t\t[temp] \"m\" (temp),\n\t\t\t\t[Ac] \"m\" (Ac),\n\t\t\t\t[K] \"m\" (K),\n\t\t\t\t[LK] \"m\" (LK)\n\t\t\t\t:\"x0\", \"x1\", \"x2\", \"x3\", \"x4\", \"x5\", \"x6\", \"x7\", \"x8\",\n\t\t\t\t\"x9\", \"x10\", \"x11\", \"x12\", \"x13\",\"x14\", \"x15\", \"x16\",\n\t\t\t\t\"x17\", \"x18\", \"x19\", \"x20\", \"x21\", \"x22\", \"x23\", \"x24\",\"x25\",\n\t\t\t\t\"x26\", \"x27\", \"x28\", \"x29\", \"x30\",\n\t\t\t\t\"v0\", \"v1\", \"v2\", \"v3\", \"v4\", \"v5\", \"v6\", \"v7\",\n\t\t\t\t\"v8\", \"v9\", \"v10\", \"v11\", \"v12\", \"v13\", \"v14\", \"v15\",\n\t\t\t\t\"v16\", \"v17\", \"v18\", \"v19\", \"v20\", \"v21\", \"v22\", \"v23\",\n\t\t\t\t\"v24\", \"v25\", \"v26\", \"v27\", \"v28\", \"v29\", \"v30\", \"v31\"\n\n\t\t);\n\n\t\tAc = Ac + K * 8;\n\n\t}\n\n}\n\n\nvoid Sin_PACK(float* A, float* Ac, long M, long K, long LK)\n{\n\tlong ii, jj, kk;\n\tlong Kc;\n\n\n\tfor( kk =0 ; kk < K; kk = kk + Kc)\n\t{\n\t\t\n\t\tKc = GEMM_K;\n\t\tif(K - kk < GEMM_K)\n\t\t\tKc= K - kk;\n\n\t\tfor( ii = 0 ; ii < M; ii = ii + 8)\n\t\t{\n\n\n\t\t\tfloat *temp = A + ii * LK + kk;\n\n\t\t\tasm volatile(\n\t\t\t\t\t\"\tldr\t\tx0, %[Ac]\t\t\t\t\t\t\t\\n\"\n\t\t\t\t\t\"\tldr\t\tx1, %[Kc]\t\t\t\t\t\t\t\\n\"\n\t\t\t\t\t\"\tldr\t\tx2, %[temp]\t\t\t\t\t\t\\n\"\n\t\t\t\t\t\"\tldr\t\tx30, %[LK]\t\t\t\t\t\t\\n\"\n\n\t\t\t\t\t\"\tadd\t\tx3, x2, x30, lsl #2\t\t\\n\"\n\t\t\t\t\t\"\tadd\t\tx4, x2, x30, lsl #3\t\t\\n\"\n\t\t\t\t\t\"\tadd\t\tx5, x3, x30, lsl #3\t\t\\n\"\n\t\t\t\t\t\"\tadd\t\tx6, x4, x30, lsl #3\t\t\\n\"\n\t\t\t\t\t\"\tadd\t\tx7, x5, x30, lsl #3\t\t\\n\"\n\t\t\t\t\t\"\tadd\t\tx8, x6, x30, lsl #3\t\t\\n\"\n\t\t\t\t\t\"\tadd\t\tx9, x7, x30, lsl #3\t\t\\n\"\n\n\n\n\t\t\t\t\t\"\tlsr\t\tx21, x1, #3\t\t\t\t\t\t\\n\"\n\t\t\t\t\t\"\tcmp\t\tx21, #0\t\t\t\t\t\t\t\t\\n\"\n\t\t\t\t\t\"\tbeq\t\tSin_PACKA_END\t\t\t\t\t\\n\"\n\n\t\t\t\t\t\"Sin_PACKA:\t\t\t\t\t\t\t\t\t\t\\n\"\n\n\t\t\t\t\t\"\tprfm\tPLDL1KEEP, [x2, #128]\t\\n\"\n\t\t\t\t\t\"\tprfm\tPLDL1KEEP, [x3, #128]\t\\n\"\n\n\t\t\t\t\t\"\tldr\t\tq0, [x2], #16\t\t\t\t\t\\n\"\n\t\t\t\t\t\"\tldr\t\tq1, [x3], #16\t\t\t\t\t\\n\"\n\t\t\t\t\t\"\tldr\t\tq2, [x4], #16\t\t\t\t\t\\n\"\n\t\t\t\t\t\"\tldr\t\tq3, [x5], #16\t\t\t\t\t\\n\"\n\n\t\t\t\t\t\"\tprfm\tPLDL1KEEP, [x4, #128]\t\\n\"\n\t\t\t\t\t\"\tprfm\tPLDL1KEEP, [x5, #128]\t\\n\"\n\n\t\t\t\t\t\"\tst4\t\t{v0.s, v1.s, v2.s, v3.s}[0], [x0], #16\t\\n\"\n\n\t\t\t\t\t\"\tldr\t\tq4, [x6], #16\t\t\t\t\t\\n\"\n\t\t\t\t\t\"\tldr\t\tq5, [x7], #16\t\t\t\t\t\\n\"\n\t\t\t\t\t\"\tldr\t\tq6, [x8], #16\t\t\t\t\t\\n\"\n\t\t\t\t\t\"\tldr\t\tq7, [x9], #16\t\t\t\t\t\\n\"\n\n\t\t\t\t\t\"\tst4\t\t{v4.s, v5.s, v6.s, v7.s}[0], [x0], #16\t\\n\"\n\n\t\t\t\t\t\"\tprfm\tPLDL1KEEP, [x6, #128]\t\\n\"\n\t\t\t\t\t\"\tprfm\tPLDL1KEEP, [x7, #128]\t\\n\"\n\n\t\t\t\t\t\"\tldr\t\tq8, [x2], #16\t\t\t\t\t\\n\"\n\t\t\t\t\t\"\tst4\t\t{v0.s, v1.s, v2.s, v3.s}[1], [x0], #16\t\\n\"\n\t\t\t\t\t\"\tldr\t\tq9, [x3], #16\t\t\t\t\t\\n\"\n\t\t\t\t\t\"\tst4\t\t{v4.s, v5.s, v6.s, v7.s}[1], [x0], #16\t\\n\"\n\t\t\t\t\t\"\tldr\t\tq10, [x4], #16\t\t\t\t\\n\"\n\t\t\t\t\t\"\tst4\t\t{v0.s, v1.s, v2.s, v3.s}[2], [x0], #16\t\\n\"\n\t\t\t\t\t\"\tldr\t\tq11, [x5], #16\t\t\t\t\\n\"\n\t\t\t\t\t\"\tst4\t\t{v4.s, v5.s, v6.s, v7.s}[2], [x0], #16\t\\n\"\n\n\t\t\t\t\t\"\tprfm\tPLDL1KEEP, [x8, #128]\t\\n\"\n\t\t\t\t\t\"\tprfm\tPLDL1KEEP, [x9, #128]\t\\n\"\n\n\n\t\t\t\t\t\"\tldr\t\tq12, [x6], #16\t\t\t\t\\n\"\n\t\t\t\t\t\"\tst4\t\t{v0.s, v1.s, v2.s, v3.s}[3], [x0], #16\t\t\\n\"\n\t\t\t\t\t\"\tldr\t\tq13, [x7], #16\t\t\t\t\\n\"\n\t\t\t\t\t\"\tst4\t\t{v4.s, v5.s, v6.s, v7.s}[3], [x0], #16\t\t\\n\"\n\t\t\t\t\t\"\tldr\t\tq14, [x8], #16\t\t\t\t\\n\"\n\t\t\t\t\t\"\tst4\t\t{v8.s, v9.s, v10.s, v11.s}[0], [x0], #16\t\\n\"\n\t\t\t\t\t\"\tldr\t\tq15, [x9], #16\t\t\t\t\\n\"\n\t\t\t\t\t\"\tst4\t\t{v12.s, v13.s, v14.s, v15.s}[0], [x0], #16\t\\n\"\n\n\t\t\t\t\t\"\tsubs\tx21, x21, #1\t\t\t\t\t\\n\"\n\n\t\t\t\t\t\"\tst4\t\t{v8.s, v9.s, v10.s, v11.s}[1], [x0], #16\t\\n\"\n\t\t\t\t\t\"\tst4\t\t{v12.s, v13.s, v14.s, v15.s}[1], [x0], #16\t\\n\"\n\t\t\t\t\t\"\tst4\t\t{v8.s, v9.s, v10.s, v11.s}[2], [x0], #16\t\\n\"\n\t\t\t\t\t\"\tst4\t\t{v12.s, v13.s, v14.s, v15.s}[2], [x0], #16\t\\n\"\n\t\t\t\t\t\"\tst4\t\t{v8.s, v9.s, v10.s, v11.s}[3], [x0], #16\t\\n\"\n\t\t\t\t\t\"\tst4\t\t{v12.s, v13.s, v14.s, v15.s}[3], [x0], #16\t\\n\"\n\n\t\t\t\t\t\"\tbgt\t\tSin_PACKA \t\t\t\t\\n\"\n\n\t\t\t\t\t\"\tands\tx22, x1, #7\t\t\t\t\\n\"\n\t\t\t\t\t\"\tbeq\t\tSin_PACKA_END\t\t\t\\n\"\n\n\t\t\t\t\t\"\tcmp\t\tx22, #4\t\t\t\t\t\t\\n\"\n\t\t\t\t\t\"\tblt \tSin_K1_PACKA\t\t\t\\n\"\n\n\n\t\t\t\t\t\"Sin_K4_PACKA:\t\t\t\t\t\t\\n\"\n\n\t\t\t\t\t\"\tldr\t\tq0, [x2], #16\t\t\t\\n\"\n\t\t\t\t\t\"\tldr\t\tq1, [x3], #16\t\t\t\\n\"\n\t\t\t\t\t\"\tldr\t\tq2, [x4], #16\t\t\t\\n\"\n\t\t\t\t\t\"\tldr\t\tq3, [x5], #16\t\t\t\\n\"\n\n\t\t\t\t\t\"\tst4\t\t{v0.s, v1.s, v2.s, v3.s}[0], [x0], #16\t\\n\"\n\t\t\t\t\t\"\tldr\t\tq4, [x6], #16\t\t\t\\n\"\n\t\t\t\t\t\"\tst4\t\t{v0.s, v1.s, v2.s, v3.s}[1], [x0], #16\t\\n\"\n\t\t\t\t\t\"\tldr\t\tq5, [x7], #16\t\t\t\\n\"\n\t\t\t\t\t\"\tst4\t\t{v0.s, v1.s, v2.s, v3.s}[2], [x0], #16\t\\n\"\n\t\t\t\t\t\"\tldr\t\tq6, [x8], #16\t\t\t\\n\"\n\t\t\t\t\t\"\tst4\t\t{v0.s, v1.s, v2.s, v3.s}[3], [x0], #16\t\\n\"\n\t\t\t\t\t\"\tldr\t\tq7, [x9], #16\t\t\t\\n\"\n\n\t\t\t\t\t\"\tst4\t\t{v4.s, v5.s, v6.s, v7.s}[0], [x0], #16\t\\n\"\n\t\t\t\t\t\"\tst4\t\t{v4.s, v5.s, v6.s, v7.s}[1], [x0], #16\t\\n\"\n\t\t\t\t\t\"\tst4\t\t{v4.s, v5.s, v6.s, v7.s}[2], [x0], #16\t\\n\"\n\t\t\t\t\t\"\tst4\t\t{v4.s, v5.s, v6.s, v7.s}[3], [x0], #16\t\\n\"\n\n\t\t\t\t\t\"\tsubs\tx22, x22, #4\t\t\t\\n\"\n\t\t\t\t\t\"\tbeq\t\tSin_PACKA_END\t\t\t\\n\"\n\n\t\t\t\t\t\"Sin_K1_PACKA:\t\t\t\t\t\t\\n\"\n\n\t\t\t\t\t\"\tldr\t\ts0, [x2], #4\t\t\t\\n\"\n\t\t\t\t\t\"\tldr\t\ts1, [x3], #4\t\t\t\\n\"\n\t\t\t\t\t\"\tldr\t\ts2, [x4], #4\t\t\t\\n\"\n\t\t\t\t\t\"\tldr\t\ts3, [x5], #4\t\t\t\\n\"\n\n\t\t\t\t\t\"\tsubs \tx22, x22, #1\t\t\t\\n\"\n\n\t\t\t\t\t\"\tst4\t\t{v0.s, v1.s, v2.s, v3.s}[0], [x0], #16\t\\n\"\n\t\t\t\t\t\"\tldr\t\ts4, [x6], #4\t\t\t\\n\"\n\t\t\t\t\t\"\tldr\t\ts5, [x7], #4\t\t\t\\n\"\n\t\t\t\t\t\"\tldr\t\ts6, [x8], #4\t\t\t\\n\"\n\t\t\t\t\t\"\tldr\t\ts7, [x9], #4\t\t\t\\n\"\n\n\t\t\t\t\t\"\tst4\t\t{v4.s, v5.s, v6.s, v7.s}[0], [x0], #16\t\\n\"\n\n\t\t\t\t\t\"\tbgt\t\tSin_K1_PACKA\t\t\t\\n\"\n\n\n\n\t\t\t\t\t\"Sin_PACKA_END:\t\t\t\t\t\t\\n\"\n\n\t\t\t\t\t:\n\t        :\n\t      \t\t[temp] \"m\" (temp),\n\t      \t\t[Ac] \"m\" (Ac),\n\t      \t\t[Kc] \"m\" (Kc),\n\t      \t\t[LK] \"m\" (LK)\n\t        :\"x0\", \"x1\", \"x2\", \"x3\", \"x4\", \"x5\", \"x6\", \"x7\", \"x8\",\n\t        \"x9\", \"x10\", \"x11\", \"x12\", \"x13\",\"x14\", \"x15\", \"x16\",\n\t        \"x17\", \"x18\", \"x19\", \"x20\", \"x21\", \"x22\", \"x23\", \"x24\",\"x25\",\n\t        \"x26\", \"x27\", \"x28\", \"x29\", \"x30\",\n\t        \"v0\", \"v1\", \"v2\", \"v3\", \"v4\", \"v5\", \"v6\", \"v7\",\n\t        \"v8\", \"v9\", \"v10\", \"v11\", \"v12\", \"v13\", \"v14\", \"v15\",\n\t        \"v16\", \"v17\", \"v18\", \"v19\", \"v20\", \"v21\", \"v22\", \"v23\",\n\t        \"v24\", \"v25\", \"v26\", \"v27\", \"v28\", \"v29\", \"v30\", \"v31\"\n\n\t\t\t);\n\n\t\t\tAc = Ac + Kc * 8;\n\n\t\t}\n\t}\n}\n", "meta": {"hexsha": "a67e3da7875dca2341a19abf0efcc6f862fe714e", "size": 9253, "ext": "h", "lang": "C", "max_stars_repo_path": "NN_LIB/PACK.h", "max_stars_repo_name": "AnonymousYWL/MYLIB", "max_stars_repo_head_hexsha": "2497123bf3bfd12f215b428ae83afd223cd072fc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 12.0, "max_stars_repo_stars_event_min_datetime": "2021-06-04T14:39:37.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-21T10:45:29.000Z", "max_issues_repo_path": "NN_LIB/PACK.h", "max_issues_repo_name": "ProgrammerAnonymousWLY/MYLIB", "max_issues_repo_head_hexsha": "2497123bf3bfd12f215b428ae83afd223cd072fc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-06-23T17:16:12.000Z", "max_issues_repo_issues_event_max_datetime": "2021-06-23T17:16:12.000Z", "max_forks_repo_path": "NN_LIB/PACK.h", "max_forks_repo_name": "ProgrammerAnonymousWLY/MYLIB", "max_forks_repo_head_hexsha": "2497123bf3bfd12f215b428ae83afd223cd072fc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2021-06-04T14:40:41.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-07T07:51:15.000Z", "avg_line_length": 26.2869318182, "max_line_length": 70, "alphanum_fraction": 0.37857992, "num_tokens": 5224, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4882833804028559, "lm_q2_score": 0.02297737070451605, "lm_q1q2_score": 0.011219468240370647}}
{"text": "/* Odeint solver */\n#include <pygsl/utils.h>\n#include <pygsl/block_helpers.h>\n#include <pygsl/error_helpers.h>\n#include <Python.h>\n#include <gsl/gsl_odeiv.h>\n#include <gsl/gsl_errno.h>\n\nchar odeiv_module_doc[] = \"XXX odeiv module doc missing!\\n\";\n\nstatic char this_file[] = __FILE__;\nstatic PyObject *module = NULL; /* set by initodeiv */ \n\nstatic void\t\t\t/* generic instance destruction */\ngeneric_dealloc (PyObject *self)\n{\n  DEBUG_MESS(1, \" *** generic_dealloc %p\\n\", (void *) self);\n  PyMem_Free(self);\n}\n\ntypedef struct {\n     PyObject_HEAD\n     gsl_odeiv_step * step;\n     gsl_odeiv_system system;\n     PyObject *py_func;\n     PyObject *py_jac;\n     PyObject *arguments;\n     jmp_buf buffer;\n}\nPyGSL_odeiv_step;\n\ntypedef struct {\n  PyObject_HEAD\n  PyGSL_odeiv_step * step;\n  gsl_odeiv_control * control;\n} PyGSL_odeiv_control;\n\ntypedef struct {\n  PyObject_HEAD\n  PyGSL_odeiv_step * step;\n  PyGSL_odeiv_control * control;\n  gsl_odeiv_evolve * evolve;\n} PyGSL_odeiv_evolve;\n\ntypedef struct {\n  PyObject_HEAD\n  gsl_odeiv_step_type * step_type;\n} PyGSL_odeiv_step_type;\n\ntypedef struct {\n  PyObject_HEAD\n  gsl_odeiv_control_type * control_type;\n} PyGSL_odeiv_control_type;\n\n/*---------------------------------------------------------------------------\n * Declaration of the various Methods\n *---------------------------------------------------------------------------*/\n/*\n * stepper\n */\nstatic int \nPyGSL_odeiv_func(double t, const double y[], double f[], void *params);\nstatic int \nPyGSL_odeiv_jac(double t, const double y[], double *dfdy, double dfdt[], \n\t\tvoid *params);\nstatic PyObject *\nPyGSL_odeiv_step_apply(PyGSL_odeiv_step *self, PyObject *args);\nstatic PyObject *\nPyGSL_odeiv_step_reset(PyGSL_odeiv_step *self, PyObject *args);\nstatic void \nPyGSL_odeiv_step_free(PyGSL_odeiv_step * self);\nstatic PyObject *\nPyGSL_odeiv_step_name(PyGSL_odeiv_step *self, PyObject *args);\nstatic PyObject *\nPyGSL_odeiv_step_order(PyGSL_odeiv_step *self, PyObject *args);\n\n/*\n * control \n */\nstatic PyObject *\nPyGSL_odeiv_control_hadjust(PyGSL_odeiv_control *self, PyObject *args);\nstatic void \nPyGSL_odeiv_control_free(PyGSL_odeiv_control * self);\nstatic PyObject *\nPyGSL_odeiv_control_name(PyGSL_odeiv_control *self, PyObject *args);\n\n/*\n * evolve\n */\nstatic void \nPyGSL_odeiv_evolve_free(PyGSL_odeiv_evolve * self);\nstatic PyObject *\nPyGSL_odeiv_evolve_apply(PyGSL_odeiv_evolve *self, PyObject *args);\nstatic PyObject *\nPyGSL_odeiv_evolve_reset(PyGSL_odeiv_evolve *self, PyObject *args);\n/*---------------------------------------------------------------------------*/\n\nstatic char PyGSL_odeiv_step_type_doc[] = \"A odeiv step type\\n\";\nstatic char PyGSL_odeiv_control_type_doc[] = \"A odeiv control type\\n\";\nstatic char PyGSL_odeiv_evolve_type_doc[] = \"A odeiv evolve type\\n\";\n\n\n\n\n\n\n\n#define PyGSL_ODEIV_GENERIC_TYPE_PYTYPE_ALL                               \\\nstatic PyTypeObject PyGSL_ODEIV_GENERIC_TYPE_PYTYPE = {\t\t          \\\n  PyObject_HEAD_INIT(NULL)\t/* fix up the type slot in initodeiv */\t  \\\n  0,\t\t\t\t/* ob_size */\t\t\t\t  \\\n  PyGSL_ODEIV_GENERIC_TYPE_NAME,     \t/* tp_name */\t\t\t  \\\n  sizeof(PyGSL_ODEIV_GENERIC_TYPE),       /* tp_basicsize */\t\t  \\\n  0,\t\t\t\t/* tp_itemsize */\t\t\t  \\\n\t\t\t\t\t\t\t\t\t  \\\n  /* standard methods */\t\t\t\t\t\t  \\\n  (destructor)  generic_dealloc,   /* tp_dealloc  ref-count==0  */\t  \\\n  (printfunc)   0,\t\t   /* tp_print    \"print x\"     */\t  \\\n  (getattrfunc) 0,                 /* tp_getattr  \"x.attr\"      */\t  \\\n  (setattrfunc) 0,\t\t   /* tp_setattr  \"x.attr=v\"    */\t  \\\n  (cmpfunc)     0,\t\t   /* tp_compare  \"x > y\"       */\t  \\\n  (reprfunc)    0,                 /* tp_repr     `x`, print x  */\t  \\\n\t\t\t\t\t\t\t\t\t  \\\n  /* type categories */\t\t\t\t\t\t\t  \\\n  0,\t\t\t\t/* tp_as_number   +,-,*,/,%,&,>>,pow...*/ \\\n  0,\t\t\t\t/* tp_as_sequence +,[i],[i:j],len, ...*/  \\\n  0,\t\t\t\t/* tp_as_mapping  [key], len, ...*/\t  \\\n\t\t\t\t\t\t\t\t\t  \\\n  /* more methods */\t\t\t\t\t\t\t  \\\n  (hashfunc)     0,\t\t/* tp_hash    \"dict[x]\" */\t\t  \\\n  (ternaryfunc)  0,             /* tp_call    \"x()\"     */\t\t  \\\n  (reprfunc)     0,             /* tp_str     \"str(x)\"  */\t\t  \\\n  (getattrofunc) 0,\t\t/* tp_getattro */\t\t\t  \\\n  (setattrofunc) 0,\t\t/* tp_setattro */\t\t\t  \\\n  0,\t\t\t\t/* tp_as_buffer */\t\t\t  \\\n  0L,\t\t\t\t/* tp_flags */\t\t\t\t  \\\n  PyGSL_ODEIV_GENERIC_TYPE_DOC       /* tp_doc */                         \\\n};\n\n#define PyGSL_ODEIV_GENERIC_TYPE        PyGSL_odeiv_step_type\n#define PyGSL_ODEIV_GENERIC_TYPE_PYTYPE PyGSL_odeiv_step_type_pytype\n#define PyGSL_ODEIV_GENERIC_TYPE_NAME   \"PyGSL_odeiv_step_type\"\n#define PyGSL_ODEIV_GENERIC_TYPE_DOC    PyGSL_odeiv_step_type_doc\nPyGSL_ODEIV_GENERIC_TYPE_PYTYPE_ALL\n\n\n#undef PyGSL_ODEIV_GENERIC_TYPE       \n#undef PyGSL_ODEIV_GENERIC_TYPE_PYTYPE\n#undef PyGSL_ODEIV_GENERIC_TYPE_NAME  \n#undef PyGSL_ODEIV_GENERIC_TYPE_DOC   \n#define PyGSL_ODEIV_GENERIC_TYPE        PyGSL_odeiv_control_type\n#define PyGSL_ODEIV_GENERIC_TYPE_PYTYPE PyGSL_odeiv_control_type_pytype\n#define PyGSL_ODEIV_GENERIC_TYPE_NAME   \"PyGSL_odeiv_control_type\"\n#define PyGSL_ODEIV_GENERIC_TYPE_DOC    PyGSL_odeiv_control_type_doc\nPyGSL_ODEIV_GENERIC_TYPE_PYTYPE_ALL\n\n\n\n#define PyGSLOdeivStepType_Check(v)    ((v)->ob_type == &PyGSL_odeiv_step_type_pytype)\n#define PyGSLOdeivControlType_Check(v) ((v)->ob_type == &PyGSL_odeiv_control_type_pytype)\n#define PyGSLOdeivEvolveType_Check(v)  ((v)->ob_type == &PyGSL_odeiv_evolve_type_pytype)\n\n\n\n\n\n#define PyGSL_ODEIV_GENERIC_ALL                                                           \\\nstatic PyObject *\t\t\t\t\t\t\t\t\t  \\\nPyGSL_ODEIV_GENERIC_GETATTR(PyGSL_ODEIV_GENERIC *self, char *name)\t\t          \\\n{\t\t\t\t\t\t\t\t\t\t\t  \\\n     PyObject *tmp = NULL;\t\t\t\t\t\t\t\t  \\\n\t\t\t\t\t\t\t\t\t\t\t  \\\n     FUNC_MESS_BEGIN();\t\t\t\t\t\t\t\t\t  \\\n \t\t\t\t\t\t\t\t\t\t\t  \\\n     tmp = Py_FindMethod(PyGSL_ODEIV_GENERIC_METHODS, (PyObject *) self, name);\t          \\\n     if(NULL == tmp){\t  \t\t\t\t\t\t\t\t  \\\n\t  PyGSL_add_traceback(module, __FILE__, \"odeiv.__attr__\", __LINE__ - 1);\t  \\\n\t  return NULL;\t\t\t\t\t\t\t\t\t  \\\n     }\t\t\t\t\t\t\t\t\t\t\t  \\\n     return tmp;                                                                          \\\n}                                                                                         \\\nstatic PyTypeObject PyGSL_ODEIV_GENERIC_PYTYPE = {\t\t\t\t\t  \\\n  PyObject_HEAD_INIT(NULL)\t/* fix up the type slot in initcrng */\t\t\t  \\\n  0,\t\t\t\t/* ob_size */\t\t\t\t\t\t  \\\n  PyGSL_ODEIV_GENERIC_NAME,\t\t\t/* tp_name */\t\t\t          \\\n  sizeof(PyGSL_ODEIV_GENERIC),  /* tp_basicsize */\t\t\t\t\t  \\\n  0,\t\t\t\t/* tp_itemsize */\t\t\t\t\t  \\\n\t\t\t\t\t\t\t\t\t\t\t  \\\n  /* standard methods */\t\t\t\t\t\t\t\t  \\\n  (destructor)  PyGSL_ODEIV_GENERIC_DELETE,       /* tp_dealloc  ref-count==0  */\t  \\\n  (printfunc)   0,\t\t                      /* tp_print    \"print x\"     */\t  \\\n  (getattrfunc) PyGSL_ODEIV_GENERIC_GETATTR,       /* tp_getattr  \"x.attr\"      */\t  \\\n  (setattrfunc) 0,\t\t   /* tp_setattr  \"x.attr=v\"    */\t\t\t  \\\n  (cmpfunc)     0,\t\t   /* tp_compare  \"x > y\"       */\t\t\t  \\\n  (reprfunc)    0,                 /* tp_repr     `x`, print x  */\t\t\t  \\\n\t\t\t\t\t\t\t\t\t\t\t  \\\n  /* type categories */\t\t\t\t\t\t\t\t\t  \\\n  0,\t\t\t\t/* tp_as_number   +,-,*,/,%,&,>>,pow...*/\t\t  \\\n  0,\t\t\t\t/* tp_as_sequence +,[i],[i:j],len, ...*/\t\t  \\\n  0,\t\t\t\t/* tp_as_mapping  [key], len, ...*/\t\t\t  \\\n\t\t\t\t\t\t\t\t\t\t\t  \\\n  /* more methods */\t\t\t\t\t\t\t\t\t  \\\n  (hashfunc)     0,\t\t/* tp_hash    \"dict[x]\" */\t\t\t\t  \\\n  (ternaryfunc)  0,             /* tp_call    \"x()\"     */\t\t\t\t  \\\n  (reprfunc)     0,             /* tp_str     \"str(x)\"  */\t\t\t\t  \\\n  (getattrofunc) 0,\t\t/* tp_getattro */\t\t\t\t\t  \\\n  (setattrofunc) 0,\t\t/* tp_setattro */\t\t\t\t\t  \\\n  0,\t\t\t\t/* tp_as_buffer */\t\t\t\t\t  \\\n  0L,\t\t\t\t/* tp_flags */\t\t\t\t\t\t  \\\n  PyGSL_ODEIV_GENERIC_DOC       /* doc */                                                 \\\n};                                                                                        \n\n\n#define PyGSL_ODEIV_GENERIC            PyGSL_odeiv_step\n#define PyGSL_ODEIV_GENERIC_NAME      \"PyGSL_odeiv_step\"\n#define PyGSL_ODEIV_GENERIC_PYTYPE     PyGSL_odeiv_step_pytype\n#define PyGSL_ODEIV_GENERIC_DOC        PyGSL_odeiv_step_doc\n#define PyGSL_ODEIV_GENERIC_GETATTR    PyGSL_odeiv_step_getattr\n#define PyGSL_ODEIV_GENERIC_METHODS    PyGSL_odeiv_step_methods\n#define PyGSL_ODEIV_GENERIC_DELETE     PyGSL_odeiv_step_free\nPyGSL_ODEIV_GENERIC_ALL\n/**/;\n#undef PyGSL_ODEIV_GENERIC       \n#undef PyGSL_ODEIV_GENERIC_NAME  \n#undef PyGSL_ODEIV_GENERIC_PYTYPE\n#undef PyGSL_ODEIV_GENERIC_DOC   \n#undef PyGSL_ODEIV_GENERIC_GETATTR\n#undef PyGSL_ODEIV_GENERIC_METHODS\n#undef PyGSL_ODEIV_GENERIC_DELETE\n#define PyGSL_ODEIV_GENERIC            PyGSL_odeiv_control\n#define PyGSL_ODEIV_GENERIC_NAME      \"PyGSL_odeiv_control\"\n#define PyGSL_ODEIV_GENERIC_PYTYPE     PyGSL_odeiv_control_pytype\n#define PyGSL_ODEIV_GENERIC_DOC        PyGSL_odeiv_control_doc\n#define PyGSL_ODEIV_GENERIC_GETATTR    PyGSL_odeiv_control_getattr\n#define PyGSL_ODEIV_GENERIC_METHODS    PyGSL_odeiv_control_methods\n#define PyGSL_ODEIV_GENERIC_DELETE     PyGSL_odeiv_control_free\nPyGSL_ODEIV_GENERIC_ALL\n/**/;\n#undef PyGSL_ODEIV_GENERIC       \n#undef PyGSL_ODEIV_GENERIC_NAME  \n#undef PyGSL_ODEIV_GENERIC_PYTYPE\n#undef PyGSL_ODEIV_GENERIC_DOC   \n#undef PyGSL_ODEIV_GENERIC_GETATTR\n#undef PyGSL_ODEIV_GENERIC_METHODS\n#undef PyGSL_ODEIV_GENERIC_DELETE\n#define PyGSL_ODEIV_GENERIC            PyGSL_odeiv_evolve\n#define PyGSL_ODEIV_GENERIC_NAME      \"PyGSL_odeiv_evolve\"\n#define PyGSL_ODEIV_GENERIC_PYTYPE     PyGSL_odeiv_evolve_pytype\n#define PyGSL_ODEIV_GENERIC_DOC        PyGSL_odeiv_evolve_doc\n#define PyGSL_ODEIV_GENERIC_GETATTR    PyGSL_odeiv_evolve_getattr\n#define PyGSL_ODEIV_GENERIC_METHODS    PyGSL_odeiv_evolve_methods\n#define PyGSL_ODEIV_GENERIC_DELETE     PyGSL_odeiv_evolve_free\nPyGSL_ODEIV_GENERIC_ALL\n/**/;\n\n\n\n\n\nstatic void \nPyGSL_odeiv_step_free(PyGSL_odeiv_step * self)\n{\n     assert(PyGSL_ODEIV_STEP_Check(self));\n     Py_DECREF(self->py_func);\n     Py_XDECREF(self->py_jac);\n     Py_DECREF(self->arguments);\n     gsl_odeiv_step_free(self->step);\n     PyMem_Free(self);\n}\n\nstatic PyObject *\nPyGSL_odeiv_step_reset(PyGSL_odeiv_step *self, PyObject *args)\n{\n     assert(PyGSL_ODEIV_STEP_Check(self));\n     gsl_odeiv_step_reset(self->step);\n     Py_INCREF(Py_None);\n     return Py_None;\n}\n\nstatic PyObject *\nPyGSL_odeiv_step_name(PyGSL_odeiv_step *self, PyObject *args)\n{\n     assert(PyGSL_ODEIV_STEP_Check(self));\n     return PyString_FromString(gsl_odeiv_step_name(self->step));\n}\n\n{\n     assert(PyGSL_ODEIV_STEP_Check(self));\n     return PyInt_FromLong((long) gsl_odeiv_step_order(self->step));\n}\n\n\n/* --------------------------------------------------------------------------- */\n/* control_hadjust needs a few arrays */\n/*\nextern int \ngsl_odeiv_control_hadjust (gsl_odeiv_control * c, gsl_odeiv_step * s, \n\t\t\t   const double y0[],  const double yerr[], \n\t\t\t   const double dydt[], double * h);\n*/\n\n\nstatic void \nPyGSL_odeiv_control_free(PyGSL_odeiv_control * self)\n{\n     assert(PyGSL_ODEIV_CONTROL_Check(self));\n     Py_DECREF(self->step);\n     //gsl_odeiv_control_free(self->control);\n     PyMem_Free(self);\n}\n\nstatic PyObject *\nPyGSL_odeiv_control_name(PyGSL_odeiv_control *self, PyObject *args)\n{\n     assert(PyGSL_ODEIV_CONTROL_Check(self));\n     return PyString_FromString(gsl_odeiv_control_name(self->control));\n}\n\nstatic void \nPyGSL_odeiv_evolve_free(PyGSL_odeiv_evolve * self)\n{\n     assert(PyGSL_ODEIV_EVOLVE_Check(self));\n     Py_DECREF(self->step);\n     Py_DECREF(self->control);\n     gsl_odeiv_evolve_free(self->evolve);\n     PyMem_Free(self);\n}\n\nstatic PyObject *\nPyGSL_odeiv_evolve_reset(PyGSL_odeiv_evolve *self, PyObject *args)\n{\n     assert(PyGSL_ODEIV_EVOLVE_Check(self));\n     gsl_odeiv_evolve_reset(self->evolve);\n     Py_INCREF(Py_None);\n     return Py_None;\n}\n\n\n#if 0\nstatic\nvoid create_odeiv_step_types(PyObject *module_dict)\n{\n\n     PyGSL_odeiv_step_type *a_odeiv_step = NULL;\n     PyObject *item=NULL;\n\n     gsl_odeiv_step_type ** thistype;\n     gsl_odeiv_step_type const * const step_types[]  ={\n\t  gsl_odeiv_step_rk2,\n\t  gsl_odeiv_step_rk4,\n\t  gsl_odeiv_step_rkf45,\n\t  gsl_odeiv_step_rkck,\n\t  gsl_odeiv_step_rk8pd,\n\t  gsl_odeiv_step_rk2imp,\n\t  gsl_odeiv_step_rk4imp,\n\t  gsl_odeiv_step_bsimp,\n\t  gsl_odeiv_step_gear1,\n\t  gsl_odeiv_step_gear2,\n\t  NULL\n     };\n\n     FUNC_MESS_BEGIN();\n\n     thistype = (gsl_odeiv_step_type **) step_types;\n     while((*thistype) != NULL){\n\t  a_odeiv_step =  PyObject_NEW(PyGSL_odeiv_step_type, &PyGSL_odeiv_step_type_pytype);\n\t  assert(a_odeiv_step);\n\t  a_odeiv_step->step_type = (gsl_odeiv_step_type *) *thistype;\n\t  item = PyString_FromString((*thistype)->name);\n\t  DEBUG_MESS(2, \"Preparing step type -->%s<--\", PyString_AsString(item));\n\t  PyGSL_clear_name(PyString_AsString(item), PyString_Size(item));\n\t  DEBUG_MESS(2, \"Adding step type -->%s<--\",  PyString_AsString(item));\n\t  assert(item);\n\t  PyDict_SetItem(module_dict, item, (PyObject *) a_odeiv_step);\n\t  /* Py_DECREF(item); */\n\t  item = NULL;\t  \n\t  thistype++;\n\n     }\n     FUNC_MESS_END();\n}\n#endif\n\n\nstatic PyMethodDef PyGSL_odeiv_module_functions[] = {\n     {\"step_rk2\",    PyGSL_odeiv_step_init_rk2,    METH_VARARGS|METH_KEYWORDS, NULL},\n     {\"step_rk4\",    PyGSL_odeiv_step_init_rk4,    METH_VARARGS|METH_KEYWORDS, NULL},\n     {\"step_rkf45\",  PyGSL_odeiv_step_init_rkf45,  METH_VARARGS|METH_KEYWORDS, NULL},\n     {\"step_rkck\",   PyGSL_odeiv_step_init_rkck,   METH_VARARGS|METH_KEYWORDS, NULL},\n     {\"step_rk8pd\",  PyGSL_odeiv_step_init_rk8pd,  METH_VARARGS|METH_KEYWORDS, NULL},\n     {\"step_rk2imp\", PyGSL_odeiv_step_init_rk2imp, METH_VARARGS|METH_KEYWORDS, NULL},\n     {\"step_rk4imp\", PyGSL_odeiv_step_init_rk4imp, METH_VARARGS|METH_KEYWORDS, NULL},\n     {\"step_bsimp\",  PyGSL_odeiv_step_init_bsimp,  METH_VARARGS|METH_KEYWORDS, NULL},\n     {\"step_gear1\",  PyGSL_odeiv_step_init_gear1,  METH_VARARGS|METH_KEYWORDS, NULL},\n     {\"step_gear2\",  PyGSL_odeiv_step_init_gear2,  METH_VARARGS|METH_KEYWORDS, NULL},\n     {\"control_standard_new\", PyGSL_odeiv_control_init_standard_new, METH_VARARGS, NULL},\n     {\"control_y_new\",        PyGSL_odeiv_control_init_y_new,        METH_VARARGS, NULL},\n     {\"control_yp_new\",       PyGSL_odeiv_control_init_yp_new,       METH_VARARGS, NULL},\n     {\"evolve\", PyGSL_odeiv_evolve_init, METH_VARARGS, NULL},\n     {NULL, NULL, 0}        /* Sentinel */\n};\n\nvoid \ninitodeiv(void)\n{\n     PyObject *m=NULL, *item=NULL, *dict=NULL;\n\n     FUNC_MESS_BEGIN();\n     fprintf(stderr, \"Compiled at %s %s\\n\", __DATE__, __TIME__);\n     m = Py_InitModule(\"odeiv\", PyGSL_odeiv_module_functions);\n     assert(m);\n     module = m;\n     import_array();\n     init_pygsl();\n\n     PyGSL_odeiv_step_type_pytype.ob_type = &PyType_Type;\n     PyGSL_odeiv_control_type_pytype.ob_type = &PyType_Type;\n\n     PyGSL_odeiv_step_pytype.ob_type = &PyType_Type;\n     PyGSL_odeiv_control_pytype.ob_type = &PyType_Type;\n     PyGSL_odeiv_evolve_pytype.ob_type = &PyType_Type;\n\n     dict = PyModule_GetDict(m);\n     /* create_odeiv_step_types(dict); */\n     if(!dict)\n\t  goto fail;\n     \n     if (!(item = PyString_FromString(odeiv_module_doc))){\n\t  PyErr_SetString(PyExc_ImportError, \n\t\t\t  \"I could not generate module doc string!\");\n\t  goto fail;\n     }\n     if (PyDict_SetItemString(dict, \"__doc__\", item) != 0){\n\t  PyErr_SetString(PyExc_ImportError, \n\t\t\t  \"I could not init doc string!\");\n\t  goto fail;\n     }\n     \n     FUNC_MESS_END();\n     return;\n fail:\n     FUNC_MESS(\"Fail\");\n     fprintf(stderr, \"Import of module odeiv failed!\\n\");\n}\n\n", "meta": {"hexsha": "639f8d785c9647ec0b184433c005d64be88bf22b", "size": 15219, "ext": "c", "lang": "C", "max_stars_repo_path": "production/pygsl-0.9.5/testing/src/solvers/old/odeiv_old.c", "max_stars_repo_name": "juhnowski/FishingRod", "max_stars_repo_head_hexsha": "457e7afb5cab424296dff95e1acf10ebf70d32a9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "production/pygsl-0.9.5/testing/src/solvers/old/odeiv_old.c", "max_issues_repo_name": "juhnowski/FishingRod", "max_issues_repo_head_hexsha": "457e7afb5cab424296dff95e1acf10ebf70d32a9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "production/pygsl-0.9.5/testing/src/solvers/old/odeiv_old.c", "max_forks_repo_name": "juhnowski/FishingRod", "max_forks_repo_head_hexsha": "457e7afb5cab424296dff95e1acf10ebf70d32a9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2018-10-02T06:18:07.000Z", "max_forks_repo_forks_event_max_datetime": "2018-10-02T06:18:07.000Z", "avg_line_length": 34.1233183857, "max_line_length": 91, "alphanum_fraction": 0.6543136868, "num_tokens": 4537, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.36296920551961676, "lm_q2_score": 0.02976009534431753, "lm_q1q2_score": 0.01080199816331498}}
{"text": "/**\n * File: scaleback_utils.c\n * Subroutine for the WFC3 background scaling\n *\n */\n#include <gsl/gsl_vector.h>\n#include <gsl/gsl_multifit_nlin.h>\n#include <gsl/gsl_vector.h>\n#include <gsl/gsl_matrix.h>\n#include <gsl/gsl_sort.h>\n#include \"aXe_grism.h\"\n#include \"aXe_utils.h\"\n#include \"spc_FITScards.h\"\n#include \"spce_sect.h\"\n#include \"spce_fitting.h\"\n#include \"spce_is_in.h\"\n#include \"spc_back.h\"\n#include \"spce_pathlength.h\"\n#include \"trfit_utils.h\"\n#include \"nicback_utils.h\"\n#include \"scaleback_utils.h\"\n\n/**\n * Function: fit_to_FITScards\n * Fills the results of the fitting into a set of fits cards.\n *\n * Parameters:\n * @param bck_vals   - vector with the fit results\n * @param npixels    - dimension of all images\n *\n * Returns:\n * @return cards - the list of fits header cards\n */\nFITScards *fit_to_FITScards(const gsl_vector* bck_vals, const px_point npixels)\n{\n    char templt[FLEN_CARD];\n    int i=0,keytype, f_status=0;\n    int npix_tot;\n\n    FITScards *cards;\n\n    // allocate the cards\n    cards = allocate_FITScards(7);\n\n    // compute the number of pixels\n    npix_tot = npixels.x * npixels.y;\n\n    i=0;\n    sprintf(templt,\"SCALVAL = %e / computed scale value\", gsl_vector_get(bck_vals, 0));\n    fits_parse_template (templt, cards->cards[i++], &keytype, &f_status);\n    sprintf(templt,\"SCALERR = %e / error for scale value\", gsl_vector_get(bck_vals, 1));\n    fits_parse_template (templt, cards->cards[i++], &keytype, &f_status);\n    sprintf(templt,\"NPIXINI = %e / initial fill value\", gsl_vector_get(bck_vals, 2));\n    fits_parse_template (templt, cards->cards[i++], &keytype, &f_status);\n    sprintf(templt,\"NPIXFIN = %e / final fill value\", gsl_vector_get(bck_vals, 3));\n    fits_parse_template (templt, cards->cards[i++], &keytype, &f_status);\n    sprintf(templt,\"FRACINI = %e / initial fill value\", gsl_vector_get(bck_vals, 2) / (float)npix_tot);\n    fits_parse_template (templt, cards->cards[i++], &keytype, &f_status);\n    sprintf(templt,\"FRACFIN = %e / final fill value\", gsl_vector_get(bck_vals, 3) / (float)npix_tot);\n    fits_parse_template (templt, cards->cards[i++], &keytype, &f_status);\n    sprintf(templt,\"NITER = %d / number of iterations\", (int)gsl_vector_get(bck_vals, 4));\n    fits_parse_template (templt, cards->cards[i++], &keytype, &f_status);\n\n    // return the filled cards\n    return cards;\n}\n\n/**\n * Function: make_scale_back\n * Loads the various image data inputs and performs a fit using a kappa-sigma\n * clipping iteration. Then a scaled version of one of the input images\n * is produced and written to disk. Optionally, an ASCII list with the\n * pixel values before the fitting is produced.\n *\n * Parameters:\n * @param grism_image - full pathname to the grism image\n * @param grism_mask  - full pathname to the mask image\n * @param conf_file   - full pathname to the configuration file\n * @param scale_image - full pathname to the scaling (=master sky) image\n * @param bck_image   - full pathname to the scaled (=background) image\n * @param plist_name  - full pathname to the pixel list\n * @param scale_to_master - integer/boolean to specify what should be scaled as output\n * @param make_plis   - integer/boolean to request a pixel list as output\n *\n * Returns:\n * @return -\n */\nvoid\nmake_scale_back(char grism_image[], const char grism_mask[], char conf_file[],\n\t\tconst char scale_image[], char bck_image[], const char plist_name[],\n\t\tconst int scale_to_master, const int make_plis)\n{\n  px_point npixels;\n\n  gsl_matrix *gr_img;\n  gsl_matrix *gr_dqval;\n  gsl_matrix *gr_mask;\n  gsl_matrix *sc_img;\n  gsl_matrix *bck_img;\n\n  gsl_vector *bck_vals;\n\n  fitbck_data *fbck_data;\n  //int f_status=0;\n\n  FITScards *cards;\n\n  aperture_conf  *conf;\n\n  char  ID[MAXCHAR];\n\n  // fix the extension name\n  sprintf (ID, \"BCK\");\n\n  // read the configuration file\n  // determine all extensions\n  conf = get_aperture_descriptor(conf_file);\n  get_extension_numbers(grism_image, conf, conf->optkey1, conf->optval1);\n\n  // load the scale image\n  fprintf(stdout,\"Loading DATA from: %s...\", scale_image);\n  sc_img = FITSimage_to_gsl(scale_image, 1, 1);\n  fprintf(stdout,\". Done.\\n\");\n\n  // load the grism image\n  fprintf(stdout,\"Loading DATA from: %s...\", grism_image);\n  gr_img = FITSimage_to_gsl(grism_image, conf->science_numext, 1);\n  fprintf(stdout,\". Done.\\n\");\n\n  if (conf->dq_numext < 0)\n    {\n    // allocate the space for the dq-image\n    // set all values to 0.0\n    gr_dqval = gsl_matrix_alloc(gr_img->size1, gr_img->size2);\n    gsl_matrix_set_all (gr_dqval, 0.0);\n    }\n  else\n    {\n    // load the scale dq values\n    fprintf(stdout,\"Loading DQ from: %s...\", grism_image);\n    gr_dqval = FITSimage_to_gsl(grism_image, conf->dq_numext, 1);\n    fprintf(stdout,\". Done.\\n\");\n    }\n\n  // load the grism mask\n  fprintf(stdout,\"Loading DATA from: %s...\", grism_mask);\n  gr_mask = FITSimage_to_gsl(grism_mask, 2, 1);\n  fprintf(stdout,\". Done.\\n\");\n\n  // get the number of pixels\n  npixels.x = sc_img->size1;\n  npixels.y = sc_img->size2;\n\n  // report the number of pixels\n  //fprintf(stdout,\"Loading DATA from: %i pix\\n\", npixels.x * npixels.y);\n\n  // allocate memory for the fit data\n  fbck_data = alloc_fitbck_data(npixels.x * npixels.y);\n\n  // fill the data into the structure\n  if (scale_to_master)\n    fill_cont_data(gr_img, gr_dqval, gr_mask, sc_img, fbck_data, conf->dqmask);\n  else\n    fill_mask_data(gr_img, gr_dqval, gr_mask, sc_img, fbck_data, conf->dqmask);\n\n\n  // make a pixel list if desired\n  if (make_plis)\n    print_plis(fbck_data, plist_name);\n\n  // make the fit\n  bck_vals = make_ksig_scalefit(fbck_data);\n\n  // report the result of the fit onto the screen\n  fprintf(stdout, \"\\nScale result image %s : c0 = %f +- %f\", grism_image, gsl_vector_get(bck_vals, 0), gsl_vector_get(bck_vals, 1));\n  fprintf(stdout, \"\\nInitial fill factor: %.1f%%, final: %.1f%%\", 100.0 * gsl_vector_get(bck_vals, 2) / ((float)npixels.x * (float)npixels.y), 100.0 *gsl_vector_get(bck_vals, 3) / ((float)npixels.x * (float)npixels.y));\n  fprintf(stdout, \"\\nNumber of iterations: % 2i\\n\\n\", (int)gsl_vector_get(bck_vals, 4));\n\n  if (scale_to_master)\n    bck_img = compute_scale_grism(gr_img, gr_dqval, gr_mask, conf->dqmask, bck_vals);\n  else\n    bck_img = compute_scale_master(sc_img, bck_vals);\n\n  // write the background image to a file\n  fprintf(stdout,\"Writing data to: %s...\", bck_image);\n  gsl_to_FITSimage (bck_img, bck_image, 1, ID);\n  cards = fit_to_FITScards(bck_vals, npixels);\n  put_FITS_cards(bck_image, 1, cards);\n  fprintf(stdout,\". Done.\\n\");\n\n  // release memory\n  free_fitbck_data(fbck_data);\n  free_FITScards(cards);\n  gsl_matrix_free(sc_img);\n  gsl_matrix_free(gr_img);\n  gsl_matrix_free(gr_dqval);\n  gsl_matrix_free(gr_mask);\n  gsl_matrix_free(bck_img);\n  gsl_vector_free(bck_vals);\n  free_aperture_conf(conf);\n}\n\n/**\n * Function: print_plis\n * Prints the content of a pixel list structure\n * to an ASCII file.\n *\n * Parameters:\n * @param fbck_data  - the list of pixel values\n * @param plist_name - full pathname to the pixel list\n *\n * Returns:\n * @return -\n */\nvoid\nprint_plis(const fitbck_data *fbck_data, const char plist_name[])\n{\n    int index=0;\n    char Buffer[10240];\n    FILE *fout;\n\n    // open the pixel list\n    fout = fopen(plist_name, \"w\");\n\n    // go over all data values\n    for (index=0; index < fbck_data->n_data; index++)\n      {\n      // put the values into the buffer\n      sprintf (Buffer, \"%i %i %e %e\\n\",fbck_data->x_pos[index], fbck_data->y_pos[index],\n          fbck_data->x_values[index], fbck_data->y_values[index]);\n\n      // push the buffer to the  file\n      fputs (Buffer, fout);\n      }\n\n    // close the pixel file\n    fclose(fout);\n}\n\n\n/**\n * Function: compute_scale_grism\n * Computes a scaled version of the input grism images, using the\n * scale given as input. Pixels masked in other images are given\n * a fixed value.\n *\n * Parameters:\n * @param gr_img  - the list of pixel values\n * @param gr_dqval - full pathname to the pixel list\n * @param gr_mask - full pathname to the pixel list\n * @param bck_vals - full pathname to the pixel list\n *\n * Returns:\n * @return bck_img - the scaled grism image\n */\ngsl_matrix *\ncompute_scale_grism(gsl_matrix *gr_img, gsl_matrix *gr_dqval, gsl_matrix *gr_mask,\n\t\tint dqmask, gsl_vector *bck_vals)\n{\n    gsl_matrix *bck_img;\n\n    int ii, jj;\n    double scale=0.0;\n\n    // get the scale\n    scale = gsl_vector_get(bck_vals, 0);\n\n    // allocate the space for the background image\n    bck_img = gsl_matrix_alloc(gr_img->size1, gr_img->size2);\n\n    // go over each row\n    for (ii=0; ii < (int)gr_img->size1; ii++)\n      // go over each column\n      for (jj=0; jj < (int)gr_img->size2; jj++)\n        // compute and set the value in the background image\n        if (gsl_matrix_get(gr_mask, ii, jj) > 0.0 ||\n            (int)gsl_matrix_get(gr_dqval, ii, jj) & dqmask)\n          gsl_matrix_set(bck_img, ii, jj, MASK_VALUE);\n        else\n          // using the fit values only\n          gsl_matrix_set(bck_img, ii, jj, gsl_matrix_get(gr_img, ii, jj) * scale);\n\n    // return the background image\n    return bck_img;\n}\n\n/**\n * Function: compute_scale_master\n * Computes a scaled version of the scaling (=master sky) image,\n * using the scale given as input.\n *\n * Parameters:\n * @param sc_img  - the list of pixel valuessc_img\n * @param bck_vals - full pathname to the pixel list\n *\n * Returns:\n * @return bck_img - the scaled grism image\n */\ngsl_matrix *\ncompute_scale_master(const gsl_matrix *sc_img, const gsl_vector *bck_vals)\n{\n    gsl_matrix *bck_img;\n\n    int ii, jj;\n    double scale=0.0;\n\n    // get the scale\n    scale = gsl_vector_get(bck_vals, 0);\n\n    // allocate the space for the background image\n    bck_img = gsl_matrix_alloc(sc_img->size1, sc_img->size2);\n\n    // go over each row\n    for (ii=0; ii < (int)sc_img->size1; ii++)\n      // go over each column\n      for (jj=0; jj < (int)sc_img->size2; jj++)\n        // scale the master sky\n        gsl_matrix_set(bck_img, ii, jj, gsl_matrix_get(sc_img, ii, jj) * scale);\n\n    // return the background image\n    return bck_img;\n}\n\n/**\n * Function: fill_mask_data\n * Fills the pixel value structure with the data for the x/y-positions,\n * the grism image and the scaling image values and a weigth. dq-flagged\n * pixels and masked pixel are neglected. The mask is supposed to be a background\n * mask where pixel with a value < 900000 shall be neglected.\n * The weights are initially all set to 1.\n *\n * Parameters:\n * @param gr_img    - the grism image array\n * @param gr_dqval  - the dq-value array\n * @param gr_mask   - the grism mask array\n * @param sc_img    - the scaling image array\n * @param fbck_data - the pixel list structure\n * @param dqmask    - dq value from the configuration file\n *\n * Returns:\n * @return -\n */\nvoid\nfill_mask_data(gsl_matrix *gr_img, gsl_matrix *gr_dqval, gsl_matrix *gr_mask,\n\t\tgsl_matrix *sc_img, fitbck_data *fbck_data, int dqmask)\n{\n    int ix=0;\n    int iy=0;\n    int index=0;\n\n    // intitialize the index for\n    // the fit_data structure\n    index = 0;\n\n    // go over all pixels\n    // in the grism image\n    for (ix=0; ix < (int)sc_img->size1; ix++)\n      {\n      for (iy=0; iy < (int)sc_img->size2; iy++)\n        {\n        // set the scale image pixel as independent variable\n        fbck_data->x_values[index] = gsl_matrix_get(gr_img, ix, iy);\n\n        // set the grism image pixel as dependent variable\n        fbck_data->y_values[index] = gsl_matrix_get(sc_img, ix, iy);;\n\n        // set the x- and y-positions\n        fbck_data->x_pos[index] = ix;\n        fbck_data->y_pos[index] = iy;\n\n        // check whether the pixel was masked out\n        // or is part of an object\n        if (gsl_matrix_get(sc_img, ix, iy) < 0.0 ||\n            gsl_matrix_get(gr_mask, ix, iy) < -900000.0 ||\n            ((int)gsl_matrix_get(gr_dqval, ix, iy) & dqmask))\n          {\n          continue;\n          }\n        else\n          {\n          // give the pixel full weight\n          //x,y,value_back,value_grism_imag\n          fbck_data->e_values[index] = 1.0;\n\n          // enhance the counter\n          index++;\n          }\n        }\n      }\n\n    fbck_data->n_data = index;\n    fprintf(stdout, \"\\nNumber of pixels in structure: %i\\n\\n\", fbck_data->n_data);\n\n    if (fbck_data->n_data < 1)\n      aXe_message (aXe_M_FATAL, __FILE__, __LINE__,\n          \"aXe_SCALEBCK: no data left to determine the scale!\\n\");\n}\n\n/**\n * Function: fill_cont_data\n * Fills the pixel value structure with the data for the x/y-positions,\n * the grism image and the scaling image values and a weigth. dq-flagged\n * pixels and masked pixel are neglected. The mask is supposed to be a geometric\n * contamination where pixel with a value > 0 shall be neglected.\n * The weights are initially all set to 1.\n *\n * Parameters:\n * @param gr_img    - the grism image array\n * @param gr_dqval  - the dq-value array\n * @param gr_mask   - the grism mask array\n * @param sc_img    - the scaling image array\n * @param fbck_data - the pixel list structure\n *\n * Returns:\n * @return -\n */\nvoid\nfill_cont_data(gsl_matrix *gr_img, gsl_matrix *gr_dqval, gsl_matrix *gr_mask,\n                gsl_matrix *sc_img, fitbck_data *fbck_data, int dqmask)\n{\n    int ix=0;\n    int iy=0;\n    int index=0;\n\n    // intitialize the index for\n    // the fit_data structure\n    index = 0;\n\n    // go over all pixels\n    // in the grism image\n    for (ix=0; ix < (int)sc_img->size1; ix++)\n      {\n      for (iy=0; iy < (int)sc_img->size2; iy++)\n        {\n        // set the scale image pixel as independent variable\n        fbck_data->x_values[index] = gsl_matrix_get(sc_img, ix, iy);\n\n        // set the grism image pixel as dependent variable\n        fbck_data->y_values[index] = gsl_matrix_get(gr_img, ix, iy);;\n\n        // set the x- and y-positions\n        fbck_data->x_pos[index] = ix;\n        fbck_data->y_pos[index] = iy;\n\n        // check whether the pixel was masked out\n        // or is part of an object\n        if (gsl_matrix_get(sc_img, ix, iy) < 0.0 ||\n            gsl_matrix_get(gr_mask, ix, iy) > 0.0 ||\n            ((int)gsl_matrix_get(gr_dqval, ix, iy) & dqmask))\n          continue;\n        else\n          {\n          // give the pixel full weight\n          //x,y,value_back,value_grism_imag\n          fbck_data->e_values[index] = 1.0;\n\n          // enhance the counter\n          index++;\n          }\n        }\n      }\n\n    fbck_data->n_data = index;\n    fprintf(stdout, \"\\nNumber of pixels in structure: %i\\n\\n\", fbck_data->n_data);\n\n    if (fbck_data->n_data < 1)\n      aXe_message (aXe_M_FATAL, __FILE__, __LINE__,\n          \"aXe_SCALEBCK: no data left to determine the scale!\\n\");\n}\n\n/**\n * Function: make_ksig_scalefit\n * Determines the scale from the values in the pixel value structure.\n * The results are determined iteratively while rejecting pixels via\n * kappa-sigma clipping to get robust measurements. The results are\n * the scale value, the standard deviation, the final number of\n * not rejected points and the number of iterations.\n *\n * Parameters:\n * @param fbck_data - the pixel value structure\n *\n * Returns:\n * @return bck_vals - a vector with the fit results\n */\ngsl_vector *\nmake_ksig_scalefit(fitbck_data *fbck_data)\n{\n  gsl_vector *bck_vals=NULL;\n\n  float old_scale;\n  int index=0;\n  int clipped=1;\n\n  bck_vals = gsl_vector_alloc(6);\n\n  // check whether iterations still\n  // must be done and whether\n  // the data was changed from clipping\n  old_scale= 1.0e+06;\n  while (index < N_BCKSCALE_ITER && clipped)\n    {\n\n    // make a non-weighted linear fit\n    get_bck_scale(fbck_data->x_values, fbck_data->y_values, fbck_data->e_values,\n        fbck_data->n_data, bck_vals);\n\n    // make a clipping iteration\n    clipped = clipp_scale_data(fbck_data, bck_vals, N_BCKSCALE_KAPPA);\n\n    // break the iteration if the scale change is below a certain threshold\n    if (fabs((gsl_vector_get(bck_vals, 0)-old_scale)/gsl_vector_get(bck_vals, 0)) < N_BCKSCALE_ACCUR)\n      clipped = 0;\n\n    // store the new scale\n    old_scale = gsl_vector_get(bck_vals, 0);\n\n    // inhance the clipping counter\n    index++;\n    }\n\n  // set the number of iterations\n  gsl_vector_set(bck_vals, 4, (double)index);\n\n  // return the fit result\n  return bck_vals;\n}\n\n/**\n * Function: get_bck_scale\n * Computes the scale value from the pixel values in two arrays.\n * The scale value is the median value of all input with weight.\n * Also the standard deviation, the total number of input and\n * the number of input with weight is returned.\n *\n * Parameters:\n * @param xs       - pixel values from one image\n * @param ys       - pixel values from second image\n * @param ws       - weight values\n * @param n_elem   - number of elements\n * @param bck_vals - vector for the result\n *\n * Returns:\n * @return -\n */\nvoid\nget_bck_scale(const double *xs, double *ys, double *ws,\n\t\t  const int n_elem, gsl_vector *bck_vals)\n{\n  int i, m;\n  double *tmp;\n  double median;\n  double stdev;\n\n  // allocate space for temporary vectors\n  tmp = (double *) malloc (n_elem * sizeof (double));\n\n  // initialize the array\n  for (i = 0; i < n_elem; i++)\n    tmp[i] = 0.0;\n\n  // fill the temporary vectors\n  // with scale values and weights\n  m = 0;\n  for (i = 0; i < n_elem; i++)\n  {\n    if (ws[i] > 0.0 && ys[i] != 0.0)\n      {\n      tmp[m] = xs[i] / ys[i];\n      m++;\n      }\n  }\n\n  // sort the vector\n  gsl_sort( tmp, 1, m);\n\n  // just confirm the sorting\n  for (i = 1; i < m; i++)\n    if (tmp[i] < tmp[i-1])\n      fprintf(stdout, \"Wrong: %f <--> %f\\n\", tmp[i],tmp[i-1]);\n\n  // take the home made median\n  median = tmp[(int)m/2];\n\n  // get the standard deviation\n  stdev = comp_stdev_from_array(tmp, m, median);\n\n  // put the results in the vector\n  gsl_vector_set(bck_vals, 0, median);\n  gsl_vector_set(bck_vals, 1, stdev);\n  gsl_vector_set(bck_vals, 2, (double)n_elem);\n  gsl_vector_set(bck_vals, 3, (double)m);\n\n  // release memory\n  free(tmp);\n}\n\n/**\n * Function: clipp_scale_data\n * Set the weight in the pixel value structure such as to clip\n * point that deviate from the mean/characteristic value by\n * more than the allowed amount.\n *\n * Parameters:\n * @param fbck_data - pixel values from one image\n * @param bck_vals  - vector for the result\n * @param kappa     - vector for the result\n *\n * Returns:\n * @return nclip - integer/boolean indicating new clipping\n */\nint\nclipp_scale_data(fitbck_data *fbck_data, const gsl_vector *bck_vals,\n\t\tconst float kappa)\n{\n    int index;\n    int nclip=0;\n    int newclip=0;\n    double mean;\n    //double stdev;\n    double absdev;\n\n    // get the mean value\n    mean = gsl_vector_get(bck_vals, 0);\n\n    // compute the maximum allowed deviation\n    absdev = kappa * gsl_vector_get(bck_vals, 1);\n\n    // go over all data values\n    for (index=0; index < fbck_data->n_data; index++)\n      {\n      // avoid zero values\n      if (fbck_data->y_values[index] != 0.0)\n        {\n        // check whether the actual value is outside the allowed range\n        if (fabs(mean - (fbck_data->x_values[index]/fbck_data->y_values[index])) > absdev)\n          {\n          // check and mark clip changes\n          if (fbck_data->e_values[index])\n            newclip = 1;\n\n          // set the weight, change the counter\n          fbck_data->e_values[index] = 0.0;\n          nclip++;\n          }\n        else\n          {\n          // set the weight\n          fbck_data->e_values[index] = 1.0;\n          }\n        }\n      else\n        {\n        // set the weight, change the counter\n        fbck_data->e_values[index] = 0.0;\n        nclip++;\n        }\n      }\n\n    // return the newclip indicator\n    return newclip;\n}\n", "meta": {"hexsha": "8bc6910772a8cc2a638f2ec41b76b5da94c1f8e6", "size": 19480, "ext": "c", "lang": "C", "max_stars_repo_path": "cextern/src/scaleback_utils.c", "max_stars_repo_name": "sosey/pyaxe", "max_stars_repo_head_hexsha": "f57de55daf77de21d5868ace08b69090778d5975", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "cextern/src/scaleback_utils.c", "max_issues_repo_name": "sosey/pyaxe", "max_issues_repo_head_hexsha": "f57de55daf77de21d5868ace08b69090778d5975", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "cextern/src/scaleback_utils.c", "max_forks_repo_name": "sosey/pyaxe", "max_forks_repo_head_hexsha": "f57de55daf77de21d5868ace08b69090778d5975", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.4259818731, "max_line_length": 219, "alphanum_fraction": 0.657238193, "num_tokens": 5576, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4225046348141882, "lm_q2_score": 0.025565216289747925, "lm_q1q2_score": 0.010801422372445683}}
{"text": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <getopt.h>\n#include <iniparser.h>\n#include <limits.h>\n#include \"prepmt/prepmt.h\"\n#include \"ispl/process.h\"\n#include \"iscl/array/array.h\"\n#include \"iscl/memory/memory.h\"\n#include \"iscl/os/os.h\"\n#ifdef PARMT_USE_INTEL\n#include <mkl_cblas.h>\n#else\n#include <cblas.h>\n#endif\n\n#define PROGRAM_NAME \"xgrnsTeleB\"\n\nstatic void printUsage(void);\nstatic int parseArguments(int argc, char *argv[],\n                          char iniFile[PATH_MAX], char section[256]);\nstruct sacData_struct *\n    prepmt_grnsTeleB_readData(const char *archiveFile, int *nobs, int *ierr);\n\nint prepmt_grnsTeleB_readParameters(const char *iniFile,\n                                    const char *section,\n                                    char archiveFile[PATH_MAX],\n                                    char parmtDataFile[PATH_MAX],\n                                    bool *luseCrust1,\n                                    char crustDir[PATH_MAX],\n                                    bool *luseSourceModel,\n                                    char sourceModel[PATH_MAX],\n                                    bool *luseTstarTable,\n                                    double *defaultTstar,\n                                    char tstarTable[PATH_MAX],\n                                    bool *lrepickGrns,\n                                    double *staWin, double *ltaWin,\n                                    double *staltaThreshPct,\n                                    bool *lalignXC,\n                                    bool *luseEnvelope,\n                                    bool *lnormalizeXC,\n                                    double *maxXCtimeLag,\n                                    int *ndepth, double **depths);\nint prepmt_grnsTeleB_loadTstarTable(const char *tstarTable,\n                                    const double defaultTstar,\n                                    const int nobs,\n                                    struct sacData_struct *data,\n                                    double **tstars);\n\nint main(int argc, char **argv)\n{\n    char iniFile[PATH_MAX], archiveFile[PATH_MAX], tstarTable[PATH_MAX],\n         parmtDataFile[PATH_MAX], crustDir[PATH_MAX],\n         sourceModel[PATH_MAX], section[256];\n    struct prepmtCommands_struct cmds;\n    struct vmodel_struct *recmod, telmod, srcmod;\n    struct prepmtEventParms_struct event;\n    struct hudson96_parms_struct hudson96Parms;\n    struct hpulse96_parms_struct hpulse96Parms;\n    struct prepmtModifyCommands_struct options;\n    struct sacData_struct *sacData, *grns, *ffGrns, *locFF;\n    const char *hudsonSection = \"hudson96\\0\";\n    const char *hpulseSection = \"hpulse96\\0\";\n    const int ntstar = 1;\n    double *depths, *tstars, defaultTstar, ltaWin, maxXCtimeLag,\n           staltaThreshPct, staWin;\n    int i, ierr, iobs, k, kndx, ndepth, nobs;\n    bool lalignXC, lnormalizeXC, lrepickGrns, luseCrust1,\n         luseSourceModel, luseEnvelope, luseTstarTable;\n\n    iscl_init();\n    depths = NULL;\n    memset(&options, 0, sizeof(struct prepmtModifyCommands_struct));\n    ierr = parseArguments(argc, argv, iniFile, section);\n    if (ierr != 0)\n    {\n        if (ierr ==-2){return EXIT_FAILURE;}\n        return EXIT_SUCCESS;\n    }\n    // Load the event\n    ierr = prepmt_event_initializeFromIniFile(iniFile, &event);\n    if (ierr != 0)\n    {\n        printf(\"%s: Error reading event info\\n\", PROGRAM_NAME);\n        return EXIT_FAILURE;\n    }\n    // Read the forward modeling parameters\n    ierr = prepmt_hudson96_readHudson96Parameters(iniFile, hudsonSection,\n                                                  &hudson96Parms);\n    if (ierr != 0)\n    {\n        printf(\"%s: Failed to read hudson parameters\\n\", PROGRAM_NAME);\n        return EXIT_FAILURE;\n    }\n    ierr = prepmt_hpulse96_readHpulse96Parameters(iniFile, hpulseSection,\n                                                  &hpulse96Parms);\n    if (ierr != 0)\n    {\n        printf(\"%s: Failed to read hpulse parameters\\n\", PROGRAM_NAME);\n        return EXIT_FAILURE;\n    }\n    ierr = prepmt_grnsTeleB_readParameters(iniFile, section,\n                                           archiveFile,\n                                           parmtDataFile,\n                                           &luseCrust1, crustDir,\n                                           &luseSourceModel, sourceModel,\n                                           &luseTstarTable,\n                                           &defaultTstar,\n                                           tstarTable,\n                                           &lrepickGrns,\n                                           &staWin, &ltaWin, &staltaThreshPct,\n                                           &lalignXC, &luseEnvelope,\n                                           &lnormalizeXC, &maxXCtimeLag,\n                                           &ndepth, &depths);\n    if (ierr != 0)\n    {\n        printf(\"%s: Failed to read modeling parameters\\n\", PROGRAM_NAME);\n        return EXIT_FAILURE;\n    }\n    // Read how the default commands will be modified\n    options.iodva = hpulse96Parms.iodva;\n    options.ldeconvolution = false; // We are working with the greens fns \n    ierr = prepmt_prepData_getDefaultDTAndWindowFromIniFile(iniFile, section,\n                                                            &options.targetDt,\n                                                            &options.cut0,\n                                                            &options.cut1);\n    if (ierr != 0)\n    {\n        printf(\"%s: Failed to read default command info\\n\", PROGRAM_NAME);\n        return EXIT_FAILURE;\n    }\n    // Load the data\n//memset(archiveFile, 0, PATH_MAX*sizeof(char));\n//strcpy(archiveFile, \"windowedPData/observedWaveforms.h5\\0\");\n    printf(\"%s: Loading data...\\n\", PROGRAM_NAME);\n    sacData = prepmt_prepData_readArchivedWaveforms(archiveFile, &nobs, &ierr);\n    if (ierr != 0)\n    {\n        printf(\"%s: Error loading data\\n\", PROGRAM_NAME);\n        return EXIT_FAILURE;\n    }\n    if (luseTstarTable)\n    {\n        printf(\"%s: Loading tstar table...\\n\", PROGRAM_NAME);\n        ierr = prepmt_grnsTeleB_loadTstarTable(tstarTable, defaultTstar,\n                                               nobs, sacData, &tstars);\n        if (ierr != 0)\n        {\n            printf(\"%s: Failed to load t* table\\n\", PROGRAM_NAME);\n            return EXIT_FAILURE;\n        }\n    }\n    else\n    {\n        printf(\"%s: Using default tstar: %f\\n\", PROGRAM_NAME, defaultTstar); \n        tstars = array_set64f(nobs, defaultTstar, &ierr);\n    }\n    printf(\"%s: Reading pre-processing commands...\\n\", PROGRAM_NAME);\n    cmds = prepmt_commands_readFromIniFile(iniFile, section, nobs,\n                                           sacData, &ierr);\n    if (ierr != 0)\n    {\n        printf(\"%s: Error loading grns prep commands\\n\", PROGRAM_NAME);\n        return -1;\n    }\n    printf(\"%s: Loading velocity models...\\n\", PROGRAM_NAME);\n    recmod = (struct vmodel_struct *)\n             calloc((size_t) nobs, sizeof(struct vmodel_struct));\n    ierr = hudson96_getModels(nobs, sacData,\n                              luseCrust1, crustDir,\n                              luseSourceModel, sourceModel,\n                              &telmod, &srcmod, recmod);\n    if (ierr != 0)\n    {\n        printf(\"%s: Failed to load models\\n\", PROGRAM_NAME);\n        return EXIT_FAILURE;\n    }\n    printf(\"%s: Computing fundamental fault solutions...\\n\", PROGRAM_NAME);\n    ffGrns = (struct sacData_struct *)\n             calloc((size_t) (ndepth*nobs*ntstar*10),\n                    sizeof(struct sacData_struct));\n    for (k=0; k<nobs; k++)\n    {\n        locFF = prepmt_hudson96_computeGreensFF(hudson96Parms,\n                                                hpulse96Parms,\n                                                telmod, srcmod, recmod,\n                                                ntstar, &tstars[1],\n                                                ndepth, depths,\n                                                1, &sacData[k], &ierr);\n        for (i=0; i<10*ndepth; i++)\n        {\n            kndx = k*10*ndepth + i;\n            sacio_copy(locFF[i], &ffGrns[kndx]);\n            sacio_freeData(&locFF[i]);\n        }\n        free(locFF);\n    }\n    printf(\"%s: Contextualing Green's functions...\\n\", PROGRAM_NAME);\n    grns = (struct sacData_struct *)\n           calloc((size_t) (6*ndepth*nobs*ntstar),\n                  sizeof(struct sacData_struct));\n    ierr = prepmt_greens_ffGreensToGreens(nobs, sacData,\n                                          ndepth, ntstar, ffGrns, grns);\n    if (ierr != 0)\n    {\n        printf(\"%s: Error contextualizing Greens functions\\n\", PROGRAM_NAME);\n        return EXIT_FAILURE;\n    }\n    for (k=0; k<10*nobs*ndepth*ntstar; k++){sacio_freeData(&ffGrns[k]);}\n    free(ffGrns);\n    // Release memory\n    for (k=0; k<nobs; k++)\n    {\n        cps_utils_freeVmodelStruct(&recmod[k]);\n    }\n    free(recmod);\n    cps_utils_freeVmodelStruct(&srcmod);\n    cps_utils_freeVmodelStruct(&telmod);\n    // Process the Green's functions\n    printf(\"%s: Modifying Green's functions processing commands...\\n\",\n           PROGRAM_NAME);\n    for (k=0; k<cmds.nobs; k++)\n    {\n        ierr = prepmt_commands_modifyCommandsCharsStruct(options,\n                                                         sacData[k],\n                                                         &cmds.cmds[k]);\n        /*\n        for (int l=0; l<cmds.cmds[k].ncmds; l++)\n        {\n             printf(\"%s\\n\", cmds.cmds[k].cmds[l]);\n        }\n        printf(\"\\n\");\n        */\n        if (ierr != 0)\n        {\n            printf(\"%s: Failed to modify processing commands\\n\", PROGRAM_NAME);\n            return EXIT_FAILURE;\n        }\n    }\n    printf(\"%s: Processing Green's functions...\\n\", PROGRAM_NAME);\n    ierr = prepmt_greens_processHudson96Greens(nobs, ntstar, ndepth,\n                                               cmds, grns);\n    if (ierr != 0)\n    {\n        printf(\"%s: Error processing Green's functions\\n\", PROGRAM_NAME);\n        return EXIT_FAILURE;\n    }\n    // Repick the Green's functions with an STA/LTA\n    if (lrepickGrns)\n    {\n        printf(\"%s: Repicking Green's functions...\\n\", PROGRAM_NAME);\n        for (k=0; k<ndepth*ntstar*nobs*6; k=k+6)\n        {\n            ierr = prepmt_greens_repickGreensWithSTALTA(staWin, ltaWin,\n                                                        staltaThreshPct,\n                                                        &grns[k]);\n            if (ierr != 0)\n            {\n                printf(\"%s: Error repicking Green's functions\\n\", PROGRAM_NAME);\n                return EXIT_FAILURE;\n            }\n        }\n    }\n    // Shift \n    if (lalignXC)\n    {\n        printf(\"%s: Refining waveform alignment with cross-correlation\\n\",\n               PROGRAM_NAME);\n        for (iobs=0; iobs<nobs; iobs++)\n        {\n            for (k=0; k<ndepth*ntstar; k++)\n            {\n                kndx = iobs*ndepth*ntstar*6 + k*6;\n                ierr = prepmt_greens_xcAlignGreensToData(sacData[iobs],\n                                                         luseEnvelope,\n                                                         lnormalizeXC,\n                                                         maxXCtimeLag,\n                                                         &grns[kndx]);\n                if (ierr != 0)\n                {\n                    printf(\"%s: Error aligning with XC\\n\", PROGRAM_NAME);\n                    return EXIT_FAILURE;\n                }\n            }\n        }\n    }\n    // Trim\n    printf(\"%s: Windowing Green's functions to data\\n\", PROGRAM_NAME);\n    ierr = prepmt_greens_cutHudson96FromData(nobs, sacData,\n                                             ndepth, ntstar, grns);\n    if (ierr != 0)\n    {\n        printf(\"%s: Error trimming Green's functions\\n\", PROGRAM_NAME);\n        return EXIT_FAILURE;\n    }\n    // Dump archive\n/*\nsacio_writeTimeSeriesFile(\"test_gxx.sac\", grns[11*ndepth*6+6]);\nsacio_writeTimeSeriesFile(\"test_gyy.sac\", grns[11*ndepth*6+7]);\nsacio_writeTimeSeriesFile(\"test_gzz.sac\", grns[11*ndepth*6+8]);\nsacio_writeTimeSeriesFile(\"test_gxy.sac\", grns[11*ndepth*6+9]);\nsacio_writeTimeSeriesFile(\"test_gxz.sac\", grns[11*ndepth*6+10]);\nsacio_writeTimeSeriesFile(\"test_gyz.sac\", grns[11*ndepth*6+11]);\n*/\n    printf(\"%s: Writing archive: %s\\n\", PROGRAM_NAME, parmtDataFile);\n    ierr = prepmt_greens_writeArchive(parmtDataFile, //\"./\", \"pwave\",\n                                      nobs, ndepth,\n                                      event.latitude, event.longitude,\n                                      depths, sacData, grns);\n    if (ierr != 0)\n    {\n        printf(\"%s: Failed to write archive file\\n\", PROGRAM_NAME);\n        return EXIT_FAILURE;\n    }\n    // release rest of memory\n    for (k=0; k<nobs; k++){sacio_freeData(&sacData[k]);}\n    for (k=0; k<ndepth*ntstar*nobs*6; k++){sacio_freeData(&grns[k]);}\n    memory_free64f(&tstars);\n    free(grns);\n    free(sacData);\n    iscl_finalize();\n\n    return EXIT_SUCCESS;\n}\n//============================================================================//\n/*!\n * @brief Obtains the forward modeling t* values for each teleseismic\n *        waveform observation from a text file.\n *\n * @param[in] tstarTable    Name of tstar table.\n * @param[in] defaultTstar  Default t* if a piece of data cannot be found in\n *                          the table.\n * @param[in] nobs          Number of observations.\n * @param[in] data          List of teleseismic waveforms to map t* values to.\n *                          This is an array of dimension [nobs].\n *\n * @param[out] tstars       tstar values corresponding to each station.\n *                          If a SNCL in the data list cannot be found in the\n *                          tstarTable file then this tstar will be set to the\n *                          default value.\n *                          This is an array of length [nobs].\n *\n * @result 0 indicates success.\n *\n * @author Ben Baker\n *\n */\nint prepmt_grnsTeleB_loadTstarTable(const char *tstarTable,\n                                    const double defaultTstar,\n                                    const int nobs,\n                                    struct sacData_struct *data,\n                                    double **tstars)\n{\n    FILE *tsf;\n    char cline[64], search[64], item[64];\n    double *tstar, tin;\n    int i, ierr, k, nlines;\n    bool lfound;\n    *tstars = NULL;\n    tstar = NULL;\n    if (!os_path_isfile(tstarTable))\n    {\n        fprintf(stderr, \"%s: Error tstar table %s does not exist\\n\",\n                 __func__, tstarTable);\n        return -1;\n    }\n    if (nobs < 1 || data == NULL)\n    {\n        fprintf(stderr, \"%s: No data\\n\", __func__);\n        return -1;\n    }\n    // Initialize to default\n    tstar = array_set64f(nobs, defaultTstar, &ierr);\n    // Get number of lines in text file\n    tsf = fopen(tstarTable, \"r\");\n    nlines = 0;\n    while (fgets(cline, 64, tsf) != NULL){nlines = nlines + 1;}  \n    rewind(tsf);\n    // Loop through and match observations to tstar's in table\n    for (k=0; k<nobs; k++)\n    {\n        memset(search, 0, 64*sizeof(char));\n        sprintf(search, \"%s.%s.%s.%s\",\n                data[k].header.knetwk, data[k].header.kstnm,\n                data[k].header.kcmpnm, data[k].header.khole);\n        lfound = false;\n        for (i=0; i<nlines; i++)\n        {\n            memset(cline, 0, 64*sizeof(char));\n            memset(item,  0, 64*sizeof(char));\n            fgets(cline, 64, tsf);\n            sscanf(cline, \"%s %lf\\n\", item, &tin);\n            if (strcasecmp(search, item) == 0)\n            {\n                tstar[k] = defaultTstar; \n                lfound = true;\n                break;\n            }\n        }\n        if (!lfound)\n        {\n            fprintf(stderr, \"%s: Setting %s tstar to: %f\\n\",\n                    __func__, search, defaultTstar);\n        }\n        rewind(tsf);\n    }\n    fclose(tsf);\n    *tstars = tstar;\n    return 0;\n}\n//============================================================================//\n/*!\n * @brief TODO: delete this function. \n */\nint prepmt_grnsTeleB_windowHudson96(\n    const int nobs, const int ntstar, const int ndepth,\n    const struct sacData_struct *data,\n    struct sacData_struct *grns)\n{\n    double epoch, epochGrns;\n    int indices[6], idep, ierr, iobs, it;\n    for (iobs=0; iobs<nobs; iobs++)\n    {\n        // Figure out the origin time\n        ierr = sacio_getEpochalStartTime(data[iobs].header, &epoch);\n        if (ierr != 0)\n        {\n            fprintf(stderr, \"%s: Failed to get start time\\n\", __func__);\n            break;\n        }\n        for (idep=0; idep<ndepth; idep++)\n        {\n            for (it=0; it<ntstar; it++)\n            {\n                ierr = prepmt_greens_getHudson96GreensFunctionsIndices(\n                                        nobs, ntstar, ndepth,\n                                        iobs, it, idep, indices);\n                // Figure out the origin time\n                ierr = sacio_getEpochalStartTime(grns[indices[0]].header,\n                                                 &epochGrns);\n                if (ierr != 0)\n                {\n                    fprintf(stderr, \"%s: Failed to get start time\\n\", __func__);\n                    break;\n                }\n                // Fig\n            }\n        }\n    }\n    return 0;\n}\n//============================================================================//\n/*!\n * @brief Processes the Green's functions.\n *\n * @param[in,out] grns    On input contains the Green's functions for all\n *                        observations, depths, and t*'s as well as the\n *                        processing chains. \\n\n *                        On output contains the filtered Green's functions\n *                        for all observations, depths, and t*'s.\n *\n * @result 0 indicates success.\n *\n * @author Ben Baker, ISTI\n *\n */\nint prepmt_grnsTeleB_processHudson96Greens(\n    const int nobs, const int ntstar, const int ndepth,\n    const struct prepmtCommands_struct cmds,\n    struct sacData_struct *grns)\n{\n    struct serialCommands_struct commands;\n    struct parallelCommands_struct parallelCommands;\n    double *G, dt, dt0, epoch, epoch0, time;\n    int *dataPtr, indices[6], \n        i, i0, i1, i2, ierr, iobs, idep, it, kndx, l, npts, npts0, nq,\n        nwork, ny, ns, nsuse;\n    bool lnewDt, lnewStartTime;\n    const int nTimeVars = 12;\n    const enum sacHeader_enum timeVars[12]\n       = {SAC_FLOAT_A, SAC_FLOAT_O, \n          SAC_FLOAT_T0, SAC_FLOAT_T1, SAC_FLOAT_T2, SAC_FLOAT_T3,\n          SAC_FLOAT_T4, SAC_FLOAT_T5, SAC_FLOAT_T6, SAC_FLOAT_T7,\n          SAC_FLOAT_T8, SAC_FLOAT_T9};\n    const int spaceInquiry =-1;\n    // Loop on the observations\n    ns = ndepth*ntstar*6;\n    dataPtr = memory_calloc32i(ns);\n    for (iobs=0; iobs<nobs; iobs++)\n    {\n        // Set the processing structure\n        memset(&parallelCommands, 0,\n               sizeof(struct parallelCommands_struct)); \n               memset(&commands, 0, sizeof(struct serialCommands_struct));\n        kndx = prepmt_greens_getHudson96GreensFunctionIndex(G11_GRNS,\n                                                      nobs, ntstar, ndepth,\n                                                      iobs, 0, 0);\n        // Parse the commands\n        ierr = process_stringsToSerialCommandsOptions(\n                                      cmds.cmds[iobs].ncmds,\n                                      (const char **) cmds.cmds[iobs].cmds,\n                                      &commands);\n        if (ierr != 0)\n        {\n            fprintf(stderr, \"%s: Error setting serial command string\\n\",\n                    __func__);\n            goto ERROR;\n        }\n        // Determine some characteristics of the processing\n        sacio_getEpochalStartTime(grns[kndx].header, &epoch0);\n        sacio_getFloatHeader(SAC_FLOAT_DELTA, grns[kndx].header, &dt0);\n        lnewDt = false;\n        lnewStartTime = false;\n        epoch = epoch0;\n        dt = dt0;\n        for (i=0; i<commands.ncmds; i++)\n        {\n            if (commands.commands[i].type == CUT_COMMAND)\n            {\n                i0 = commands.commands[i].cut.i0;\n                epoch = epoch + (double) i0*dt;\n                lnewStartTime = true;\n            }\n            if (commands.commands[i].type == DOWNSAMPLE_COMMAND)\n            {\n                nq = commands.commands[i].downsample.nq;\n                dt = dt*(double) nq;\n                lnewDt = true;\n            }\n            if (commands.commands[i].type == DECIMATE_COMMAND)\n            {\n                nq = commands.commands[i].decimate.nqAll;\n                dt = dt*(double) nq;\n                lnewDt = true;\n            }\n        }\n        // Set the commands on the parallel processing structure\n        ierr = process_setCommandOnAllParallelCommands(ns, commands,\n                                                       &parallelCommands);\n        if (ierr != 0)\n        {\n            fprintf(stderr, \"%s: Error setting the parallel commands\\n\",\n                    __func__);\n            goto ERROR;\n        }\n        // Get the data\n        dataPtr[0] = 0;\n        for (idep=0; idep<ndepth; idep++)\n        {\n            for (it=0; it<ntstar; it++)\n            {\n                kndx = prepmt_greens_getHudson96GreensFunctionIndex(G11_GRNS,\n                                                          nobs, ntstar, ndepth,\n                                                          iobs, 0, 0);\n                ierr = sacio_getIntegerHeader(SAC_INT_NPTS,\n                                              grns[kndx].header, &npts);\n                if (ierr != 0)\n                {\n                    fprintf(stderr, \"%s: Error getting npts\\n\", __func__);\n                    goto ERROR;\n                }\n                i1 = idep*6*ntstar + it*6 + 0;\n                i2 = i1 + 6;\n                for (i=i1; i<i2; i++)\n                {\n                    dataPtr[i+1] = dataPtr[i] + npts;\n                }\n            }\n        }\n        nwork = dataPtr[6*ndepth*ntstar];\n        if (nwork < 1)\n        {\n            fprintf(stderr, \"%s: Invalid workspace size: %d\\n\",\n                    __func__, nwork);\n            ierr = 1;\n            goto ERROR;\n        } \n        G = memory_calloc64f(nwork);\n        for (idep=0; idep<ndepth; idep++)\n        {\n            for (it=0; it<ntstar; it++)\n            {\n                ierr = prepmt_greens_getHudson96GreensFunctionsIndices(\n                                        nobs, ntstar, ndepth,\n                                        iobs, it, idep, indices);\n                if (ierr != 0)\n                {\n                    fprintf(stderr, \"%s: Error getting index\\n\", __func__);\n                    goto ERROR;\n                }\n                for (i=0; i<6; i++)\n                {\n                    i1 = idep*6*ntstar + it*6 + i;\n                    cblas_dcopy(grns[indices[i]].npts, \n                                grns[indices[i]].data, 1, &G[dataPtr[i1]], 1);\n                }\n            }\n        }\n        // Set the data\n        ierr =  process_setParallelCommandsData64f(ns, dataPtr,\n                                                   G, &parallelCommands);\n        if (ierr != 0)\n        {\n            fprintf(stderr, \"%s: Error setting data\\n\", __func__);\n            goto ERROR;\n        }\n        // Apply the commands\n        ierr = process_applyParallelCommands(&parallelCommands);\n        if (ierr != 0)\n        {\n            fprintf(stderr, \"%s: Error processing data\\n\", __func__);\n            goto ERROR;\n        }\n        // Get the data\n        ierr = process_getParallelCommandsData64f(parallelCommands,\n                                                  spaceInquiry, spaceInquiry,\n                                                  &ny, &nsuse,\n                                                  dataPtr, G);\n        if (ny < nwork)\n        {\n            memory_free64f(&G);\n            G = memory_calloc64f(ny);\n        }\n        ny = nwork;\n        ierr = process_getParallelCommandsData64f(parallelCommands,\n                                                  nwork, ns,\n                                                  &ny, &nsuse, dataPtr, G); \n        if (ierr != 0)\n        {\n            fprintf(stderr, \"%s: Error getting data\\n\", __func__);\n            goto ERROR;\n        }\n        // Unpack the data\n        for (idep=0; idep<ndepth; idep++)\n        {\n            for (it=0; it<ntstar; it++)\n            {\n                ierr = prepmt_greens_getHudson96GreensFunctionsIndices(\n                                        nobs, ntstar, ndepth,\n                                        iobs, it, idep, indices);\n                if (ierr != 0)\n                {\n                    fprintf(stderr, \"%s: Error getting index\\n\", __func__);\n                    goto ERROR;\n                }\n                for (i=0; i<6; i++)\n                {\n                    i1 = idep*6*ntstar + it*6 + i;\n                    sacio_getIntegerHeader(SAC_INT_NPTS,  \n                                           grns[indices[i]].header, &npts0);\n                    npts = dataPtr[i1+1] - dataPtr[i1];\n                    // Resize event\n                    if (npts != npts0)\n                    {\n                        sacio_freeData(&grns[indices[i]]);\n                        grns[indices[i]].data = sacio_malloc64f(npts);\n                        grns[indices[i]].npts = npts;\n                        sacio_setIntegerHeader(SAC_INT_NPTS, npts,\n                                               &grns[indices[i]].header);\n                        ierr = array_copy64f_work(npts,\n                                                  &G[dataPtr[i]],\n                                                  grns[indices[i]].data);\n                    }\n                    else\n                    {\n                        ierr = array_copy64f_work(npts,\n                                                  &G[dataPtr[i]],\n                                                  grns[indices[i]].data);\n                    }\n                    // Update the times\n                    if (lnewStartTime)\n                    {\n                        for (i=0; i<6; i++)\n                        {\n                            // Update the picks\n                            for (l=0; l<nTimeVars; l++)\n                            {\n                                ierr = sacio_getFloatHeader(timeVars[l],\n                                              grns[indices[i]].header, &time);\n                                if (ierr == 0)\n                                {\n                                    time = time + epoch0; // Turn to real time\n                                    time = time - epoch;  // Relative to new time\n                                    sacio_setFloatHeader(timeVars[l], time,\n                                                    &grns[indices[i]].header);\n                                }\n                            } // Loop on picks\n                            sacio_setEpochalStartTime(epoch,\n                                                      &grns[indices[i]].header);\n                        } // Loop on signals\n                    }\n                    // Update the sampling period\n                    if (lnewDt)\n                    {\n                        for (i=0; i<6; i++)\n                        {\n                            sacio_setFloatHeader(SAC_FLOAT_DELTA, dt,\n                                                 &grns[indices[i]].header);\n                        }\n                    }\n                } // Loop on Green's functions gxx, gyy, ...\n            } // Loop on t*\n        } // Loop on depths\n        process_freeSerialCommands(&commands);\n        process_freeParallelCommands(&parallelCommands);\n        memory_free64f(&G);\n    }\nERROR:;\n    memory_free32i(&dataPtr);\n    return 0;\n}\n//============================================================================//\n/*!\n * @brief Reads the teleseismic body wave Green's functions modeling parameters.\n *\n * @param[in] iniFile           Name of initialization file.\n * @param[in] section           Section of initalization file to read.  For\n *                              example, this may be prepmt:telePGrns.\n * @param[out] archiveFile      This is the HDF5 file with the observed waveforms.\n * @param[out] parmtDataFile    This is the name of the data archive file to\n *                              be used by parmt.\n * @param[out] luseCrust1       If true then the modeling may use crust1 \n *                              at the source and receiver (unless superseded\n *                              by a specified local model). \\n\n *                              Otherwise, use a local model or the global \n *                              ak135 earth model.\n * @param[out] crustDir         The crust1.0 directory.  This is only relevant\n *                              if luseCrust1 is true.\n * @param[out] luseSourceModel  If true then use a local source model.\n * @param[out] sourceModel      If luseSourceModel is true then this is the\n *                              filename with the local source model.\n * @param[out] luseTstarTable   If true then read the t* attenuation factors\n *                              from a table.\n * @param[out] defaultTstar     This is the default t* (e.g., 0.4).\n * @param[out] tstarTable       If luseTstarTable is true then this is the file\n *                              with the station/t* table pairings.\n * @param[out] lreprickGrns     If true then repick the Green's functions with\n *                              an STA/LTA function.  This is in the context of\n *                              severe attenutation which noticeably effect\n *                              theoretical arrival times.\n * @param[out] staWin           If repicking Green's functions then this\n *                              is the short term window (seconds).\n * @param[out] ltaWin           If repicking Green's functions then this\n *                              is the long term window (seconds).  \n * @param[out] staltaThreshPct  This is the fraction (0,1) after which an \n *                              arrival is declared in the STA/LTA repicking.\n * @param[out] lalignXC         If true the the Green's functions will be \n *                              re-aligned with cross-correlation.\n * @param[out] luseEnvelope     If true and lalignXC is true then the \n *                              Green's functions will be aligned based on \n *                              the cross-correlation of their envelopes.\n * @param[out] lnormalizeXC     If true then each Green's function is normalized\n *                              in the Green's function cross-correlation thus\n *                              Green's functions with larger amplitudes may \n *                              bias the result.\n * @param[out] maxXCtimeLag     This is the max time lag (seconds) available to\n *                              the waveform cross-correlation alignment.\n * @param[out] ndepth           Number of depths in modeling.\n * @param[in,out] depths        On input this is a NULL pointer.\n *                              On output this is a pointer to an array \n *                              of dimension [ndepth] with the modeling depths\n *                              (km).\n *\n * @result 0 indicates success.\n *\n * @author Ben Baker, ISTI\n *\n */\nint prepmt_grnsTeleB_readParameters(const char *iniFile,\n                                    const char *section,\n                                    char archiveFile[PATH_MAX],\n                                    char parmtDataFile[PATH_MAX],\n                                    bool *luseCrust1,\n                                    char crustDir[PATH_MAX],\n                                    bool *luseSourceModel,\n                                    char sourceModel[PATH_MAX],\n                                    bool *luseTstarTable,\n                                    double *defaultTstar,\n                                    char tstarTable[PATH_MAX],\n                                    bool *lrepickGrns,\n                                    double *staWin, double *ltaWin,\n                                    double *staltaThreshPct,\n                                    bool *lalignXC,\n                                    bool *luseEnvelope,\n                                    bool *lnormalizeXC,\n                                    double *maxXCtimeLag,\n                                    int *ndepth, double **depths)\n{\n    const char *s;\n    char vname[256];\n    dictionary *ini;\n    char *dirName;\n    double *deps, dmin, dmax;\n    int ierr;\n\n    ierr = 0;\n    deps = NULL;\n    memset(archiveFile, 0, PATH_MAX*sizeof(char));\n    memset(crustDir, 0, PATH_MAX*sizeof(char));\n    memset(sourceModel, 0, PATH_MAX*sizeof(char));\n    memset(tstarTable, 0, PATH_MAX*sizeof(char));\n    memset(parmtDataFile, 0, PATH_MAX*sizeof(char));\n    if (!os_path_isfile(iniFile))\n    {\n        fprintf(stderr, \"%s: Error ini file does not exist\\n\", __func__);\n        return -1;\n    }\n    ini = iniparser_load(iniFile);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:dataH5File\", section);\n    s = iniparser_getstring(ini, vname, NULL);\n    if (!os_path_isfile(s))\n    {\n        fprintf(stderr, \"%s: Data file %s does not exist\\n\", __func__, s);\n        ierr = 1;\n        goto ERROR;\n    }\n    strcpy(archiveFile, s);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:parmtDataFile\", section);\n    s = iniparser_getstring(ini, vname, \"bodyWave.h5\"); \n    strcpy(parmtDataFile, s);\n\n    dirName = os_dirname(parmtDataFile, &ierr);\n    if (!os_path_isdir(dirName))\n    {\n        ierr = os_makedirs(dirName);\n        if (ierr != 0)\n        {\n            fprintf(stderr, \"%s: Failed to make directory: %s\\n\",\n                    __func__, dirName);\n            goto ERROR;\n        }\n    }\n    memory_free8c(&dirName);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:lrepickGrns\", section);\n    *lrepickGrns = iniparser_getboolean(ini, vname, false);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:staWin\", section);\n    *staWin = iniparser_getdouble(ini, vname, 0.2);\n    if (*staWin <= 0.0)\n    {\n        fprintf(stderr, \"%s: Invalid STA length %f\\n\", __func__, *staWin);\n        ierr = 1;\n        goto ERROR;\n    }\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:ltaWin\", section);\n    *ltaWin = iniparser_getdouble(ini, vname, 1.2);\n    if (*ltaWin <= *staWin)\n    {\n        fprintf(stderr, \"%s: Invalid LTA/STA lengths %f %f\\n\",\n                __func__, *staWin, *ltaWin);\n        ierr = 1;\n        goto ERROR;\n    }\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:staltaThreshPct\", section);\n    *staltaThreshPct = iniparser_getdouble(ini, vname, 0.8);\n    if (*staltaThreshPct <= 0.0 || *staltaThreshPct > 1.0)\n    {\n        fprintf(stderr, \"%s: Invalid STA/LTA thresh pct %f\\n\",\n                 __func__, *staltaThreshPct);\n        ierr = 1;\n        goto ERROR;\n    }\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:luseTstarTable\", section);\n    *luseTstarTable = iniparser_getboolean(ini, vname, false);\n    if (*luseTstarTable)\n    {\n        memset(vname, 0, 256*sizeof(char));\n        sprintf(vname, \"%s:tstarTable\", section);\n        s = iniparser_getstring(ini, vname, NULL);\n        if (!os_path_isfile(s))\n        {\n            fprintf(stderr, \"%s: tstar table %s doesn't exist\\n\",\n                    __func__, s);\n            ierr = 1;\n            goto ERROR;\n        }\n        strcpy(tstarTable, s);\n    }\n\n    memset(vname, 0, 256*sizeof(char));\n    strcpy(vname, \"precompute:ndepths\\0\");\n    *ndepth = iniparser_getint(ini, vname, 0);\n    if (*ndepth < 1)\n    {\n        fprintf(stderr, \"%s: Inadequate number of depths %d\\n\",\n                __func__, *ndepth);\n        ierr = 1;\n        goto ERROR;\n    }\n\n    memset(vname, 0, 256*sizeof(char));\n    strcpy(vname, \"precompute:depthMin\\0\");\n    dmin = iniparser_getdouble(ini, vname, -1.0);\n\n    memset(vname, 0, 256*sizeof(char));\n    strcpy(vname, \"precompute:depthMax\\0\");\n    dmax = iniparser_getdouble(ini, vname, -1.0);\n    if (dmin < 0.0 || dmin > dmax)\n    {\n        fprintf(stderr, \"%s: Invalid dmin/dmax %f %f\\n\", __func__, dmin, dmax);\n        ierr = 1;\n        goto ERROR;\n    }\n    deps = array_linspace64f(dmin, dmax, *ndepth, &ierr);\n\n    memset(vname, 0, 256*sizeof(char));\n    strcpy(vname, \"precompute:luseCrust1\\0\");\n    *luseCrust1 = iniparser_getboolean(ini, vname, true);\n    if (*luseCrust1)\n    {\n        memset(vname, 0, 256*sizeof(char));\n        strcpy(vname, \"precompute:crustDir\\0\");\n        s = iniparser_getstring(ini, vname, CPS_DEFAULT_CRUST1_DIRECTORY);\n        if (!os_path_isdir(s))\n        {\n            fprintf(stderr, \"%s: crust1.0 directory %s doesn't exist\\n\",\n                    __func__, s);\n            ierr = 1;\n            goto ERROR;\n        }\n        strcpy(crustDir, s);\n    }\n\n    memset(vname, 0, 256*sizeof(char));\n    strcpy(vname, \"precompute:luseSourceModel\\0\");\n    *luseSourceModel = iniparser_getboolean(ini, vname, false);\n    if (*luseSourceModel)\n    {\n        memset(vname, 0, 256*sizeof(char));\n        strcpy(vname, \"precompute:sourceModel\\0\");\n        s = iniparser_getstring(ini, vname, NULL);\n        if (!os_path_isfile(s))\n        {\n            fprintf(stderr, \"%s: Source model %s does not exist\\n\",\n                    __func__, s);\n            ierr = 1;\n            goto ERROR;\n        }\n        strcpy(sourceModel, s);\n    }\n       \n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:defaultTstar\", section); \n    *defaultTstar = iniparser_getdouble(ini, vname, 0.4);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:lalignXC\", section);\n    *lalignXC = iniparser_getboolean(ini, vname, false);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:luseEnvelope\", section);\n    *luseEnvelope = iniparser_getboolean(ini, vname, false);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:lnormalizeXC\", section);\n    *lnormalizeXC = iniparser_getboolean(ini, vname, false);\n\n    memset(vname, 0, 256*sizeof(char));\n    sprintf(vname, \"%s:maxXCtimeLag\", section);\n    *maxXCtimeLag = iniparser_getdouble(ini, vname, -1.0);\n \nERROR:;\n    *depths = deps;\n    iniparser_freedict(ini);\n    return ierr;\n}\n//============================================================================//\n/*!\n * @brief Utility function for reading the data for which the Green's functions\n *        will be generated.\n *\n * @param[in] archiveFile  Name of HDF5 archive file containing the\n *                         observations.\n *\n * @param[out] nobs        Number of observations.\n * @param[out] ierr        0 indicates success.\n *\n * @result The SAC data from the H5 archive for which the Green's functions\n *         will be created.  This is an array of dimension [nobs].\n *\n * @author Ben Baker, ISTI\n *\n */\nstruct sacData_struct *\n    prepmt_grnsTeleB_readData(const char *archiveFile, int *nobs, int *ierr)\n{\n    char **sacFiles;\n    hid_t groupID, fileID;\n    int i, nfiles;\n    struct sacData_struct *sacData;\n    *nobs = 0;\n    sacData = NULL;\n    if (!os_path_isfile(archiveFile))\n    {\n        fprintf(stderr, \"%s: Error archive file %s doesn't exist\\n\",\n                __func__, archiveFile);\n        *ierr = 1;\n        return sacData;\n    }\n    fileID = H5Fopen(archiveFile, H5F_ACC_RDONLY, H5P_DEFAULT); \n    groupID = H5Gopen2(fileID, \"/ObservedWaveforms\", H5P_DEFAULT);\n    sacFiles = sacioh5_getFilesInGroup(groupID, &nfiles, ierr);\n    if (*ierr != 0 || sacFiles == NULL)\n    {\n        fprintf(stderr, \"%s: Error getting names of SAC flies\\n\", __func__);\n        *ierr = 1;\n        return sacData;\n    }\n    sacData = sacioh5_readTimeSeriesList(nfiles, (const char **) sacFiles,\n                                         groupID, nobs, ierr);\n    if (*ierr != 0)\n    {\n        fprintf(stderr, \"%s: Errors while reading SAC files\\n\", __func__);\n    }\n    if (*nobs != nfiles)\n    {\n        fprintf(stderr, \"%s: Warning - subset of data was read\\n\", __func__);\n    }\n    // Clean up and close archive file\n    for (i=0; i<nfiles; i++)\n    {\n        if (sacFiles[i] != NULL){free(sacFiles[i]);}\n    }\n    free(sacFiles);\n    H5Gclose(groupID);\n    H5Fclose(fileID);\n    return sacData;\n}\n//============================================================================//\n/*!\n * @brief Parses the command line arguments for the ini file.\n *\n * @param[in] argc      Number of arguments input to the program.\n * @param[in] argv      Command line arguments.\n *\n * @param[out] iniFile  If the result is 0 then this is the ini file.\n * @param[out] section  Section of ini file to read.  The default is\n *                      prepmt:telePGrns. \n *\n * @result 0 indicates success. \\n\n *        -1 indicates the user inquired about the usage. \\n\n *        -2 indicates the command line argument is invalid.\n *\n * @author Ben Baker, ISTI\n *\n */\nstatic int parseArguments(int argc, char *argv[],\n                          char iniFile[PATH_MAX], char section[256])\n{\n    bool linFile, lsection;\n    linFile = false;\n    lsection = false;\n    memset(iniFile, 0, PATH_MAX*sizeof(char));\n    memset(section, 0, 256*sizeof(char));\n    while (true)\n    {\n        static struct option longOptions[] =\n        {\n            {\"help\", no_argument, 0, '?'},\n            {\"help\", no_argument, 0, 'h'},\n            {\"ini_file\", required_argument, 0, 'i'},\n            {\"section\", required_argument, 0, 's'},\n            {0, 0, 0, 0}\n        };\n        int c, optionIndex;\n        c = getopt_long(argc, argv, \"?hi:s:\",\n                        longOptions, &optionIndex);\n        if (c ==-1){break;}\n        if (c == 'i')\n        {\n            strcpy(iniFile, (const char *) optarg);\n            linFile = true;\n        }\n        else if (c == 's')\n        {\n            strcpy(section, (const char *) optarg);\n            lsection = true;\n        }\n        else if (c == 'h' || c == '?')\n        {\n            printUsage();\n            return -2;\n        }\n        else\n        {\n            printf(\"%s: Unknown options: %s\\n\",\n                   PROGRAM_NAME, argv[optionIndex]);\n        }\n    }\n    if (!linFile)\n    {\n        printf(\"%s: Error must specify ini file\\n\\n\", PROGRAM_NAME);\n        printUsage();\n        return -1;\n    }\n    else\n    {\n        if (!os_path_isfile(iniFile))\n        {\n            printf(\"%s: Error - ini file: %s does not exist\\n\",\n                   PROGRAM_NAME, iniFile);\n            return EXIT_FAILURE;\n        }\n    }\n    if (!lsection){strcpy(section, \"prepmt:telePGrns\\0\");}\n    return 0;\n}\n//============================================================================//\nstatic void printUsage(void)\n{\n    printf(\"Usage:\\n   %s -i ini_file\\n\\n\", PROGRAM_NAME);\n    printf(\"Required arguments:\\n\");\n    printf(\"    -i ini_file specifies the initialization file\\n\");\n    printf(\"\\n\");\n    printf(\"Optional arguments:\\n\");\n    printf(\"    -h displays this message\\n\");\n    printf(\"    -s section of ini file to read\\n\");\n    return;\n}\n", "meta": {"hexsha": "06d1d5c5af8518df9d0acc4b5c4e2973b8c7f5b9", "size": 43121, "ext": "c", "lang": "C", "max_stars_repo_path": "prepmt/grnsTeleB.c", "max_stars_repo_name": "bakerb845/parmt", "max_stars_repo_head_hexsha": "2b4097df02ef5e56407d40e821d5c7155c2e4416", "max_stars_repo_licenses": ["Intel"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "prepmt/grnsTeleB.c", "max_issues_repo_name": "bakerb845/parmt", "max_issues_repo_head_hexsha": "2b4097df02ef5e56407d40e821d5c7155c2e4416", "max_issues_repo_licenses": ["Intel"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "prepmt/grnsTeleB.c", "max_forks_repo_name": "bakerb845/parmt", "max_forks_repo_head_hexsha": "2b4097df02ef5e56407d40e821d5c7155c2e4416", "max_forks_repo_licenses": ["Intel"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.0255731922, "max_line_length": 82, "alphanum_fraction": 0.4891584147, "num_tokens": 10240, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.39981165504266236, "lm_q2_score": 0.02635535102983882, "lm_q1q2_score": 0.010537176514470194}}
{"text": "#include <string.h>\n#include <alloca.h>\n#include <math.h>\n#include <mpi.h>\n\n#include <kdcount/kdtree.h>\n\n#include <fastpm/libfastpm.h>\n#include <gsl/gsl_rng.h>\n\n#include <fastpm/prof.h>\n#include <fastpm/logging.h>\n#include <fastpm/store.h>\n\n#include <fastpm/fof.h>\n\n#include \"pmpfft.h\"\n#include \"pm2lpt.h\"\n#include \"pmghosts.h\"\n#include \"vpm.h\"\n\n#include <fastpm/io.h>\n#include <fastpm/string.h>\n#include <bigfile-mpi.h>\n\n//#define FASTPM_FOF_DEBUG\n\nstruct FastPMFOFFinderPrivate {\n    int ThisTask;\n    int NTask;\n    double * boxsize;\n    MPI_Comm comm;\n};\n\n/* creating a kdtree struct\n * for store with np particles starting from start.\n * */\nstruct KDTreeNodeBuffer {\n    void * mem;\n    void * base;\n    char * ptr;\n    char * end;\n    struct KDTreeNodeBuffer * prev;\n};\n\n\nstatic void *\n_kdtree_buffered_malloc(void * userdata, size_t size)\n{\n    struct KDTreeNodeBuffer ** pbuffer = (struct KDTreeNodeBuffer**) userdata;\n\n    struct KDTreeNodeBuffer * buffer = *pbuffer;\n\n    if(buffer->base == NULL || buffer->ptr + size >= buffer->end) {\n        struct KDTreeNodeBuffer * newbuffer = malloc(sizeof(newbuffer[0]));\n        newbuffer->mem = buffer->mem;\n        size_t newsize = 1024 * 1024 * 4; /* 4 MB for each block */\n        if(newsize < size) {\n            newsize = size;\n        }\n        newbuffer->base = fastpm_memory_alloc(buffer->mem, \"KDTreeBase\", newsize, FASTPM_MEMORY_STACK);\n        newbuffer->ptr = newbuffer->base;\n        newbuffer->end = newbuffer->base + newsize;\n        newbuffer->prev = buffer;\n\n        *pbuffer = newbuffer;\n        buffer = newbuffer;\n    }\n\n    void * r = buffer->ptr;\n    buffer->ptr += size;\n    return r;\n}\n\nstatic void\n_kdtree_buffered_free(void * userdata, size_t size, void * ptr)\n{\n    /* do nothing; */\n}\n\nstatic \nKDNode *\n_create_kdtree (KDTree * tree, int thresh,\n    FastPMStore ** stores, int nstore,\n    double boxsize[])\n{\n    /* if boxsize is NULL the tree will be non-periodic. */\n    /* the allocator; started empty. */\n    struct KDTreeNodeBuffer ** pbuffer = malloc(sizeof(void*));\n    struct KDTreeNodeBuffer * headbuffer = malloc(sizeof(headbuffer[0]));\n    *pbuffer = headbuffer;\n\n    headbuffer->mem = stores[0]->mem;\n    headbuffer->base = NULL;\n    headbuffer->prev = NULL;\n\n    int s;\n    ptrdiff_t i;\n\n    tree->userdata = pbuffer;\n\n    tree->input.dims[0] = 0;\n\n    for(s = 0; s < nstore; s ++) {\n        tree->input.dims[0] += stores[s]->np;\n    }\n\n    tree->input.dims[1] = 3;\n\n    if(tree->input.dims[0] < stores[0]->np_upper) {\n        /* if the first store is big enough, use it for the tree */\n        tree->input.buffer = (void*) &stores[0]->x[0][0];\n    } else {\n        /* otherwise, allocate a big buffer and make a copy */\n        tree->input.buffer = _kdtree_buffered_malloc(pbuffer,\n                    tree->input.dims[0] * sizeof(stores[0]->x[0]));\n        memcpy(tree->input.buffer, &stores[0]->x[0][0], stores[0]->np * sizeof(stores[0]->x[0]));\n    }\n\n    i = stores[0]->np;\n\n    /* copy the other positions to the base pointer. */\n    for(s = 1; s < nstore; s ++) {\n        memcpy(((char*) tree->input.buffer) + i * sizeof(stores[0]->x[0]),\n                &stores[s]->x[0][0],\n                stores[s]->np * sizeof(stores[0]->x[0]));\n\n        i = i + stores[s]->np;\n    }\n\n    tree->input.strides[0] = sizeof(stores[0]->x[0]);\n    tree->input.strides[1] = sizeof(stores[0]->x[0][0]);\n    tree->input.elsize = sizeof(stores[0]->x[0][0]);\n    tree->input.cast = NULL;\n\n    tree->ind = _kdtree_buffered_malloc(pbuffer, tree->input.dims[0] * sizeof(tree->ind[0]));\n    for(i = 0; i < tree->input.dims[0]; i ++) {\n        tree->ind[i] = i;\n    }\n    tree->ind_size = tree->input.dims[0];\n\n    tree->malloc = _kdtree_buffered_malloc;\n    tree->free = _kdtree_buffered_free;\n\n    tree->thresh = thresh;\n\n    tree->boxsize = boxsize;\n\n    KDNode * root = kd_build(tree);\n    fastpm_info(\"Creating KDTree with %td nodes for %td particles\\n\", tree->size, tree->ind_size);\n    return root;\n}\n\nvoid \n_free_kdtree (KDTree * tree, KDNode * root)\n{\n    kd_free(root);\n    struct KDTreeNodeBuffer * buffer, *q, **pbuffer = tree->userdata;\n\n    for(buffer = *pbuffer; buffer; buffer = q) {\n        if(buffer->base)\n            fastpm_memory_free(buffer->mem, buffer->base);\n        q = buffer->prev;\n        free(buffer);\n    }\n    free(pbuffer);\n}\n\nvoid\nfastpm_fof_init(FastPMFOFFinder * finder, FastPMStore * store, PM * pm)\n{\n    finder->priv = malloc(sizeof(FastPMFOFFinderPrivate));\n    finder->p = store;\n    finder->pm = pm;\n\n    finder->event_handlers = NULL;\n\n    if (finder->periodic)\n        finder->priv->boxsize = pm_boxsize(pm);\n    else\n        finder->priv->boxsize = NULL;\n\n    finder->priv->comm = pm_comm(pm);\n    MPI_Comm comm = finder->priv->comm;\n    MPI_Comm_rank(comm, &finder->priv->ThisTask);\n    MPI_Comm_size(comm, &finder->priv->NTask);\n}\n\nstatic void\n_fof_local_find(FastPMFOFFinder * finder,\n            FastPMStore * p,\n            PMGhostData * pgd,\n            ptrdiff_t * head, double linkinglength)\n{\n    /* local find of p and the the ghosts */\n    KDTree tree;\n\n    FastPMStore * stores[2] = {p, pgd->p};\n\n    KDNode * root = _create_kdtree(&tree, finder->kdtree_thresh, stores, 2, finder->priv->boxsize);\n\n    kd_fof(root, linkinglength, head);\n\n    _free_kdtree(&tree, root);\n}\n\nstatic int\n_merge(uint64_t * src, ptrdiff_t isrc, uint64_t * dest, ptrdiff_t idest, ptrdiff_t * head)\n{\n    int merge = 0;\n    ptrdiff_t j = head[idest];\n    if(src[isrc] < dest[j]) {\n        merge = 1;\n    }\n\n    if(merge) {\n        dest[j] = src[isrc];\n    }\n    return merge;\n}\n\nstruct reduce_fof_data {\n    ptrdiff_t * head;\n    size_t nmerged;\n};\n\nstatic void\nFastPMReduceFOF(FastPMStore * src, ptrdiff_t isrc, FastPMStore * dest, ptrdiff_t idest, int ci, void * userdata)\n{\n\n    struct reduce_fof_data * data = userdata;\n\n    data->nmerged += _merge(src->minid, isrc, dest->minid, idest, data->head);\n}\n\n\nstatic void\n_fof_global_merge(\n    FastPMFOFFinder * finder,\n    FastPMStore * p,\n    PMGhostData * pgd,\n    uint64_t * minid,\n    ptrdiff_t * head\n)\n{\n    ptrdiff_t i;\n\n    MPI_Comm comm = finder->priv->comm;\n\n    size_t npmax = p->np;\n\n    MPI_Allreduce(MPI_IN_PLACE, &npmax, 1, MPI_LONG, MPI_MAX, comm);\n\n    /* initialize minid, used as a global tag of groups as we merge */\n    for(i = 0; i < p->np; i ++) {\n        /* assign unique ID to each particle; could use a better scheme with true offsets */\n        minid[i] = i + finder->priv->ThisTask * npmax;\n        #ifdef FASTPM_FOF_DEBUG\n        /* for debugging, overwrite the previous unique ID with the true ID of particles */\n        minid[i] = p->id[i];\n        #endif\n    }\n\n    /* send minid */\n    p->minid = minid; /* only send up to p->np */\n    pm_ghosts_send(pgd, COLUMN_MINID);\n    p->minid = NULL;\n\n    /* copy over to minid for storage; FIXME: allow overriding  */\n    for(i = 0; i < pgd->p->np; i ++) {\n        minid[i + p->np] = pgd->p->minid[i];\n    }\n\n    /* reduce the minid of the head items according to the local connection. */\n\n    while(1) {\n        size_t nmerge = 0;\n        for(i = 0; i < p->np + pgd->p->np; i ++) {\n            nmerge += _merge(minid, i, minid, i, head);\n        }\n        if(nmerge == 0) break;\n    }\n\n#ifdef FASTPM_FOF_DEBUG\n    {\n        FILE * fp = fopen(fastpm_strdup_printf(\"dump-pos-%d.f8\", finder->priv->ThisTask), \"w\");\n        fwrite(p->x, p->np, sizeof(double) * 3, fp);\n        fwrite(pgd->p->x, pgd->p->np, sizeof(double) * 3, fp);\n        fclose(fp);\n    }\n    {\n        FILE * fp = fopen(fastpm_strdup_printf(\"dump-id-%d.f8\", finder->priv->ThisTask), \"w\");\n        fwrite(p->id, p->np, sizeof(int64_t), fp);\n        fwrite(pgd->p->id, pgd->p->np, sizeof(int64_t) * 3, fp);\n        fclose(fp);\n    }\n\n#endif\n    int iter = 0;\n\n    while(1) {\n\n        /* prepare the communication buffer, every ghost has\n         * the minid and task of the current head. such that\n         * they will connect to the other ranks correctly */\n\n        for(i = 0; i < pgd->p->np; i ++) {\n            pgd->p->minid[i] = minid[head[i + p->np]];\n        }\n\n        /* at this point all items on ghosts have local minid and task, ready to reduce */\n\n        struct reduce_fof_data data = {\n            .head = head,\n            .nmerged = 0,\n        };\n\n        /* merge ghosts into the p, reducing the MINID on p */\n\n        p->minid = minid; /* only update up to p->np */\n        pm_ghosts_reduce(pgd, COLUMN_MINID, FastPMReduceFOF, &data);\n        p->minid = NULL;\n\n        size_t nmerged = data.nmerged;\n\n        /* at this point all items on p->fof with head[i] = i have present minid and task */\n\n        MPI_Allreduce(MPI_IN_PLACE, &nmerged, 1, MPI_LONG, MPI_SUM, comm);\n\n        MPI_Barrier(comm);\n\n        fastpm_info(\"FOF reduction iteration %d : merged %td crosslinks\\n\", iter, nmerged);\n\n        if(nmerged == 0) break;\n\n        for(i = 0; i < p->np + pgd->p->np; i ++) {\n            if(minid[i] < minid[head[i]]) {\n                fastpm_raise(-1, \"p->fof invariance is broken i = %td np = %td\\n\", i, p->np);\n            }\n        }\n\n        iter++;\n    }\n\n    /* previous loop only updated head[i]; now make sure every particles has the correct minid. */\n    for(i = 0; i < p->np + pgd->p->np; i ++) {\n        minid[i] = minid[head[i]];\n    }\n\n    #ifdef FASTPM_FOF_DEBUG\n    {\n    for(i = 0; i < p->np + pgd->p->np ; i ++) {\n        uint64_t id = i <p->np?p->id[i]:pgd->p->id[i - p->np];\n        if(minid[i] == 88) {\n            fastpm_ilog(INFO, \"%d MINID == %ld ID = %ld headminid == %ld i = %td / %td head=%td\", finder->priv->ThisTask,\n                minid[i], id, minid[head[i]], i, p->np, head[i]);\n        }\n        if(id == 88 || id == 96 || id == 152 || id == 160) {\n            fastpm_ilog(INFO, \"%d MINID == %ld ID = %ld headminid == %ld i = %td / %td head=%td\", finder->priv->ThisTask,\n                minid[i], id, minid[head[i]], i, p->np, head[i]);\n        }\n    }\n    }\n    #endif\n}\n\n/* set head[i] to hid*/\nstatic size_t\n_assign_halo_attr(FastPMFOFFinder * finder, PMGhostData * pgd, ptrdiff_t * head, size_t np, size_t np_ghosts, int nmin)\n{\n    ptrdiff_t * offset = fastpm_memory_alloc(finder->p->mem, \"FOFOffset\", sizeof(offset[0]) * (np + np_ghosts), FASTPM_MEMORY_STACK);\n    uint8_t * has_remote = fastpm_memory_alloc(finder->p->mem, \"FOFHasRemote\", sizeof(has_remote[0]) * (np + np_ghosts), FASTPM_MEMORY_STACK);\n    uint8_t * has_local = fastpm_memory_alloc(finder->p->mem, \"FOFHasLocal\", sizeof(has_local[0]) * (np + np_ghosts), FASTPM_MEMORY_STACK);\n\n    ptrdiff_t i;\n    for(i = 0; i < np + np_ghosts; i ++) {\n        offset[i] = 0;\n        has_remote[i] = 0;\n        has_local[i] = 0;\n    }\n\n    /* set offset to number of particles in the halo */\n    for(i = 0; i < np + np_ghosts; i ++) {\n        offset[head[i]] ++;\n    }\n\n    for(i = 0; i < np; i ++) {\n        has_local[head[i]] = 1;\n    }\n\n    /* if the group is connected to a remote component */\n    /* if the particle has a ghost, then */\n    pm_ghosts_has_ghosts(pgd, has_remote);\n\n    /* if connected to a particle that has ghost */\n    for(i = 0; i < np; i ++) {\n        if(has_remote[i]) has_remote[head[i]] = 1;\n    }\n\n    /* if connected to a ghost */\n    for(i = np; i < np + np_ghosts; i ++) {\n        has_remote[head[i]] = 1;\n    }\n\n    size_t it = 0;\n\n    /* assign attr index for groups at least contain 1 local particle */\n    for(i = 0; i < np + np_ghosts; i ++) {\n        if(has_local[i] && (has_remote[i] || offset[i] >= nmin)) {\n            offset[i] = it;\n            it ++;\n        } else {\n            offset[i] = -1;\n        }\n    }\n\n    size_t nhalos = it;\n\n    /* update head [i] to offset[head[i]], which stores the index in the halo store for this particle. */\n    for(i = 0; i < np + np_ghosts; i ++) {\n        head[i] = offset[head[i]];\n        /* this will not happen if nmin == 1 */\n        if(head[i] != -1 && head[i] > nhalos) {\n            fastpm_raise(-1, \"head[i] (%td) > nhalos (%td) This shall not happen.\\n\", head[i], nhalos);\n        }\n    }\n\n    fastpm_memory_free(finder->p->mem, has_local);\n    fastpm_memory_free(finder->p->mem, has_remote);\n    fastpm_memory_free(finder->p->mem, offset);\n\n    return it;\n}\nstatic double\nperiodic_add(double x, double wx, double y, double wy, double L)\n{\n    if(wx > 0) {\n        while(y - x > L / 2) y -= L;\n        while(y - x < -L / 2) y += L;\n\n        return wx * x + wy * y;\n    } else {\n        return wy * y;\n    }\n}\n\n/*\n * apply mask to a halo storage.\n * relable head, and halo->id\n * */\nstatic void\nfastpm_fof_subsample(FastPMFOFFinder * finder, FastPMStore * halos, FastPMParticleMaskType * mask, ptrdiff_t * head)\n{\n    /* mapping goes from the old head[i] value to the new head[i] value */\n    ptrdiff_t * mapping = fastpm_memory_alloc(finder->p->mem, \"FOFMapping\", sizeof(mapping[0]) * halos->np, FASTPM_MEMORY_STACK);\n\n    ptrdiff_t i;\n    for(i = 0; i < halos->np; i ++) {\n        mapping[i] = -1;\n        halos->id[i] = i;\n    }\n\n    /* remove non-contributing halo segments */\n    fastpm_store_subsample(halos, mask, halos);\n\n    for(i = 0; i < halos->np; i ++) {\n        mapping[halos->id[i]] = i;\n        halos->id[i] = i;\n    }\n\n    /* adjust head[i] */\n\n    for(i = 0; i < finder->p->np; i ++) {\n        if(head[i] >= 0) {\n            head[i] = mapping[head[i]];\n        }\n    }\n\n    fastpm_memory_free(finder->p->mem, mapping);\n}\n\nstatic void\nfastpm_fof_apply_length_cut(FastPMFOFFinder * finder, FastPMStore * halos, ptrdiff_t * head)\n{\n    MPI_Comm comm = finder->priv->comm;\n\n    FastPMParticleMaskType * mask = fastpm_memory_alloc(finder->p->mem, \"LengthMask\", sizeof(mask[0]) * halos->np, FASTPM_MEMORY_STACK);\n    ptrdiff_t i;\n    for(i = 0; i < halos->np; i ++) {\n        /* remove halos that are shorter than nmin */\n        if(halos->length[i] < finder->nmin) {\n            mask[i] = 0;\n        } else {\n            mask[i] = 1;\n        }\n    }\n    fastpm_fof_subsample(finder, halos, mask, head);\n    fastpm_memory_free(finder->p->mem, mask);\n\n    fastpm_info(\"After length cut we have %td halos (%td including ghost halos).\\n\", \n            fastpm_store_get_mask_sum(halos, comm),\n            fastpm_store_get_np_total(halos, comm));\n}\n\n/* first every undecided halo; then the real halo with particles */\nstatic int\nFastPMLocalSortByMinID(const int i1,\n                    const int i2,\n                    FastPMStore * p)\n{\n    int v1 = (p->minid[i1] < p->minid[i2]);\n    int v2 = (p->minid[i1] > p->minid[i2]);\n\n    return v2 - v1;\n}\n\nstatic int\nFastPMTargetMinID(FastPMStore * store, ptrdiff_t i, void * userdata)\n{\n    FastPMFOFFinder * finder = userdata;\n\n    const uint32_t GOLDEN32 = 2654435761ul;\n    /* const uint64_t GOLDEN64 = 11400714819323198549; */\n    /* may over flow, but should be okay here as the periodicity is ggt NTask */\n    int key = (store->minid[i] * GOLDEN32) % (unsigned) finder->priv->NTask;\n    return key;\n}\n\nstatic int\nFastPMTargetTask(FastPMStore * store, ptrdiff_t i, void * userdata)\n{\n    return store->task[i];\n}\n\n/* for debugging, move particles to a spatially unrelated rank */\nstatic int\nFastPMTargetFOF(FastPMStore * store, ptrdiff_t i, void * userdata)\n{\n#ifdef FASTPM_FOF_DEBUG\n    PM * pm = userdata;\n    int NTask;\n    MPI_Comm_size(pm_comm(pm), &NTask);\n    const uint32_t GOLDEN32 = 2654435761ul;\n    /* const uint64_t GOLDEN64 = 11400714819323198549; */\n    /* may over flow, but should be okay here as the periodicity is ggt NTask */\n    int key = (store->id[i] * GOLDEN32) % (unsigned) NTask;\n    return key;\n#else\n    return FastPMTargetPM(store, i, userdata);\n#endif\n}\n/*\n * This function group halos by halos->minid[i].\n *\n * All halos with the same minid will have the same attribute values afterwards, except\n * a few book keeping items named in this function (see comments inside)\n *\n * */\nstatic void\nfastpm_fof_reduce_halo_attrs(FastPMFOFFinder * finder, FastPMStore * halos,\n        void (* add_func) (FastPMFOFFinder * finder, FastPMStore * halo1, ptrdiff_t i1, FastPMStore * halo2, ptrdiff_t i2 ),\n        void (* reduce_func)(FastPMFOFFinder * finder, FastPMStore * halo1, ptrdiff_t i1)\n)\n{\n\n    ptrdiff_t i;\n\n    ptrdiff_t first = -1;\n    uint64_t lastminid = 0;\n\n    /* ind is the array to use to replicate items */\n    int * ind = fastpm_memory_alloc(finder->p->mem, \"HaloPermutation\", sizeof(ind[0]) * halos->np, FASTPM_MEMORY_STACK);\n\n    /* the following items will have mask[i] == 1, but we will mark some to 0 if\n     * they are not the principle (first) halos segment with this minid */\n    for(i = 0; i < halos->np + 1; i++) {\n        /* we use i == halos->np to terminate the last segment */\n        if(first == -1 || i == halos->np || lastminid != halos->minid[i]) {\n            if (first >= 0) {\n                /* a segment ended */\n                ptrdiff_t j;\n                for(j = first; j < i; j ++) {\n                    ind[j] = first;\n                }\n            }\n            if (i < halos->np) {\n                /* a segment started */\n                halos->mask[i] = 1;\n                lastminid = halos->minid[i];\n            }\n            /* starting a segment of the same halos */\n            first = i;\n        } else {\n            /* inside segment, simply add the ith halo to the first of the segment */\n            halos->mask[i] = 0;\n            add_func(finder, halos, first, halos, i);\n        }\n    }\n\n    /* use permute to replicate the first halo attr to the rest:\n     *\n     * we do not want to replicate\n     * - fof, as fof.task is the original mpi rank of the halo\n     * - id, as it is the original location of the halo on the original mpi rank. \n     * - mask, whether it is primary or not\n     *\n     * we need to replicate because otherwise when we return the head array on the\n     * original ranks will be violated.\n     *   */\n\n    FastPMStore save[1];\n\n    /* FIXME: add a method for this! */\n    memcpy(save->columns, halos->columns, sizeof(save->columns));\n\n    halos->minid = NULL;\n    halos->task = NULL;\n    halos->id = NULL;\n    halos->mask = NULL;\n\n    fastpm_store_permute(halos, ind);\n\n    memcpy(halos->columns, save->columns, sizeof(save->columns));\n\n    for(i = 0; i < halos->np; i++) {\n        reduce_func(finder, halos, i);\n    }\n\n    fastpm_memory_free(finder->p->mem, ind);\n}\n\n\nstatic void\nfastpm_fof_compute_halo_attrs(FastPMFOFFinder * finder, FastPMStore * halos,\n            ptrdiff_t * head,\n            void (*convert_func)(FastPMFOFFinder * finder, FastPMStore * p, ptrdiff_t i, FastPMStore * halos),\n            void (*add_func)(FastPMFOFFinder * finder, FastPMStore * halos, ptrdiff_t i1, FastPMStore * halos2, ptrdiff_t i2),\n            void (*reduce_func)(FastPMFOFFinder * finder, FastPMStore * halos, ptrdiff_t i)\n)\n{\n    MPI_Comm comm = finder->priv->comm;\n\n    FastPMStore h1[1];\n    fastpm_store_init(h1, \"FOF\", 1, halos->attributes, FASTPM_MEMORY_HEAP);\n    ptrdiff_t i;\n\n    for(i = 0; i < finder->p->np; i++) {\n        ptrdiff_t hid = head[i];\n        if(hid < 0) continue;\n\n\n        if(hid >= halos->np) {\n            fastpm_raise(-1, \"halo of a particle out of bounds (%td > %td)\\n\", hid, halos->np);\n        }\n\n        /* initialize h1 with existing halo attributes for this particle */\n        fastpm_store_take(halos, hid, h1, 0);\n\n        convert_func(finder, finder->p, i, h1);\n\n        add_func(finder, halos, hid, h1, 0);\n    }\n\n    fastpm_store_destroy(h1);\n    /* decompose halos by minid (gather); if all halo segments of the same minid are on the same rank, we can combine\n     * these into a single entry, then replicate for each particle to look up;\n     * halo segments that have no local particles are never exchanged to another rank. */\n    if(0 != fastpm_store_decompose(halos,\n            (fastpm_store_target_func) FastPMTargetMinID, finder, comm)) {\n\n        fastpm_raise(-1, \"out of space sending halos by MinID.\\n\");\n    }\n\n    /* now head[i] is no longer the halo attribute of particle i. */\n\n    /* to combine, first local sort by minid; those without local particles are moved to the beginning\n     * so we can easily skip them. */\n    fastpm_store_sort(halos, FastPMLocalSortByMinID);\n\n    /* reduce and update properties */\n    fastpm_fof_reduce_halo_attrs(finder, halos, add_func, reduce_func);\n\n    /* decompose halos by task (return) */\n    if (0 != fastpm_store_decompose(halos,\n            (fastpm_store_target_func) FastPMTargetTask, finder, comm)) {\n        fastpm_raise(-1, \"out of space for gathering halos this shall never happen.\\n\");\n    }\n    /* local sort by id (restore the order) */\n    fastpm_store_sort(halos, FastPMLocalSortByID);\n\n    /* now head[i] is again the halo attribute of particle i. */\n}\n\n/*\n * compute the attrs of the local halo segments based on local particles.\n * head : the hid of each particle; \n * fofsave : the minid of each particle (unique label of each halo)\n *\n * if a halo has no local particles,  halos->mask[i] is set to 0.\n * if a halo has any local particles, and halos->mask[i] is set to 1.\n * */\nstatic void\nfastpm_fof_remove_empty_halos(FastPMFOFFinder * finder, FastPMStore * halos, uint64_t * minid, ptrdiff_t * head)\n{\n\n    /* */\n    ptrdiff_t i;\n\n    /* set minid and task of the halo; all of the halo particles of the same minid needs to be reduced */\n    for(i = 0; i < finder->p->np; i++) {\n        /* set the minid of the halo; need to take care of the ghosts too.\n         * even though we do not add them to the attributes */\n        ptrdiff_t hid = head[i];\n\n        if(hid < 0) continue;\n\n        if(halos->mask[hid] == 0) {\n            /* halo will be reduced by minid */\n            halos->minid[hid] = minid[i];\n            halos->mask[hid] = 1;\n        } else {\n            if(halos->minid[hid] != minid[i]) {\n                fastpm_raise(-1, \"Consistency check failed after FOF global merge.\\n\");\n            }\n        }\n    }\n\n    /* halo will be returned to this task;\n     * we save ThisTask here.*/\n    for(i = 0; i < halos->np; i ++) {\n        halos->task[i] = finder->priv->ThisTask;\n    }\n\n    fastpm_fof_subsample(finder, halos, halos->mask, head);\n}\n\nstatic void\n_add_basic_halo_attrs(FastPMFOFFinder * finder, FastPMStore * halos, ptrdiff_t hid, FastPMStore * h1, ptrdiff_t i)\n{\n    double * boxsize = finder->priv->boxsize;\n\n    if(halos->aemit)\n        halos->aemit[hid] += h1->aemit[i];\n\n    int d;\n\n    for(d = 0; d < 3; d++) {\n        if(halos->v)\n            halos->v[hid][d] += h1->v[i][d];\n        if(halos->dx1)\n            halos->dx1[hid][d] += h1->dx1[i][d];\n        if(halos->dx2)\n            halos->dx2[hid][d] += h1->dx2[i][d];\n    }\n\n    if(halos->x) {\n        for(d = 0; d < 3; d++) {\n            if(boxsize) {\n                halos->x[hid][d] = periodic_add(\n                    halos->x[hid][d] / halos->length[hid], halos->length[hid],\n                    h1->x[i][d] / h1->length[i], h1->length[i], boxsize[d]);\n            } else {\n                halos->x[hid][d] += h1->x[i][d];\n            }\n        }\n    }\n\n    if(halos->q) {\n        for(d = 0; d < 3; d ++) {\n            if (boxsize) {\n                halos->q[hid][d] = periodic_add(\n                    halos->q[hid][d] / halos->length[hid], halos->length[hid],\n                    h1->q[i][d] / h1->length[i], h1->length[i], boxsize[d]);\n            } else {\n                halos->q[hid][d] += h1->q[i][d];\n            }\n        }\n    }\n    /* do this after the loop because x depends on the old length. */\n    halos->length[hid] += h1->length[i];\n}\n\n/* convert a particle to the first halo in the halo store */\nstatic void\n_convert_basic_halo_attrs(FastPMFOFFinder * finder, FastPMStore * p, ptrdiff_t i, FastPMStore * halos)\n{\n    int hid = 0;\n\n    int d;\n\n    double q[3];\n\n    if(halos->q && fastpm_store_has_q(p)) {\n        fastpm_store_get_q_from_id(p, p->id[i], q);\n    }\n    halos->length[hid] = 1;\n\n    for(d = 0; d < 3; d++) {\n        if(halos->x)\n            halos->x[hid][d] = p->x[i][d];\n        if(halos->v)\n            halos->v[hid][d] = p->v[i][d];\n        if(halos->dx1)\n            halos->dx1[hid][d] = p->dx1[i][d];\n        if(halos->dx2)\n            halos->dx2[hid][d] = p->dx2[i][d];\n        if(halos->q && fastpm_store_has_q(p)) {\n            halos->q[hid][d] = q[d];\n        }\n    }\n\n    if(halos->aemit)\n        halos->aemit[hid] = p->aemit[i];\n}\nstatic void\n_reduce_basic_halo_attrs(FastPMFOFFinder * finder, FastPMStore * halos, ptrdiff_t i)\n{\n    int d;\n    double n = halos->length[i];\n\n    for(d = 0; d < 3; d++) {\n        if(halos->x)\n            halos->x[i][d] /= n;\n        if(halos->v)\n            halos->v[i][d] /= n;\n        if(halos->dx1)\n            halos->dx1[i][d] /= n;\n        if(halos->dx2)\n            halos->dx2[i][d] /= n;\n        if(halos->q)\n            halos->q[i][d] /= n;\n    }\n    if(halos->aemit)\n        halos->aemit[i] /= n;\n}\n\nstatic void\n_add_extended_halo_attrs(FastPMFOFFinder * finder, FastPMStore * h1, ptrdiff_t i1, FastPMStore * h2, ptrdiff_t i2)\n{\n    int d;\n    if(h1->rvdisp) {\n        for(d = 0; d < 9; d ++) {\n            h1->rvdisp[i1][d] += h2->rvdisp[i2][d];\n        }\n    }\n    if(h1->vdisp) {\n        for(d = 0; d < 6; d ++) {\n            h1->vdisp[i1][d] += h2->vdisp[i2][d];\n        }\n    }\n    if(h1->rdisp) {\n        for(d = 0; d < 6; d ++) {\n            h1->rdisp[i1][d] += h2->rdisp[i2][d];\n        }\n    }\n}\n\nstatic void\n_convert_extended_halo_attrs(FastPMFOFFinder * finder, FastPMStore * p, ptrdiff_t i, FastPMStore * halos)\n{\n    int hid = 0;\n\n    int d;\n    double rrel[3];\n\n    for(d = 0; d < 3; d ++) {\n        rrel[d] = p->x[i][d] - halos->x[hid][d];\n\n        if(finder->priv->boxsize) {\n            double L = finder->priv->boxsize[d];\n            while(rrel[d] > L / 2) rrel[d] -= L;\n            while(rrel[d] < -L / 2) rrel[d] += L;\n        }\n    }\n\n    if(halos->vdisp) {\n        /* FIXME: add hubble expansion term based on aemit and hubble function? needs to modify Finder object */\n\n        double vrel[3];\n        for(d = 0; d < 3; d ++) {\n            vrel[d] = p->v[i][d] - halos->v[hid][d];\n        }\n        for(d = 0; d < 3; d ++) {\n            halos->vdisp[hid][d] = vrel[d] * vrel[d];\n            halos->vdisp[hid][d + 3] = vrel[d] * vrel[(d + 1) % 3];\n        }\n    }\n    if(halos->rvdisp) {\n        /* FIXME: add hubble expansion term based on aemit and hubble function? needs to modify Finder object */\n\n        double vrel[3];\n        for(d = 0; d < 3; d ++) {\n            vrel[d] = p->v[i][d] - halos->v[hid][d];\n        }\n        for(d = 0; d < 3; d ++) {\n            halos->rvdisp[hid][d] = rrel[d] * vrel[d];\n            halos->rvdisp[hid][d + 3] = rrel[d] * vrel[(d + 1) % 3];\n            halos->rvdisp[hid][d + 6] = rrel[d] * vrel[(d + 2) % 3];\n        }\n    }\n    if(halos->rdisp) {\n        for(d = 0; d < 3; d ++) {\n            halos->rdisp[hid][d] = rrel[d] * rrel[d];\n            halos->rdisp[hid][d + 3] = rrel[d] * rrel[(d + 1) % 3];\n        }\n    }\n}\nstatic void\n_reduce_extended_halo_attrs(FastPMFOFFinder * finder, FastPMStore * halos, ptrdiff_t hid)\n{\n    double n = halos->length[hid];\n    int d;\n    if(halos->rvdisp) {\n        for(d = 0; d < 9; d ++) {\n            halos->rvdisp[hid][d] /= n;\n        }\n    }\n    if(halos->vdisp) {\n        for(d = 0; d < 6; d ++) {\n            halos->vdisp[hid][d] /= n;\n        }\n    }\n    if(halos->rdisp) {\n        for(d = 0; d < 3; d ++) {\n            halos->rdisp[hid][d] /= n;\n        }\n    }\n}\n\n/* This function creates the storage object for halo segments that are local on this\n * rank. We store mnay attributes. We only allow a flucutation of 2 around avg_halos.\n * this should be OK, since we will only redistribute by the MinID, which are supposed\n * to be very uniform.\n * */\nstatic void\nfastpm_fof_create_local_halos(FastPMFOFFinder * finder, FastPMStore * halos, size_t nhalos)\n{\n\n    MPI_Comm comm = finder->priv->comm;\n\n    FastPMColumnTags attributes = finder->p->attributes;\n    attributes |= COLUMN_MASK;\n    attributes |= COLUMN_LENGTH | COLUMN_MINID | COLUMN_TASK;\n    attributes |= COLUMN_RDISP | COLUMN_VDISP | COLUMN_RVDISP;\n    attributes |= COLUMN_ACC; /* ACC used as the first particle position offset */\n    attributes &= ~COLUMN_POTENTIAL;\n    attributes &= ~COLUMN_DENSITY;\n    attributes &= ~COLUMN_TIDAL;\n\n    /* store initial position only for periodic case. non-periodic suggests light cone and\n     * we cannot infer q from ID sensibly. (crashes there) */\n    if(finder->priv->boxsize) {\n        attributes |= COLUMN_Q;\n    } else {\n        attributes &= ~COLUMN_Q;\n    }\n\n    double avg_halos;\n    double max_halos;\n    /* + 1 to ensure avg_halos > 0 */\n    MPIU_stats(comm, nhalos + 1, \"->\", &avg_halos, &max_halos);\n\n    fastpm_info(\"Allocating %d halos per rank for final catalog.\\n\", (size_t) max_halos * 2);\n\n    /* give it enough space for rebalancing. */\n    fastpm_store_init(halos, NULL, (size_t) (max_halos * 2),\n            attributes,\n            FASTPM_MEMORY_HEAP);\n\n    halos->np = nhalos;\n    halos->meta = finder->p->meta;\n\n    ptrdiff_t i;\n    for(i = 0; i < halos->np; i++) {\n        halos->id[i] = i;\n\n        halos->mask[i] = 0; /* unselect the halos ; will turn this only if any particle is used */\n        /* everthing should have been set to zero already by fastpm_store_init */\n    }\n}\n\n\nvoid\nfastpm_fof_execute(FastPMFOFFinder * finder, FastPMStore * halos)\n{\n    /* initial decompose -- reduce number of ghosts */\n    FastPMStore * p = finder->p;\n    PM * pm = finder->pm;\n    MPI_Comm comm = finder->priv->comm;\n\n    /* only do wrapping for periodic data */\n    if(finder->priv->boxsize)\n        fastpm_store_wrap(p, finder->priv->boxsize);\n\n    double npmax, npmin, npstd, npmean;\n\n    MPIU_stats(comm, p->np, \"<->s\", &npmin, &npmean, &npmax, &npstd);\n\n    fastpm_info(\"load balance before fof decompose : min = %g max = %g mean = %g std = %g\\n\",\n        npmin, npmax, npmean, npstd\n        );\n\n#if 1\n    /* still route particles to the pm pencils as if they are periodic. */\n    /* should still work (albeit use crazy memory) if we skip this. */\n    if(0 != fastpm_store_decompose(p,\n                (fastpm_store_target_func) FastPMTargetFOF, pm, comm)\n    ) {\n        fastpm_raise(-1, \"out of storage space decomposing for FOF\\n\");\n    }\n#endif\n    MPIU_stats(comm, p->np, \"<->s\", &npmin, &npmean, &npmax, &npstd);\n\n    fastpm_info(\"load balance after fof decompose : min = %g max = %g mean = %g std = %g\\n\",\n        npmin, npmax, npmean, npstd\n        );\n\n    /* create ghosts mesh size is usually > ll so we are OK here. */\n    double below[3], above[3];\n\n    int d;\n    for(d = 0; d < 3; d ++) {\n        /* bigger padding reduces number of iterations */\n        below[d] = -finder->linkinglength * 1;\n        above[d] = finder->linkinglength * 1;\n    }\n\n    PMGhostData * pgd = pm_ghosts_create_full(pm, p,\n            COLUMN_POS | COLUMN_ID | COLUMN_MINID,\n            below, above\n        );\n\n    pm_ghosts_send(pgd, COLUMN_POS);\n    pm_ghosts_send(pgd, COLUMN_ID);\n\n    size_t np_and_ghosts = p->np + pgd->p->np;\n\n    #ifdef FASTPM_FOF_DEBUG\n    fastpm_ilog(INFO, \"Rank %d has %td particles including ghost\\n\", finder->priv->ThisTask, np_and_ghosts);\n    #endif\n\n    ptrdiff_t * head = fastpm_memory_alloc(p->mem, \"FOFHead\",\n                    sizeof(head[0]) * np_and_ghosts, FASTPM_MEMORY_STACK);\n\n    FastPMStore savebuff[1];\n    fastpm_store_init(savebuff, p->name, np_and_ghosts, COLUMN_MINID, FASTPM_MEMORY_STACK);\n\n    _fof_local_find(finder, p, pgd, head, finder->linkinglength);\n\n    _fof_global_merge (finder, p, pgd, savebuff->minid, head);\n\n    /* assign halo attr entries. This will keep only candidates that can possibly reach to nmin */\n    size_t nsegments = _assign_halo_attr(finder, pgd, head, p->np, pgd->p->np, finder->nmin);\n\n    fastpm_info(\"Found %td halos segments >= %d particles; or cross linked. \\n\", nsegments, finder->nmin);\n    pm_ghosts_free(pgd);\n\n    /* create local halos and modify head to index the local halos */\n    fastpm_fof_create_local_halos(finder, halos, nsegments);\n    /* remove halos without any local particles */\n    fastpm_fof_remove_empty_halos(finder, halos, savebuff->minid, head);\n\n    fastpm_store_destroy(savebuff);\n\n    /* reduce the primary halo attrs */\n    fastpm_fof_compute_halo_attrs(finder, halos, head, _convert_basic_halo_attrs, _add_basic_halo_attrs, _reduce_basic_halo_attrs);\n\n    #ifdef FASTPM_FOF_DEBUG\n    {\n        int i;\n        for(i  = 0; i < halos->np; i ++) {\n            fastpm_ilog(INFO, \"Task = %d, Halo[%d] = %d mask=%d MINID=%ld\\n\", finder->priv->ThisTask, i, halos->length[i], halos->mask[i], halos->minid[i]);\n        }\n    }\n    #endif\n\n    /* apply length cut */\n    fastpm_fof_apply_length_cut(finder, halos, head);\n\n    /* reduce the primary halo attrs */\n    fastpm_fof_compute_halo_attrs(finder, halos, head, _convert_extended_halo_attrs, _add_extended_halo_attrs, _reduce_extended_halo_attrs);\n\n    /* the event is called with full halos, only those where mask==1 are primary\n     * the others are ghosts with the correct properties but shall not show up in the\n     * catalog.\n     * */\n    FastPMHaloEvent event[1];\n    event->halos = halos;\n    event->p = finder->p;\n    event->ihalo = head;\n\n    fastpm_emit_event(finder->event_handlers, FASTPM_EVENT_HALO,\n                    FASTPM_EVENT_STAGE_AFTER, (FastPMEvent*) event, finder);\n\n    fastpm_memory_free(finder->p->mem, head);\n\n    fastpm_store_subsample(halos, halos->mask, halos);\n\n    fastpm_info(\"After event: %td halos.\\n\", fastpm_store_get_np_total(halos, comm));\n}\n\nvoid\nfastpm_fof_destroy(FastPMFOFFinder * finder)\n{\n    fastpm_destroy_event_handlers(&finder->event_handlers);\n    free(finder->priv);\n}\n\n\n", "meta": {"hexsha": "ef5feb8e6ed9b5ebe1f746bfd31c2fba779b815d", "size": 33555, "ext": "c", "lang": "C", "max_stars_repo_path": "fastpm/libfastpm/fof.c", "max_stars_repo_name": "sbird/FastPMRunner", "max_stars_repo_head_hexsha": "f38f6e69c603fb699436b645fe7b4eb418ee82c2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "fastpm/libfastpm/fof.c", "max_issues_repo_name": "sbird/FastPMRunner", "max_issues_repo_head_hexsha": "f38f6e69c603fb699436b645fe7b4eb418ee82c2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4.0, "max_issues_repo_issues_event_min_datetime": "2021-04-19T23:01:33.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-24T05:51:04.000Z", "max_forks_repo_path": "fastpm/libfastpm/fof.c", "max_forks_repo_name": "sbird/FastPMRunner", "max_forks_repo_head_hexsha": "f38f6e69c603fb699436b645fe7b4eb418ee82c2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-04-14T23:24:19.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-14T23:24:19.000Z", "avg_line_length": 30.2297297297, "max_line_length": 156, "alphanum_fraction": 0.5818208911, "num_tokens": 10178, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47268347662043286, "lm_q2_score": 0.022286184565158445, "lm_q1q2_score": 0.010534311200863724}}
{"text": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <sys/stat.h>\n#include \"parmt_postProcess.h\"\n#ifdef PARMT_USE_INTEL\n#include <mkl_cblas.h>\n#else\n#include <cblas.h>\n#endif\n#include \"compearth.h\"\n#include \"iscl/array/array.h\"\n#include \"iscl/memory/memory.h\"\n#include \"iscl/os/os.h\"\n\n\nstatic void getBaseAndExp(const double val, double *base, int *exp);\nstatic void setFillColor(const int i, const int iopt, char color[32]);\n\n/*!\n * @brief Writes the global station distribution of stations, the\n *        station names, the epicenter or moment tensor, and, if\n *        desired, some indication of station polarity.\n */\nint postmt_gmtHelper_writeGlobalMap(\n    struct globalMapOpts_struct globalMap,\n    const int nobs, const struct sacData_struct *data)\n{\n    const char *fcnm = \"postmt_gmtHelper_writeGlobalMap\\0\";\n    FILE *ofl;\n    char *dirName, line[256], cpick[8];\n    int *pol, i, ierr, l, nw, nwd, nwu;\n    size_t lenos;\n    const char *forwardSlash = \"/\";\n    const int nTimeVars = 11;\n    const enum sacHeader_enum timeVarNames[11]\n       = {SAC_CHAR_KA,\n          SAC_CHAR_KT0, SAC_CHAR_KT1, SAC_CHAR_KT2, SAC_CHAR_KT3,\n          SAC_CHAR_KT4, SAC_CHAR_KT5, SAC_CHAR_KT6, SAC_CHAR_KT7,\n          SAC_CHAR_KT8, SAC_CHAR_KT9};\n\n    dirName = os_dirname(globalMap.outputScript, &ierr);\n    if (!os_path_isdir(dirName))\n    {\n        ierr = os_makedirs(dirName); \n        if (ierr != 0)\n        {\n            printf(\"%s: Failed to make output directory: %s\\n\", fcnm, dirName);\n            return -1;\n        }\n    }\n    memory_free8c(&dirName);\n\n    ofl = fopen(globalMap.outputScript, \"w\"); \n    fprintf(ofl, \"#!/bin/bash\\n\");\n    fprintf(ofl, \"outps=%s\\n\", globalMap.psFile);\n    fprintf(ofl, \"olat=%f\\n\", globalMap.evla);\n    fprintf(ofl, \"olon=%f\\n\", globalMap.evlo);\n    fprintf(ofl, \"J=-JH${olon}%s6i\\n\", forwardSlash);\n    fprintf(ofl, \"R=-Rg\\n\");\n    fprintf(ofl, \"gmt pscoast $J $R -B0g30 -Di -Ggray -P -K > ${outps}\\n\");\n    fprintf(ofl, \"ts=0.15i\\n\");\n  \n    fprintf(ofl, \"# Draw great circle arcs between source and receivers\\n\");\n    fprintf(ofl, \"gmt psxy $J $R -W1p -O -K << EOF >> ${outps}\\n\");\n    for (i=0; i<nobs; i++)\n    {   \n        fprintf(ofl, \"%8.3f %8.3f\\n\", data[i].header.stlo, data[i].header.stla);\n        fprintf(ofl, \"%8.3f %8.3f\\n\", globalMap.evlo, globalMap.evla);\n        if (i < nobs - 1){fprintf(ofl, \"\\n\");}\n    }   \n    fprintf(ofl, \"EOF\\n\");\n\n    fprintf(ofl, \"# Plot the moment tensor\\n\");\n    postmt_gmtHelper_makePsmecaLine(globalMap.basis, globalMap.mts,\n                                    globalMap.evla, globalMap.evlo,\n                                    globalMap.evdp, \"Optimum\\0\", line);\n    if (globalMap.lwantMT)\n    {\n        fprintf(ofl, \"gmt psmeca $J $R -Sm0.15i -M -N -Gblue -W0.5p,black -O -K << EOF >> ${outps}\\n\");\n        fprintf(ofl, \"%s\", line);\n        fprintf(ofl, \"EOF\\n\");\n    }\n    else\n    {\n        fprintf(ofl, \"# Plot the epicenter\\n\");\n        fprintf(ofl, \"gmt psxy $J $R -Sa${ts} -Gblue -Wblack -O -K << EOF >> ${outps}\\n\");\n        fprintf(ofl, \"%8.3f %8.3f\\n\", globalMap.evlo, globalMap.evla);\n        fprintf(ofl, \"EOF\\n\");\n    }\n\n    if (!globalMap.lwantPolarity)\n    {\n        fprintf(ofl, \"# Plot the stations\\n\");\n        fprintf(ofl, \"gmt psxy $J $R -St${ts} -Gred -Wblack -O -K << EOF >> ${outps}\\n\");\n        for (i=0; i<nobs; i++)\n        {\n            fprintf(ofl, \"%8.3f %8.3f %s\\n\", data[i].header.stlo,\n                    data[i].header.stla, data[i].header.kstnm);\n        }\n        fprintf(ofl, \"EOF\\n\");\n    }\n    else\n    {\n        // Get the polarities\n        nw = 0;\n        nwd = 0;\n        nwu = 0;\n        pol = (int *) calloc((size_t) nobs, sizeof(int));\n        for (i=0; i<nobs; i++)\n        {\n            memset(cpick, 0, 8*sizeof(char));\n            for (l=0; l<nTimeVars; l++)\n            {\n                ierr = sacio_getCharacterHeader(timeVarNames[l],\n                                                data[i].header, cpick);\n                if (ierr == 0){break;}\n            }\n            lenos = strlen(cpick);\n            if (lenos > 0)\n            {\n                if (cpick[lenos-1] == '+')\n                {\n                    nwu = nwu + 1;\n                    pol[i] = 1;\n                }\n                else if (cpick[lenos-1] == '-')\n                {\n                    nwd = nwd + 1;\n                    pol[i] =-1;\n                }\n                else\n                {\n                    nw = nw + 1;\n                }\n            }\n            else\n            {\n                nw = nw + 1;\n            }\n        }\n        // Write the unknowns\n        if (nw > 0)\n        {\n            fprintf(ofl, \"# Plot the indeterminant stations\\n\");\n            fprintf(ofl, \"gmt psxy $J $R -Ss${ts} -Gred -Wblack -O -K << EOF >> ${outps}\\n\");\n            for (i=0; i<nobs; i++)\n            {\n                if (pol[i] == 0)\n                {\n                    fprintf(ofl, \"%8.3f %8.3f %s\\n\", data[i].header.stlo,\n                            data[i].header.stla, data[i].header.kstnm);\n                }\n            }   \n            fprintf(ofl, \"EOF\\n\");\n        }\n        // Write the ups\n        if (nwu > 0)\n        {\n            fprintf(ofl, \"# Plot the upward stations\\n\");\n            fprintf(ofl, \"gmt psxy $J $R -St${ts} -Gred -Wblack -O -K << EOF >> ${outps}\\n\");\n            for (i=0; i<nobs; i++)\n            {\n                if (pol[i] == 1)\n                {\n                    fprintf(ofl, \"%8.3f %8.3f %s\\n\", data[i].header.stlo,\n                            data[i].header.stla, data[i].header.kstnm);\n                }\n            }\n            fprintf(ofl, \"EOF\\n\");\n        }\n        // Write the downs\n        if (nwd > 0)\n        {\n            fprintf(ofl, \"# Plot the down stations\\n\");\n            fprintf(ofl, \"gmt psxy $J $R -Si${ts} -Gred -Wblack -O -K << EOF >> ${outps}\\n\");\n            for (i=0; i<nobs; i++)\n            {\n                if (pol[i] ==-1)\n                {\n                    fprintf(ofl, \"%8.3f %8.3f %s\\n\", data[i].header.stlo,\n                            data[i].header.stla, data[i].header.kstnm);\n                }\n            }\n            fprintf(ofl, \"EOF\\n\");\n        }\n        free(pol);\n    }\n\n    fprintf(ofl, \"# Plot the station names\\n\");\n    fprintf(ofl, \"gmt pstext $J $R -F+f8p+a0+jCT -D0%s-4p -O << EOF >> ${outps}\\n\",\n            forwardSlash);\n    for (i=0; i<nobs; i++)\n    {\n        fprintf(ofl, \"%8.3f %8.3f %s\\n\", data[i].header.stlo,\n                data[i].header.stla, data[i].header.kstnm);\n    }\n    fprintf(ofl, \"EOF\\n\");\n    fprintf(ofl, \"gmt psconvert -A -Tj ${outps}\\n\");\n    fprintf(ofl, \"rm ${outps}\\n\");\n    fclose(ofl);\n    chmod(globalMap.outputScript, 0755);\n    return 0;\n}\n//============================================================================//\nint postmt_gmtHelper_writeThetaBoxes(const bool lappend, const bool lclose,\n                                     const char *outputScript,\n                                     const char *psFile,\n                                     const int nt,\n                                     const int ithetaOpt,\n                                     const double *__restrict__ thetas,\n                                     const double *__restrict__ thetaHist)\n{\n    FILE *ofl;\n    char color[32], app[8], more[8], shift[8];\n    double *cumTheta, *h, hAvg, thetaAvg, tmax;\n    int i, ierr;\n    const bool lwritePrior = true;\n    tmax = array_max64f(nt, thetaHist, &ierr);\n    // Compute h\n    h = memory_calloc64f(nt);\n    compearth_theta2h(nt, thetas, h);\n    thetaAvg = -30.0;\n    memset(app, 0, 8*sizeof(char));\n    memset(more, 0, 8*sizeof(char));\n    memset(shift, 0, 8*sizeof(char));\n    if (!lappend)\n    {\n        ofl = fopen(outputScript, \"w\");\n        fprintf(ofl, \"#!/bin/bash\\n\");\n        /*\n        fprintf(ofl, \"gmt gmtset FONT_LABEL 12p\\n\");\n        fprintf(ofl, \"gmt gmtset MAP_LABEL_OFFSET 0.1c\\n\");\n        */\n        fprintf(ofl, \"parms=\\\"--FONT_LABEL=10p --MAP_LABEL_OFFSET=0.1c --PROJ_LENGTH_UNIT=cm\\\"\\n\");\n        fprintf(ofl, \"psfl=%s\\n\", psFile);\n    }\n    else\n    {\n        ofl = fopen(outputScript, \"a\");\n        strcpy(app, \"-O\\0\");\n        strcpy(more, \">\\0\");\n        strcpy(shift, \"-Y4.0\\0\");\n    }\n    fprintf(ofl,\n/*\n            \"gmt psbasemap -JX5i/1i %s -R0/90/0/%.2f -Bg10a10:\\\"Dips (deg)\\\":/a%.2f:\\\"Likelihood\\\":WSn -P %s -K >%s ${psfl}\\n\",\n*/\n            \"gmt psbasemap -JX5i/1i %s -R0/90/0/%.2f -Bpxg10a10+l:\\\"Dips (deg)\\\" -Bpya%.2f+l:\\\"Likelihood\\\" -BWSnn -P %s -K ${parms} >%s ${psfl}\\n\",\n            shift, tmax*1.1, tmax*0.2, app, more);\n    setFillColor(0, ithetaOpt, color);\n    if (nt > 1)\n    {\n       fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O -K << EOF >> ${psfl}\\n\", color);\n    }\n    else\n    {\n       fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O << EOF >> ${psfl}\\n\", color);\n    }\n    fprintf(ofl, \"%f %f\\n\", 0.0, 0.0);\n    fprintf(ofl, \"%f %f\\n\", 0.0, thetaHist[0]);\n    for (i=0; i<nt-1; i++)\n    {\n        hAvg = 0.5*(h[i] + h[i+1]);\n        compearth_h2theta(1, &hAvg, &thetaAvg);\n        fprintf(ofl, \"%f %f\\n\", thetaAvg*180.0/M_PI, thetaHist[i]);\n        fprintf(ofl, \"%f %f\\n\", thetaAvg*180.0/M_PI, 0.0);\n        fprintf(ofl, \"EOF\\n\");\n        setFillColor(i+1, ithetaOpt, color);\n        if (i < nt - 2 || lwritePrior)\n        {\n            fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O -K << EOF >> ${psfl}\\n\", color);\n        }\n        else\n        {\n            fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O << EOF >> ${psfl}\\n\", color);\n        }\n        fprintf(ofl, \"%f %f\\n\", thetaAvg*180.0/M_PI, 0.0);\n        fprintf(ofl, \"%f %f\\n\", thetaAvg*180.0/M_PI, thetaHist[i+1]);\n    }\n    fprintf(ofl, \"%f %f\\n\", 90.0, thetaHist[nt-1]);\n    fprintf(ofl, \"%f %f\\n\", 90.0, 0.0);\n    fprintf(ofl, \"EOF\\n\");\n    // Write the prior distribution\n    if (lwritePrior)\n    {   \n        fprintf(ofl, \"gmt psxy -R -J -W1,black -O -K << EOF >> ${psfl}\\n\");\n        fprintf(ofl, \"%f %f\\n\", 00.0, 1.0/(double) nt);\n        fprintf(ofl, \"%f %f\\n\", 90.0, 1.0/(double) nt);\n        fprintf(ofl, \"EOF\\n\");\n    }\n    // Write the CDF\n/*\n    fprintf(ofl, \"gmt psbasemap -R0/90/0/1.05 -J -Bp0.2/a0.2:\\\"CDF\\\":E -O -K >> ${psfl}\\n\");\n*/\n    fprintf(ofl, \"gmt psbasemap -R0/90/0/1.05 -J -Bpx0.2 -Bpya0.2+l\\\"CDF\\\" -BE -O -K ${parms} >> ${psfl}\\n\");\n    cumTheta = array_cumsum64f(nt, thetaHist, &ierr);\n    if (lclose)\n    {\n        fprintf(ofl, \"gmt psxy -R -J -W1,blue -O << EOF >> ${psfl}\\n\");\n    }\n    else\n    {\n        fprintf(ofl, \"gmt psxy -R -J -W1,blue -O -K << EOF >> ${psfl}\\n\");\n    }\n    for (i=0; i<nt; i++)\n    {   \n        fprintf(ofl, \"%f %f\\n\", thetas[i]*180/M_PI, cumTheta[i]);\n    }   \n    fprintf(ofl, \"EOF\\n\");\n    if (lclose)\n    {\n        //fprintf(ofl, \"gmt psconvert -A -Tj ${psfl}\\n\");\n        //fprintf(ofl, \"rm ${psfl}\\n\");\n        fprintf(ofl, \"gmt psconvert -A -Tf ${psfl}\\n\");\n        fprintf(ofl, \"/bin/rm ${psfl}\\n\"); \n    }\n    memory_free64f(&cumTheta);\n    memory_free64f(&h);\n    fclose(ofl);\n    chmod(outputScript, 0755);\n    return 0;\n}\n//============================================================================//\nint postmt_gmtHelper_writeSigmaBoxes(const bool lappend, const bool lclose,\n                                     const char *outputScript,\n                                     const char *psFile,\n                                     const int ns,\n                                     const int isigmaOpt,\n                                     const double *__restrict__ sigmas,\n                                     const double *__restrict__ sigmaHist)\n{\n    FILE *ofl;\n    char color[32], app[8], more[8], shift[8];\n    double *cumSigma, ds, smax;\n    int i, ierr;\n    const bool lwritePrior = true;\n    smax = array_max64f(ns, sigmaHist, &ierr);\n    // Take averages\n    ds = 0.0;\n    memset(app, 0, 8*sizeof(char));\n    memset(more, 0, 8*sizeof(char));\n    memset(shift, 0, 8*sizeof(char));\n    if (!lappend)\n    {\n        ofl = fopen(outputScript, \"w\");\n        fprintf(ofl, \"#!/bin/bash\\n\");\n        /*\n        fprintf(ofl, \"gmt gmtset FONT_LABEL 12p\\n\");\n        fprintf(ofl, \"gmt gmtset MAP_LABEL_OFFSET 0.1c\\n\");\n        */\n        fprintf(ofl, \"parms=\\\"--FONT_LABEL=10p --MAP_LABEL_OFFSET=0.1c --PROJ_LENGTH_UNIT=cm\\\"\\n\");\n        fprintf(ofl, \"psfl=%s\\n\", psFile);\n    }\n    else\n    {\n        ofl = fopen(outputScript, \"a\");\n        strcpy(app, \"-O\\0\");\n        strcpy(more, \">\\0\");\n        strcpy(shift, \"-Y4.0\\0\");\n    }\n    fprintf(ofl,\n/*\n           \"gmt psbasemap -JX5i/1i %s -R-90/90/0/%.2f -Bg15a15:\\\"Slips (deg)\\\":/a%.2f:\\\"Likelihood\\\":WSn -P %s -K >%s ${psfl}\\n\",\n*/\n            \"gmt psbasemap -JX5i/1i %s -R-90/90/0/%.2f -Bpxg15a15+l\\\"Slips (deg)\\\" -Bpya%.2f+l\\\"Likelihood\\\" -BWSn -P %s -K ${parms} >%s ${psfl}\\n\",\n            shift, smax*1.1, smax*0.2, app, more);\n    setFillColor(0, isigmaOpt, color);\n    if (ns > 1)\n    {\n       fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O -K << EOF >> ${psfl}\\n\", color);\n       ds = (sigmas[1] - sigmas[0])*180.0/M_PI;\n    }\n    else\n    {\n       fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O << EOF >> ${psfl}\\n\", color);\n    }\n    fprintf(ofl, \"%.2f %f\\n\", -90.0, 0.0);\n    fprintf(ofl, \"%.2f %f\\n\", -90.0, sigmaHist[0]);\n    for (i=0; i<ns-1; i++)\n    {   \n        fprintf(ofl, \"%.2f %f\\n\", -90.0 + (double) (i+1)*ds, sigmaHist[i]);\n        fprintf(ofl, \"%.2f %f\\n\", -90.0 + (double) (i+1)*ds, 0.0);\n        fprintf(ofl, \"EOF\\n\");\n        setFillColor(i+1, isigmaOpt, color);\n        if (i < ns - 2 || lwritePrior)\n        {\n            fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O -K << EOF >> ${psfl}\\n\", color);\n        }\n        else\n        {\n            fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O << EOF >> ${psfl}\\n\", color);\n        }\n        fprintf(ofl, \"%.2f %f\\n\", -90.0 + (double) (i+1)*ds, 0.0);\n        fprintf(ofl, \"%.2f %f\\n\", -90.0 + (double) (i+1)*ds, sigmaHist[i+1]);\n    }\n    fprintf(ofl, \"%.2f %f\\n\", 90.0, sigmaHist[ns-1]);\n    fprintf(ofl, \"%.2f %f\\n\", 90.0, 0.0);\n    fprintf(ofl, \"EOF\\n\");\n    // Write the prior distribution\n    if (lwritePrior)\n    {   \n        fprintf(ofl, \"gmt psxy -R -J -W1,black -O -K << EOF >> ${psfl}\\n\");\n        fprintf(ofl, \"%f %f\\n\",-90.0, 1.0/(double) ns);\n        fprintf(ofl, \"%f %f\\n\", 90.0, 1.0/(double) ns);\n        fprintf(ofl, \"EOF\\n\");\n    }\n    // Write the CDF\n/*\n    fprintf(ofl, \"gmt psbasemap -R-90/90/0/1.05 -J -Bp0.2/a0.2:\\\"CDF\\\":E -O -K >> ${psfl}\\n\");\n*/\n    fprintf(ofl, \"gmt psbasemap -R-90/90/0/1.05 -J -Bpx0.2 -Bpya0.2+l\\\"CDF\\\" -BE -O -K ${parms} >> ${psfl}\\n\");\n    cumSigma = array_cumsum64f(ns, sigmaHist, &ierr);\n    if (lclose)\n    {\n        fprintf(ofl, \"gmt psxy -R -J -W1,blue -O << EOF >> ${psfl}\\n\");\n    }\n    else\n    {\n        fprintf(ofl, \"gmt psxy -R -J -W1,blue -O -K << EOF >> ${psfl}\\n\");\n    }\n    for (i=0; i<ns; i++)\n    {\n        fprintf(ofl, \"%f %f\\n\", sigmas[i]*180/M_PI, cumSigma[i]);\n    }   \n    fprintf(ofl, \"EOF\\n\");\n    if (lclose)\n    {    \n        //fprintf(ofl, \"gmt psconvert -A -Tj ${psfl}\\n\");\n        //fprintf(ofl, \"rm ${psfl}\\n\");\n        fprintf(ofl, \"gmt psconvert -A -Tf ${psfl}\\n\");\n        fprintf(ofl, \"/bin/rm ${psfl}\\n\");\n    }\n    memory_free64f(&cumSigma);\n    fclose(ofl);\n    chmod(outputScript, 0755);\n    return 0;\n}\n\n//============================================================================//\nint postmt_gmtHelper_writeKappaBoxes(const bool lappend, const bool lclose,\n                                     const char *outputScript,\n                                     const char *psFile,\n                                     const int nk,\n                                     const int kappaOpt,\n                                     const double *__restrict__ kappas,\n                                     const double *__restrict__ kappaHist)\n{\n    FILE *ofl;\n    char color[32], app[8], more[8], shift[8];\n    double *cumKappa, dk, kmax;\n    int i, ierr;\n    const bool lwritePrior = true;\n    kmax = array_max64f(nk, kappaHist, &ierr);\n    // Take averages\n    dk = 0.0;\n    memset(app, 0, 8*sizeof(char));\n    memset(more, 0, 8*sizeof(char));\n    memset(shift, 0, 8*sizeof(char));\n    if (!lappend)\n    {\n        ofl = fopen(outputScript, \"w\");\n        fprintf(ofl, \"#!/bin/bash\\n\");\n        /*\n        fprintf(ofl, \"gmt gmtset FONT_LABEL 12p\\n\");\n        fprintf(ofl, \"gmt gmtset MAP_LABEL_OFFSET 0.1c\\n\");\n        */\n        fprintf(ofl, \"parms=\\\"--FONT_LABEL=10p --MAP_LABEL_OFFSET=0.1c --PROJ_LENGTH_UNIT=cm\\\"\\n\");\n        fprintf(ofl, \"psfl=%s\\n\", psFile);\n    }\n    else\n    {\n        ofl = fopen(outputScript, \"a\");\n        strcpy(app, \"-O\\0\");\n        strcpy(more, \">\\0\");\n        strcpy(shift, \"-Y4.0\\0\");\n    }\n    fprintf(ofl,\n/*\n            \"gmt psbasemap -JX5i/1i %s -R0/360/0/%.2f -Bg30a30:\\\"Strike (deg)\\\":/a%.2f:\\\"Likelihood\\\":WSn -P %s -K >%s ${psfl}\\n\",\n*/\n            \"gmt psbasemap -JX5i/1i %s -R0/360/0/%.2f -Bpxg30a30+l\\\"Strike (deg)\\\" -Bpya%.2f+l\\\"Likelihood\\\" -BWSn -P %s -K ${parms} >%s ${psfl}\\n\",\n            shift, kmax*1.1, kmax*0.2, app, more);\n    setFillColor(0, kappaOpt, color);\n    if (nk > 1)\n    {\n       fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O -K << EOF >> ${psfl}\\n\", color);\n       dk = (kappas[1] - kappas[0])*180.0/M_PI;\n    }\n    else\n    {\n       fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O << EOF >> ${psfl}\\n\", color);\n    }\n    fprintf(ofl, \"%.2f %f\\n\", 0.0, 0.0);\n    fprintf(ofl, \"%.2f %f\\n\", 0.0, kappaHist[0]);\n    for (i=0; i<nk-1; i++)\n    {\n        fprintf(ofl, \"%.2f %f\\n\", 0.0 + (double) (i+1)*dk, kappaHist[i]);\n        fprintf(ofl, \"%.2f %f\\n\", 0.0 + (double) (i+1)*dk, 0.0);\n        fprintf(ofl, \"EOF\\n\");\n        setFillColor(i+1, kappaOpt, color);\n        if (i < nk - 2 || lwritePrior)\n        {\n            fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O -K << EOF >> ${psfl}\\n\", color);\n        }\n        else\n        {\n            fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O << EOF >> ${psfl}\\n\", color);\n        }\n        fprintf(ofl, \"%.2f %f\\n\", 0.0 + (double) (i+1)*dk, 0.0);\n        fprintf(ofl, \"%.2f %f\\n\", 0.0 + (double) (i+1)*dk, kappaHist[i+1]);\n    }   \n    fprintf(ofl, \"%.2f %f\\n\", 360.0, kappaHist[nk-1]);\n    fprintf(ofl, \"%.2f %f\\n\", 360.0, 0.0);\n    fprintf(ofl, \"EOF\\n\");\n    // Write the prior distribution\n    if (lwritePrior)\n    {   \n        fprintf(ofl, \"gmt psxy -R -J -W1,black -O -K << EOF >> ${psfl}\\n\");\n        fprintf(ofl, \"%f %f\\n\", 0.0,   1.0/(double) nk);\n        fprintf(ofl, \"%f %f\\n\", 360.0, 1.0/(double) nk);\n        fprintf(ofl, \"EOF\\n\");\n    }\n    // Write the CDF\n/*\n    fprintf(ofl, \"gmt psbasemap -R0/360/0/1.05 -J -Bp0.2/a0.2:\\\"CDF\\\":E -O -K >> ${psfl}\\n\");\n*/\n    fprintf(ofl, \"gmt psbasemap -R0/360/0/1.05 -J -Bpx0.2 -Bpya0.2+l\\\"CDF\\\" -BE -O -K ${parms} >> ${psfl}\\n\");\n    cumKappa = array_cumsum64f(nk, kappaHist, &ierr);\n    if (lclose)\n    {\n        fprintf(ofl, \"gmt psxy -R -J -W1,blue -O << EOF >> ${psfl}\\n\");\n    }\n    else\n    {\n        fprintf(ofl, \"gmt psxy -R -J -W1,blue -O -K << EOF >> ${psfl}\\n\");\n    }\n    for (i=0; i<nk; i++)\n    {   \n        fprintf(ofl, \"%f %f\\n\", kappas[i]*180.0/M_PI, cumKappa[i]);\n    }   \n    fprintf(ofl, \"EOF\\n\");\n    if (lclose)\n    {\n        //fprintf(ofl, \"gmt psconvert -A -Tj ${psfl}\\n\");\n        //fprintf(ofl, \"rm ${psfl}\\n\");\n        fprintf(ofl, \"gmt psconvert -A -Tf ${psfl}\\n\");\n        fprintf(ofl, \"/bin/rm ${psfl}\\n\");\n    }\n    memory_free64f(&cumKappa);\n    fclose(ofl);\n    chmod(outputScript, 0755);\n    return 0;\n}\n//============================================================================//\nint postmt_gmtHelper_writeDepthBoxes(const bool lappend, const bool lclose,\n                                     const char *outputScript,\n                                     const char *psFile,\n                                     const int nd,\n                                     const int idepOpt,\n                                     const double *__restrict__ deps,\n                                     const double *__restrict__ depHist)\n{\n    FILE *ofl;\n    char color[32], app[8], more[8], shift[8];\n    double *cumDep, dd, dmax, depMin, depMax;\n    int i, ierr;\n    const bool lwritePrior = true;\n    // Compute moment magnitudes \n    dmax = array_max64f(nd, depHist, &ierr);\n    dd = 0.1;\n    if (nd > 1){dd = deps[1] - deps[0];};\n    depMin = fmax(0.0, deps[0]    - dd/2.0);\n    depMax = fmax(0.0, deps[nd-1] + dd/2.0);\n    memset(app, 0, 8*sizeof(char));\n    memset(more, 0, 8*sizeof(char));\n    memset(shift, 0, 8*sizeof(char));\n    if (!lappend)\n    {\n        ofl = fopen(outputScript, \"w\");\n        fprintf(ofl, \"#!/bin/bash\\n\");\n        /*\n        fprintf(ofl, \"gmt gmtset FONT_LABEL 12p\\n\");\n        fprintf(ofl, \"gmt gmtset MAP_LABEL_OFFSET 0.1c\\n\");\n        */\n        fprintf(ofl, \"psfl=%s\\n\", psFile);\n    }\n    else\n    {\n        ofl = fopen(outputScript, \"a\");\n        strcpy(app, \"-O\\0\");\n        strcpy(more, \">\\0\");\n        strcpy(shift, \"-Y4.0\\0\");\n    }\n    fprintf(ofl,\n/*\n            \"gmt psbasemap -JX5i/1i %s -R%.1f/%.1f/0/%.2f -Bg%fa%f:\\\"Depths (km)\\\":/a%.2f:\\\"Likelihood\\\":WSn -P %s -K >%s ${psfl}\\n\",\n*/\n            \"gmt psbasemap -JX5i/1i %s -R%.1f/%.1f/0/%.2f -Bpxg%fa%f+l\\\"Depths (km)\\\" -Bpya%.2f+l\\\"Likelihood\\\" -BWSn -P %s -K ${parms} >%s ${psfl}\\n\",\n            shift, depMin, depMax, dmax*1.1, dd, (nd-1)*dd/5.0, dmax*0.2, app, more);\n    setFillColor(0, idepOpt, color);\n    if (nd > 1)\n    {\n       fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O -K << EOF >> ${psfl}\\n\", color);\n    }\n    else\n    {\n       fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O << EOF >> ${psfl}\\n\", color);\n    }\n    fprintf(ofl, \"%.2f %f\\n\", depMin, 0.0);\n    fprintf(ofl, \"%.2f %f\\n\", depMin, depHist[0]);\n    for (i=0; i<nd-1; i++)\n    {\n        fprintf(ofl, \"%.2f %f\\n\", depMin + (double) (i+1)*dd, depHist[i]);\n        fprintf(ofl, \"%.2f %f\\n\", depMin + (double) (i+1)*dd, 0.0);\n        fprintf(ofl, \"EOF\\n\");\n        setFillColor(i+1, idepOpt, color);\n        if (i < nd - 2 || lwritePrior)\n        {   \n            fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O -K << EOF >> ${psfl}\\n\", color);\n        }\n        else\n        {   \n            fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O << EOF >> ${psfl}\\n\", color);\n        }\n        fprintf(ofl, \"%.2f %f\\n\", depMin + (double) (i+1)*dd, 0.0);\n        fprintf(ofl, \"%.2f %f\\n\", depMin + (double) (i+1)*dd, depHist[i+1]);\n    }\n    fprintf(ofl, \"%.2f %f\\n\", depMax, depHist[nd-1]);\n    fprintf(ofl, \"%.2f %f\\n\", depMax, 0.0);\n    fprintf(ofl, \"EOF\\n\"); \n    // Write the prior distribution\n    if (lwritePrior) \n    {   \n        fprintf(ofl, \"gmt psxy -R -J -W1,black -O -K << EOF >> ${psfl}\\n\");\n        fprintf(ofl, \"%f %f\\n\", depMin, 1.0/(double) nd);\n        fprintf(ofl, \"%f %f\\n\", depMax, 1.0/(double) nd);\n        fprintf(ofl, \"EOF\\n\");\n    }\n    // Write the CDF\n/*\n    fprintf(ofl, \"gmt psbasemap -R%f/%f/0/1.05 -J -Bp0.2/a0.2:\\\"CDF\\\":E -O -K >> ${psfl}\\n\", depMin, depMax);\n*/\n    fprintf(ofl, \"gmt psbasemap -R%f/%f/0/1.05 -J -Bpx0.2 -Bpya0.2+l\\\"CDF\\\" -BE -O -K ${parms} >> ${psfl}\\n\", depMin, depMax);\n    cumDep = array_cumsum64f(nd, depHist, &ierr);\n    if (lclose)\n    {\n        fprintf(ofl, \"gmt psxy -R -J -W1,blue -O << EOF >> ${psfl}\\n\");\n    }\n    else\n    {\n        fprintf(ofl, \"gmt psxy -R -J -W1,blue -O -K << EOF >> ${psfl}\\n\");\n    }\n    for (i=0; i<nd; i++)\n    {\n        fprintf(ofl, \"%f %f\\n\", deps[i], cumDep[i]);\n    }\n    fprintf(ofl, \"EOF\\n\");\n    if (lclose)\n    {    \n        //fprintf(ofl, \"gmt psconvert -A -Tj ${psfl}\\n\");\n        //fprintf(ofl, \"rm ${psfl}\\n\");\n        fprintf(ofl, \"gmt psconvert -A -Tf ${psfl}\\n\");\n        fprintf(ofl, \"/bin/rm ${psfl}\\n\");\n    }\n    memory_free64f(&cumDep);\n    fclose(ofl);\n    chmod(outputScript, 0755);\n    return 0;\n}\n//============================================================================//\nint postmt_gmtHelper_writeMagnitudeBoxes(const bool lappend, const bool lclose,\n                                         const char *outputScript,\n                                         const char *psFile,\n                                         const int nm,\n                                         const int magOpt,\n                                         const double *__restrict__ M0s,\n                                         const double *__restrict__ magHist)\n{\n    FILE *ofl;\n    char color[32], app[8], more[8], shift[8];\n    double *cumMag, *Mw, dm, mmax, mwMin, mwMax;\n    int i, ierr;\n    const bool lwritePrior = true;\n    // Compute moment magnitudes \n    Mw = memory_calloc64f(nm);\n    mmax = array_max64f(nm, magHist, &ierr);\n    compearth_m02mw(nm, CE_KANAMORI_1978, M0s, Mw);\n    dm = 0.1;\n    if (nm > 1){dm = Mw[1] - Mw[0];};\n    mwMin = Mw[0] - dm/2.0;\n    mwMax = Mw[nm-1] + dm/2.0;\n    memset(app, 0, 8*sizeof(char));\n    memset(more, 0, 8*sizeof(char));\n    memset(shift, 0, 8*sizeof(char));\n    if (!lappend)\n    {\n        ofl = fopen(outputScript, \"w\");\n        fprintf(ofl, \"#!/bin/bash\\n\");\n        /*\n        fprintf(ofl, \"gmt gmtset FONT_LABEL 12p\\n\");\n        fprintf(ofl, \"gmt gmtset MAP_LABEL_OFFSET 0.1c\\n\");\n        */\n        fprintf(ofl, \"parms=\\\"--FONT_LABEL=10p --MAP_LABEL_OFFSET=0.1c --PROJ_LENGTH_UNIT=cm\\\"\\n\");\n        fprintf(ofl, \"psfl=%s\\n\", psFile);\n    }\n    else\n    {\n        ofl = fopen(outputScript, \"a\");\n        strcpy(app, \"-O\\0\");\n        strcpy(more, \">\\0\");\n        strcpy(shift, \"-Y4.0\\0\");\n    }\n    fprintf(ofl,\n/*\n            \"gmt psbasemap -JX5i/1i %s -R%.2f/%.2f/0/%.2f -Bg%fa%f:\\\"Magnitude (Mw)\\\":/a%.2f:\\\"Likelihood\\\":WSn -P %s -K >%s ${psfl}\\n\",\n*/\n            \"gmt psbasemap -JX5i/1i %s -R%.2f/%.2f/0/%.2f -Bpxg%fa%f+l\\\"Magnitude (Mw)\\\" -Bpya%.2f+l\\\"Likelihood\\\" -BWSn -P %s -K ${parms} >%s ${psfl}\\n\",\n            shift, mwMin, mwMax, mmax*1.1, dm, (nm-1)*dm/5.0, mmax*0.2, app, more);\n    setFillColor(0, magOpt, color);\n    if (nm > 1)\n    {\n       fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O -K << EOF >> ${psfl}\\n\", color);\n    }\n    else\n    {\n       fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O << EOF >> ${psfl}\\n\", color);\n    }   \n    fprintf(ofl, \"%.2f %f\\n\", mwMin, 0.0);\n    fprintf(ofl, \"%.2f %f\\n\", mwMin, magHist[0]);\n    for (i=0; i<nm-1; i++)\n    {\n        fprintf(ofl, \"%.2f %f\\n\", mwMin + (double) (i+1)*dm, magHist[i]);\n        fprintf(ofl, \"%.2f %f\\n\", mwMin + (double) (i+1)*dm, 0.0);\n        fprintf(ofl, \"EOF\\n\");\n        setFillColor(i+1, magOpt, color);\n        if (i < nm - 2 || lwritePrior)\n        {   \n            fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O -K << EOF >> ${psfl}\\n\", color);\n        }\n        else\n        {\n            fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O << EOF >> ${psfl}\\n\", color);\n        }\n        fprintf(ofl, \"%.2f %f\\n\", mwMin + (double) (i+1)*dm, 0.0);\n        fprintf(ofl, \"%.2f %f\\n\", mwMin + (double) (i+1)*dm, magHist[i+1]);\n    }\n    fprintf(ofl, \"%.2f %f\\n\", mwMax, magHist[nm-1]);\n    fprintf(ofl, \"%.2f %f\\n\", mwMax, 0.0);\n    fprintf(ofl, \"EOF\\n\");\n    // Write the prior distribution\n    if (lwritePrior)\n    {   \n        fprintf(ofl, \"gmt psxy -R -J -W1,black -O -K << EOF >> ${psfl}\\n\");\n        fprintf(ofl, \"%f %f\\n\", mwMin, 1.0/(double) nm);\n        fprintf(ofl, \"%f %f\\n\", mwMax, 1.0/(double) nm);\n        fprintf(ofl, \"EOF\\n\");\n    }\n    // Write the CDF\n/*\n    fprintf(ofl, \"gmt psbasemap -R%f/%f/0/1.05 -J -Bp0.2/a0.2:\\\"CDF\\\":E -O -K >> ${psfl}\\n\", mwMin, mwMax);\n*/\n    fprintf(ofl, \"gmt psbasemap -R%f/%f/0/1.05 -J -Bpx0.2 -Bpya0.2+l\\\"CDF\\\" -BE -O -K ${parms} >> ${psfl}\\n\", mwMin, mwMax);\n    cumMag = array_cumsum64f(nm, magHist, &ierr);\n    if (lclose)\n    {\n        fprintf(ofl, \"gmt psxy -R -J -W1,blue -O << EOF >> ${psfl}\\n\");\n    }\n    else\n    {\n        fprintf(ofl, \"gmt psxy -R -J -W1,blue -O -K << EOF >> ${psfl}\\n\");\n    }\n    for (i=0; i<nm; i++)\n    {\n        fprintf(ofl, \"%f %f\\n\", Mw[i], cumMag[i]);\n    }\n    fprintf(ofl, \"EOF\\n\");\n    if (lclose)\n    {    \n        //fprintf(ofl, \"gmt psconvert -A -Tj ${psfl}\\n\");\n        //fprintf(ofl, \"rm ${psfl}\\n\");\n    }\n    fclose(ofl);\n    memory_free64f(&cumMag);\n    memory_free64f(&Mw);\n    chmod(outputScript, 0755);\n    return 0;\n}\n//============================================================================//\nint postmt_gmtHelper_writeGammaBoxes(const bool lappend, const bool lclose,\n                                     const char *outputScript,\n                                     const char *psFile,\n                                     const int ng,\n                                     const int igammaOpt,\n                                     const double *__restrict__ gammas,\n                                     const double *__restrict__ gammaHist)\n{\n    FILE *ofl;\n    char color[32], app[8], more[8], shift[8];\n    double *cumGamma, *v, gmax, gammaAvg, vAvg;\n    int i, ierr;\n    const bool lwritePrior = true;\n    gmax = array_max64f(ng, gammaHist, &ierr);\n    // Compute v\n    v = memory_calloc64f(ng);\n    compearth_gamma2v(ng, gammas, v);\n    // Take averages\n    gammaAvg = -30.0;\n    memset(app, 0, 8*sizeof(char));\n    memset(shift, 0, 8*sizeof(char));\n    memset(more, 0, 8*sizeof(char));\n    if (!lappend)\n    {\n        ofl = fopen(outputScript, \"w\");\n        fprintf(ofl, \"#!/bin/bash\\n\");\n        /*\n        fprintf(ofl, \"gmt gmtset FONT_LABEL 12p\\n\");\n        fprintf(ofl, \"gmt gmtset MAP_LABEL_OFFSET 0.1c\\n\");\n        */\n        fprintf(ofl, \"parms=\\\"--FONT_LABEL=10p --MAP_LABEL_OFFSET=0.1c --PROJ_LENGTH_UNIT=cm\\\"\\n\");\n        fprintf(ofl, \"psfl=%s\\n\", psFile);\n    }\n    else\n    {\n        ofl = fopen(outputScript, \"a\");\n        strcpy(app, \"-O\\0\");\n        strcpy(more, \">\\0\");\n        strcpy(shift, \"-Y4.0\\0\");\n    }\n    fprintf(ofl,\n/*\n            \"gmt psbasemap -JX5i/1i %s -R-30/30/0/%.2f -Bg5a5:\\\"Longitude (deg)\\\":/a%.2f:\\\"Likelihood\\\":WSn -P %s -K >%s ${psfl}\\n\",\n*/\n            \"gmt psbasemap -JX5i/1i %s -R-30/30/0/%.2f -Bpxg5a5+l\\\"Longitude (deg)\\\" -Bpya%.2f+l\\\"Likelihood\\\" -BWSn -P %s -K ${parms} >%s ${psfl}\\n\",\n            shift, gmax*1.1, gmax*0.2, app, more);\n    setFillColor(0, igammaOpt, color);\n    if (ng > 1)\n    {\n       fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O -K << EOF >> ${psfl}\\n\", color);\n    }\n    else\n    {\n       fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O << EOF >> ${psfl}\\n\", color);\n    }\n    fprintf(ofl, \"%f %f\\n\", -30.0, 0.0);\n    fprintf(ofl, \"%f %f\\n\", -30.0, gammaHist[0]);\n    for (i=0; i<ng-1; i++)\n    {\n        vAvg = 0.5*(v[i] + v[i+1]);\n        compearth_v2gamma(1, &vAvg, &gammaAvg);\n        fprintf(ofl, \"%f %f\\n\", gammaAvg*180.0/M_PI, gammaHist[i]);\n        fprintf(ofl, \"%f %f\\n\", gammaAvg*180.0/M_PI, 0.0);\n        fprintf(ofl, \"EOF\\n\");\n        setFillColor(i+1, igammaOpt, color);\n        if (i < ng - 2 || lwritePrior)\n        {\n            fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O -K << EOF >> ${psfl}\\n\", color);\n        }\n        else\n        {\n            fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O << EOF >> ${psfl}\\n\", color);\n        }\n        fprintf(ofl, \"%f %f\\n\", gammaAvg*180.0/M_PI, 0.0);\n        fprintf(ofl, \"%f %f\\n\", gammaAvg*180.0/M_PI, gammaHist[i+1]);\n    }\n    fprintf(ofl, \"%f %f\\n\", 30.0, gammaHist[ng-1]);\n    fprintf(ofl, \"%f %f\\n\", 30.0, 0.0);\n    fprintf(ofl, \"EOF\\n\");\n    // Write the prior distribution\n    if (lwritePrior)\n    {\n        fprintf(ofl, \"gmt psxy -R -J -W1,black -O -K << EOF >> ${psfl}\\n\");\n        fprintf(ofl, \"%f %f\\n\",-30.0, 1.0/(double) ng);\n        fprintf(ofl, \"%f %f\\n\", 30.0, 1.0/(double) ng);\n        fprintf(ofl, \"EOF\\n\");\n    }\n    // Write the CDF\n/*\n    fprintf(ofl, \"gmt psbasemap -R-30/30/0/1.05 -J -Bp0.2/a0.2:\\\"CDF\\\":E -O -K >> ${psfl}\\n\");\n*/\n    fprintf(ofl, \"gmt psbasemap -R-30/30/0/1.05 -J -Bpx0.2 -Bpya0.2+l\\\"CDF\\\" -BE -O -K ${parms} >> ${psfl}\\n\");\n    cumGamma = array_cumsum64f(ng, gammaHist, &ierr);\n    if (lclose)\n    {\n        fprintf(ofl, \"gmt psxy -R -J -W1,blue -O << EOF >> ${psfl}\\n\");\n    }\n    else\n    {\n        fprintf(ofl, \"gmt psxy -R -J -W1,blue -O -K << EOF >> ${psfl}\\n\");\n    }\n    for (i=0; i<ng; i++)\n    {   \n        fprintf(ofl, \"%f %f\\n\", gammas[i]*180.0/M_PI, cumGamma[i]);\n    }   \n    fprintf(ofl, \"EOF\\n\");\n    if (lclose)\n    {    \n        //fprintf(ofl, \"gmt psconvert -A -Tj ${psfl}\\n\");\n        //fprintf(ofl, \"rm ${psfl}\\n\");\n        fprintf(ofl, \"gmt psconvert -A -Tf ${psfl}\\n\");\n        fprintf(ofl, \"/bin/rm ${psfl}\\n\");\n    }\n    memory_free64f(&cumGamma);\n    memory_free64f(&v);\n    fclose(ofl);\n    chmod(outputScript, 0755);\n    return 0;\n}\n//============================================================================//\nint postmt_gmtHelper_writeBetaBoxes(const bool lappend, const bool lclose,\n                                    const char *outputScript,\n                                    const char *psFile,\n                                    const int nb,\n                                    const int ibetaOpt,\n                                    const double *__restrict__ betas,\n                                    const double *__restrict__ betaHist)\n{\n    FILE *ofl;\n    char color[32], app[8], more[8], shift[8];\n    double *betaCum, *u, bmax, betaAvg, uAvg;\n    int i, ierr;\n    const bool lwritePrior = true;\n    bmax = array_max64f(nb, betaHist, &ierr);\n    // Compute u\n    u = memory_calloc64f(nb);\n    compearth_beta2u(nb, betas, u);\n    // Take averages\n    betaAvg = 0.0;\n    memset(app, 0, 8*sizeof(char));\n    memset(more, 0, 8*sizeof(char));\n    memset(shift, 0, 8*sizeof(char));\n    if (!lappend)\n    {\n        ofl = fopen(outputScript, \"w\");\n        fprintf(ofl, \"#!/bin/bash\\n\");\n        /*\n        fprintf(ofl, \"gmt gmtset FONT_LABEL 12p\\n\");\n        fprintf(ofl, \"gmt gmtset MAP_LABEL_OFFSET 0.1c\\n\");\n        */\n        fprintf(ofl, \"parms=\\\"--FONT_LABEL=10p --MAP_LABEL_OFFSET=0.1c --PROJ_LENGTH_UNIT=cm\\\"\\n\");\n        fprintf(ofl, \"psfl=%s\\n\", psFile);\n    }\n    else\n    {\n        ofl = fopen(outputScript, \"a\");\n        strcpy(app, \"-O\\0\");\n        strcpy(more, \">\\0\");\n        strcpy(shift, \"-Y4.0\\0\");\n    }\n    fprintf(ofl,\n/*\n            \"gmt psbasemap -JX5i/1i %s -R-90/90/0/%.3f -Bg15a15:\\\"Latitude (deg)\\\":/a%.2f:\\\"Likelihood\\\":WSn -P %s -K >%s ${psfl}\\n\",\n*/\n            \"gmt psbasemap -JX5i/1i %s -R-90/90/0/%.3f -Bpxg15a15+l\\\"Latitude (deg)\\\" -Bpya%.2f+l\\\"Likelihood\\\" -BWSn -P %s -K ${parms} >%s ${psfl}\\n\",\n            shift, bmax*1.1, bmax*0.2, app, more);\n    setFillColor(0, ibetaOpt, color);\n    if (nb > 1)\n    {\n       fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O -K << EOF >> ${psfl}\\n\", color);\n    }\n    else\n    {\n       fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O << EOF >> ${psfl}\\n\", color);\n    }\n    fprintf(ofl, \"%f %f\\n\", 90.0 - 0.0, 0.0);\n    fprintf(ofl, \"%f %f\\n\", 90.0 - 0.0, betaHist[0]); \n    for (i=0; i<nb-1; i++)\n    {\n        uAvg = 0.5*(u[i] + u[i+1]);\n        compearth_u2beta(1, &uAvg, &betaAvg);\n        //compearth_u2beta(1, 20, 2, &uAvg, 1.e-7, &betaAvg);\n        fprintf(ofl, \"%f %f\\n\", 90.0 - betaAvg*180.0/M_PI, betaHist[i]);\n        fprintf(ofl, \"%f %f\\n\", 90.0 - betaAvg*180.0/M_PI, 0.0);\n        fprintf(ofl, \"EOF\\n\");\n        setFillColor(i+1, ibetaOpt, color);\n        if (i < nb - 2 || lwritePrior)\n        {\n            fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O -K << EOF >> ${psfl}\\n\", color);\n        }\n        else\n        {\n            fprintf(ofl, \"gmt psxy -R -J -Wblack %s -O << EOF >> ${psfl}\\n\", color);\n        }\n        fprintf(ofl, \"%f %f\\n\", 90.0 - betaAvg*180.0/M_PI, 0.0);\n        fprintf(ofl, \"%f %f\\n\", 90.0 - betaAvg*180.0/M_PI, betaHist[i+1]);\n    }\n    fprintf(ofl, \"%f %f\\n\", 90.0 - M_PI*180.0/M_PI, betaHist[nb-1]);\n    fprintf(ofl, \"%f %f\\n\", 90.0 - M_PI*180.0/M_PI, 0.0);\n    fprintf(ofl, \"EOF\\n\");\n    // Write the prior distribution\n    if (lwritePrior)\n    {\n        fprintf(ofl, \"gmt psxy -R -J -W1,black -O -K << EOF >> ${psfl}\\n\");\n        fprintf(ofl, \"%f %f\\n\",-90.0, 1.0/(double) nb);\n        fprintf(ofl, \"%f %f\\n\", 90.0, 1.0/(double) nb);\n        fprintf(ofl, \"EOF\\n\");\n    }\n    // Write the CDF \n/*\n    fprintf(ofl, \"gmt psbasemap -R-90/90/0/1.05 -J -Bp0.2/a0.2:\\\"CDF\\\":E -O -K >> ${psfl}\\n\");\n*/\n    fprintf(ofl, \"gmt psbasemap -R-90/90/0/1.05 -J -Bpx0.2 -Bpya0.2+l\\\"CDF\\\" -BE -O -K ${parms} >> ${psfl}\\n\");\n    betaCum = array_cumsum64f(nb, betaHist, &ierr);\n    if (lclose)\n    {\n        fprintf(ofl, \"gmt psxy -R -J -W1,blue -O << EOF >> ${psfl}\\n\");\n    }\n    else\n    {\n        fprintf(ofl, \"gmt psxy -R -J -W1,blue -O -K << EOF >> ${psfl}\\n\"); \n    }\n    for (i=0; i<nb; i++)\n    {\n        // the cdf is written backwards because i flip the axis to make it\n        // increase left to right; this is opposite of what colatitude wants\n        // to do\n        fprintf(ofl, \"%f %f\\n\", 90.0 - betas[i]*180.0/M_PI, betaCum[nb-1-i]);\n    }   \n    fprintf(ofl, \"EOF\\n\");\n    if (lclose)\n    {    \n        //fprintf(ofl, \"gmt psconvert -A -Tj ${psfl}\\n\");\n        //fprintf(ofl, \"rm ${psfl}\\n\");\n        fprintf(ofl, \"gmt psconvert -A -Tf ${psfl}\\n\");\n        fprintf(ofl, \"/bin/rm ${psfl}\\n\");\n    }\n    memory_free64f(&u);\n    memory_free64f(&betaCum);\n    fclose(ofl);\n    chmod(outputScript, 0755);\n    return 0;\n}\n//============================================================================//\nint postmt_gmtHelper_makeRegularHistograms(\n    const int nlocs, const int nm,\n    const int nb, const int ng, const int nk,\n    const int ns, const int nt,\n    const int nmt, const double *__restrict__ phi,\n    double **__restrict__ locHist,\n    double **__restrict__ magHist,\n    double **__restrict__ betaHist,\n    double **__restrict__ gammaHist,\n    double **__restrict__ kappaHist,\n    double **__restrict__ sigmaHist,\n    double **__restrict__ thetaHist)\n{\n    double *betaH, *gammaH, *kappaH, *locH, *magH, *sigmaH, *thetaH, xsum;\n    int ib, ierr, ig, ik, il, im, imt, is, it; \n    locH = memory_calloc64f(nlocs);\n    magH = memory_calloc64f(nm);\n    betaH = memory_calloc64f(nb);\n    gammaH = memory_calloc64f(ng);\n    kappaH = memory_calloc64f(nk);\n    sigmaH = memory_calloc64f(ns);\n    thetaH = memory_calloc64f(nt);\n    for (il=0; il<nlocs; il++)\n    {\n        for (im=0; im<nm; im++)\n        {\n            for (ib=0; ib<nb; ib++)\n            {\n                for (ig=0; ig<ng; ig++)\n                {\n                    for (ik=0; ik<nk; ik++)\n                    {\n                        for (is=0; is<ns; is++)\n                        {\n                            for (it=0; it<nt; it++)\n                            {\n                                imt = il*nm*nb*ng*nk*ns*nt\n                                    + im*nb*ng*nk*ns*nt\n                                    + ib*ng*nk*ns*nt\n                                    + ig*nk*ns*nt\n                                    + ik*ns*nt\n                                    + is*nt\n                                    + it;\n                                locH[il]   = locH[il]   + phi[imt];\n                                magH[im]   = magH[im]   + phi[imt];\n                                betaH[ib]  = betaH[ib]  + phi[imt];\n                                gammaH[ig] = gammaH[ig] + phi[imt];\n                                kappaH[ik] = kappaH[ik] + phi[imt];\n                                sigmaH[is] = sigmaH[is] + phi[imt];\n                                thetaH[it] = thetaH[it] + phi[imt];\n                            }\n                        }\n                    }\n                }\n            }\n        }\n    }\n    xsum = array_sum64f(nmt, phi, &ierr);\n    cblas_dscal(nlocs, 1.0/xsum, locH, 1);\n    cblas_dscal(nm, 1.0/xsum, magH, 1);\n    cblas_dscal(nb, 1.0/xsum, betaH, 1);\n    cblas_dscal(ng, 1.0/xsum, gammaH, 1);\n    cblas_dscal(nk, 1.0/xsum, kappaH, 1);\n    cblas_dscal(ns, 1.0/xsum, sigmaH, 1);\n    cblas_dscal(nt, 1.0/xsum, thetaH, 1);\n    *locHist = locH;\n    *magHist = magH;\n    *betaHist = betaH;\n    *gammaHist = gammaH;\n    *kappaHist = kappaH;\n    *sigmaHist = sigmaH;\n    *thetaHist = thetaH;\n    return 0;\n}\n//============================================================================//\nstatic void getBaseAndExp(const double val, double *base, int *exp)\n{\n    char cval[64], cexp[64], temp[64];\n    int i, k, l;\n    bool lp1;\n    memset(cval, 0, 64*sizeof(char));\n    memset(cexp, 0, 64*sizeof(char));\n    memset(temp, 0, 64*sizeof(char));\n    sprintf(temp, \"%04.2e\", val);\n    lp1 = true;\n    k = 0;\n    l = 0;\n    for (i=0; i<strlen(temp); i++)\n    {\n        if (temp[i] == 'e')\n        {\n            lp1 = false;\n            continue;\n        }\n        else\n        {\n            if (lp1)\n            {\n                cval[k] = temp[i];\n                k = k + 1;\n            }\n            else\n            {\n                cexp[l] = temp[i];\n                l = l + 1;\n            }\n        }   \n    }\n    *exp = atoi(cexp);\n    *base = atof(cval);\n    return;\n}\n\nstatic void getBaseAndExpMT(const double *mtIn, double *mtOut, int *expOut)\n{\n    double xfact;\n    int expWork, i;\n    getBaseAndExp(mtIn[0], &mtOut[0], expOut);\n    for (i=1; i<6; i++)\n    {\n        getBaseAndExp(mtIn[i], &mtOut[i], &expWork);\n        if (expWork > *expOut){*expOut = expWork;}\n    }\n    // Rescale\n    for (i=0; i<6; i++)\n    {\n        getBaseAndExp(mtIn[i], &mtOut[i], &expWork);\n        xfact = pow(10.0, expWork - *expOut);\n        mtOut[i] = mtOut[i]*xfact;\n    }\n    return;\n}\n\nint postmt_gmtHelper_makePsmecaLine(const enum compearthCoordSystem_enum basis,\n                                    const double *mt,\n                                    const double evla, const double evlo,\n                                    const double evdp, const char *evid,\n                                    char line[128])\n{\n    const char *fcnm = \"postmt_gmtHelper_makePsmecaLine\\0\";\n    double mtUSE[6], mtGMT[6];\n    int exp, ierr;\n    memset(line, 0, 128*sizeof(char));\n    ierr = compearth_convertMT(1, basis, CE_USE, mt, mtUSE);\n    if (ierr != 0)\n    {\n        printf(\"%s: Error switching basis\\n\", fcnm);\n        return -1;\n    }\n    getBaseAndExpMT(mtUSE, mtGMT, &exp);\n    sprintf(line, \"%f %f %f %f %f %f %f %f %f %d %s\\n\",\n            evlo, evla, evdp,\n            mtGMT[0], mtGMT[1], mtGMT[2], mtGMT[3], mtGMT[4], mtGMT[5],\n            exp, evid);\n    return 0;\n}\n\nstatic void setFillColor(const int i, const int iopt, char color[32])\n{\n    memset(color, 0, 32*sizeof(char));\n    if (i == iopt)\n    {\n        strcpy(color, \"-Gyellow\\0\");\n    }\n    else\n    {\n        strcpy(color, \"-Gred\\0\");\n    }\n    return;\n}\n//============================================================================//\n/*\n    sprintf(\"%7.2f %5.2f %f \\n\"< \n            evlo, evla, evdp,\n            mrr, mtt, mpp,  \n            \nColumns: lon lat depth mrr mtt mpp mrt mrp mtp iexp name\n-176.96 -29.25 48 7.68 0.09 -7.77 1.39 4.52 -3.26 26 X Y 010176A  \n*/\n", "meta": {"hexsha": "3e399673441403d6030ec5a9474807aa08a5f5f4", "size": 42477, "ext": "c", "lang": "C", "max_stars_repo_path": "postprocess/gmtHelper.c", "max_stars_repo_name": "bakerb845/parmt", "max_stars_repo_head_hexsha": "2b4097df02ef5e56407d40e821d5c7155c2e4416", "max_stars_repo_licenses": ["Intel"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "postprocess/gmtHelper.c", "max_issues_repo_name": "bakerb845/parmt", "max_issues_repo_head_hexsha": "2b4097df02ef5e56407d40e821d5c7155c2e4416", "max_issues_repo_licenses": ["Intel"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "postprocess/gmtHelper.c", "max_forks_repo_name": "bakerb845/parmt", "max_forks_repo_head_hexsha": "2b4097df02ef5e56407d40e821d5c7155c2e4416", "max_forks_repo_licenses": ["Intel"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.0181368508, "max_line_length": 154, "alphanum_fraction": 0.4724439108, "num_tokens": 14322, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.2720245510940225, "lm_q2_score": 0.03846618995154013, "lm_q1q2_score": 0.010463748053865103}}
{"text": "/* $Id$      */\n/*--------------------------------------------------------------------*/\n/*;  Copyright (C) 2008-2016                                          */\n/*;  Associated Universities, Inc. Washington DC, USA.                */\n/*;                                                                   */\n/*;  This program is free software; you can redistribute it and/or    */\n/*;  modify it under the terms of the GNU General Public License as   */\n/*;  published by the Free Software Foundation; either version 2 of   */\n/*;  the License, or (at your option) any later version.              */\n/*;                                                                   */\n/*;  This program is distributed in the hope that it will be useful,  */\n/*;  but WITHOUT ANY WARRANTY; without even the implied warranty of   */\n/*;  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    */\n/*;  GNU General Public License for more details.                     */\n/*;                                                                   */\n/*;  You should have received a copy of the GNU General Public        */\n/*;  License along with this program; if not, write to the Free       */\n/*;  Software Foundation, Inc., 675 Massachusetts Ave, Cambridge,     */\n/*;  MA 02139, USA.                                                   */\n/*;                                                                   */\n/*;Correspondence about this software should be addressed as follows: */\n/*;         Internet email: bcotton@nrao.edu.                         */\n/*;         Postal address: William Cotton                            */\n/*;                         National Radio Astronomy Observatory      */\n/*;                         520 Edgemont Road                         */\n/*;                         Charlottesville, VA 22903-2475 USA        */\n/*--------------------------------------------------------------------*/\n#ifndef OBITSPECTRUMFIT_H \n#define OBITSPECTRUMFIT_H \n\n#include \"Obit.h\"\n#include \"ObitErr.h\"\n#include \"ObitImage.h\"\n#include \"ObitBeamShape.h\"\n#include \"ObitThread.h\"\n#include \"ObitInfoList.h\"\n#ifdef HAVE_GSL\n#include <gsl/gsl_multifit_nlin.h>\n#endif /* HAVE_GSL */ \n\n/*-------- Obit:  Merx mollis mortibus nuper ------------------*/\n/**\n * \\file ObitSpectrumFit.h\n *\n * ObitSpectrumFit Class for fitting spectra to image pixels\n *\n * This class does least squares fitting of log(s) as a polynomial in log($\\nu$).\n * Either an image cube or a set of single plane images at arbitrary \n * frequencies may be fitted.\n * The result is an image cube of Log(S) with multiples of powers of log($\\nu$)\n * as the planes.\n * The function ObitSpectrumFitEval will evaluate this fit and return an image\n * with the flux densities at the desired frequencies.\n * \n * \\section ObitSpectrumFitaccess Creators and Destructors\n * An ObitSpectrumFit will usually be created using ObitSpectrumFitCreate which allows \n * specifying a name for the object as well as other information.\n *\n * A copy of a pointer to an ObitSpectrumFit should always be made using the\n * #ObitSpectrumFitRef function which updates the reference count in the object.\n * Then whenever freeing an ObitSpectrumFit or changing a pointer, the function\n * #ObitSpectrumFitUnref will decrement the reference count and destroy the object\n * when the reference count hits 0.\n * There is no explicit destructor.\n */\n\n/*--------------Class definitions-------------------------------------*/\n/** ObitSpectrumFit Class structure. */\ntypedef struct {\n#include \"ObitSpectrumFitDef.h\"   /* this class definition */\n} ObitSpectrumFit;\n\n/*----------------- Macroes ---------------------------*/\n/** \n * Macro to unreference (and possibly destroy) an ObitSpectrumFit\n * returns a ObitSpectrumFit*.\n * in = object to unreference\n */\n#define ObitSpectrumFitUnref(in) ObitUnref (in)\n\n/** \n * Macro to reference (update reference count) an ObitSpectrumFit.\n * returns a ObitSpectrumFit*.\n * in = object to reference\n */\n#define ObitSpectrumFitRef(in) ObitRef (in)\n\n/** \n * Macro to determine if an object is the member of this or a \n * derived class.\n * Returns TRUE if a member, else FALSE\n * in = object to reference\n */\n#define ObitSpectrumFitIsA(in) ObitIsA (in, ObitSpectrumFitGetClass())\n\n/*---------------Public functions---------------------------*/\n/** Public: Class initializer. */\nvoid ObitSpectrumFitClassInit (void);\n\n/** Public: Default Constructor. */\nObitSpectrumFit* newObitSpectrumFit (gchar* name);\n\n/** Public: Create/initialize ObitSpectrumFit structures */\nObitSpectrumFit* ObitSpectrumFitCreate (gchar* name, olong nterm);\n/** Typedef for definition of class pointer structure */\ntypedef ObitSpectrumFit* (*ObitSpectrumFitCreateFP) (gchar* name, \n\t\t\t\t\t\t     olong nterm);\n\n/** Public: ClassInfo pointer */\ngconstpointer ObitSpectrumFitGetClass (void);\n\n/** Public: Copy (deep) constructor. */\nObitSpectrumFit* ObitSpectrumFitCopy  (ObitSpectrumFit *in, \n\t\t\t\t       ObitSpectrumFit *out, ObitErr *err);\n\n/** Public: Copy structure. */\nvoid ObitSpectrumFitClone (ObitSpectrumFit *in, ObitSpectrumFit *out, \n\t\t\t   ObitErr *err);\n\n/** Public: Fit spectrum to an image cube */\nvoid ObitSpectrumFitCube (ObitSpectrumFit* in, ObitImage *inImage, \n\t\t\t  ObitImage *outImage, ObitErr *err);\n/** Typedef for definition of class pointer structure */\ntypedef void(*ObitSpectrumFitCubeFP) (ObitSpectrumFit* in, ObitImage *inImage, \n\t\t\t\t      ObitImage *outImage, ObitErr *err);\n\n/** Public: Fit spectrum to an array of images */\nvoid ObitSpectrumFitImArr (ObitSpectrumFit* in, olong nimage, ObitImage **imArr, \n\t\t\t   ObitImage *outImage, ObitErr *err);\n/** Typedef for definition of class pointer structure */\ntypedef void(*ObitSpectrumFitImArrFP) (ObitSpectrumFit* in, olong nimage, ObitImage **imArr, \n\t\t\t   ObitImage *outImage, ObitErr *err);\n\n/* Do actual fitting */\nvoid ObitSpectrumFitter (ObitSpectrumFit* in, ObitErr *err);\ntypedef void(*ObitSpectrumFitterFP) (ObitSpectrumFit* in, ObitErr *err);\n\n/** Public: Evaluate spectrum */\nvoid ObitSpectrumFitEval (ObitSpectrumFit* in, ObitImage *inImage, \n\t\t\t  odouble outFreq, ObitImage *outImage, ObitErr *err);\n/** Typedef for definition of class pointer structure */\ntypedef void(*ObitSpectrumFitEvalFP) (ObitSpectrumFit* in, ObitImage *inImage, \n\t\t\t\t      odouble outFreq, ObitImage *outImage, \n\t\t\t\t      ObitErr *err);\n/** Private: Write output image */\nvoid ObitSpectrumWriteOutput (ObitSpectrumFit* in, ObitImage *outImage, \n\t\t\t      ObitErr *err);\ntypedef void (*ObitSpectrumWriteOutputFP) (ObitSpectrumFit* in, ObitImage *outImage, \n\t\t\t\t\t   ObitErr *err);\n/** Public: Fit single spectrum */\nofloat* ObitSpectrumFitSingle (olong nfreq, olong nterm, odouble refFreq, odouble *freq, \n\t\t\t       ofloat *flux, ofloat *sigma, gboolean doBrokePow, \n\t\t\t       ObitErr *err);\n/** Typedef for definition of class pointer structure */\ntypedef ofloat*(*ObitSpectrumFitSingleFP) (olong nfreq, olong nterm, odouble refFreq, \n\t\t\t\t\t   odouble *freq, ofloat *flux, ofloat *sigma, \n\t\t\t\t\t   gboolean doBrokePow, ObitErr *err);\n\n/** Public: Make fitting arg structure */\ngpointer ObitSpectrumFitMakeArg (olong nfreq, olong nterm, \n\t\t\t\t odouble refFreq, odouble *freq, \n\t\t\t\t gboolean doBrokePow, \n\t\t\t\t ofloat **out, ObitErr *err);\n\n/** Public: Fit single spectrum using arg */\nvoid ObitSpectrumFitSingleArg (gpointer arg, ofloat *flux, ofloat  *sigma,\n\t\t\t       ofloat *out);\n\n/** Public: Kill fitting arg structure */\nvoid ObitSpectrumFitKillArg (gpointer arg);\n/*----------- ClassInfo Structure -----------------------------------*/\n/**\n * ClassInfo Structure.\n * Contains class name, a pointer to any parent class\n * (NULL if none) and function pointers.\n */\ntypedef struct  {\n#include \"ObitSpectrumFitClassDef.h\"\n} ObitSpectrumFitClassInfo; \n\n#endif /* OBITFSPECTRUMFIT_H */ \n", "meta": {"hexsha": "91f694e692075bd9161528156fb7f9bc766c4857", "size": 7778, "ext": "h", "lang": "C", "max_stars_repo_path": "ObitSystem/Obit/include/ObitSpectrumFit.h", "max_stars_repo_name": "sarrvesh/Obit", "max_stars_repo_head_hexsha": "e4ce6029e9beb2a8c0316ee81ea710b66b2b7986", "max_stars_repo_licenses": ["Linux-OpenIB"], "max_stars_count": 5.0, "max_stars_repo_stars_event_min_datetime": "2019-08-26T06:53:08.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-20T01:08:59.000Z", "max_issues_repo_path": "ObitSystem/Obit/include/ObitSpectrumFit.h", "max_issues_repo_name": "sarrvesh/Obit", "max_issues_repo_head_hexsha": "e4ce6029e9beb2a8c0316ee81ea710b66b2b7986", "max_issues_repo_licenses": ["Linux-OpenIB"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ObitSystem/Obit/include/ObitSpectrumFit.h", "max_forks_repo_name": "sarrvesh/Obit", "max_forks_repo_head_hexsha": "e4ce6029e9beb2a8c0316ee81ea710b66b2b7986", "max_forks_repo_licenses": ["Linux-OpenIB"], "max_forks_count": 8.0, "max_forks_repo_forks_event_min_datetime": "2017-08-29T15:12:32.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T12:16:08.000Z", "avg_line_length": 42.7362637363, "max_line_length": 93, "alphanum_fraction": 0.6346104397, "num_tokens": 1926, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.31742626558767584, "lm_q2_score": 0.031618768295228174, "lm_q1q2_score": 0.010036627542436283}}
{"text": "#include <math.h>\n#include <stdlib.h>\n#if !defined(__APPLE__)\n#include <malloc.h>\n#endif\n#include <stdio.h>\n#include <assert.h>\n#include <time.h>\n#include <string.h>\n#include <stdbool.h>\n\n#include <fftw3.h>\n\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_sf_erf.h>\n#include <gsl/gsl_integration.h>\n#include <gsl/gsl_spline.h>\n#include <gsl/gsl_sf_gamma.h>\n#include <gsl/gsl_sf_legendre.h>\n#include <gsl/gsl_sf_bessel.h>\n#include <gsl/gsl_linalg.h>\n#include <gsl/gsl_matrix.h>\n#include <gsl/gsl_eigen.h>\n#include <gsl/gsl_sf_expint.h>\n#include <gsl/gsl_deriv.h>\n#include <gsl/gsl_interp2d.h>\n#include <gsl/gsl_spline2d.h>\n\n#include \"../cosmolike_core/theory/basics.c\"\n#include \"../cosmolike_core/theory/structs.c\"\n#include \"../cosmolike_core/theory/parameters.c\"\n#include \"../cosmolike_core/emu17/P_cb/emu.c\"\n#include \"../cosmolike_core/theory/recompute.c\"\n#include \"../cosmolike_core/theory/cosmo3D.c\"\n#include \"../cosmolike_core/theory/redshift_spline.c\"\n#include \"../cosmolike_core/theory/halo.c\"\n#include \"../cosmolike_core/theory/HOD.c\"\n#include \"../cosmolike_core/theory/pt.c\"\n#include \"../cosmolike_core/theory/cosmo2D_fourier.c\"\n#include \"../cosmolike_core/theory/IA.c\"\n#include \"../cosmolike_core/theory/BAO.c\"\n#include \"../cosmolike_core/theory/external_prior.c\"\n#include \"../cosmolike_core/theory/covariances_3D.c\"\n#include \"../cosmolike_core/theory/covariances_fourier.c\"\n#include \"../cosmolike_core/theory/CMBxLSS_fourier.c\"\n#include \"../cosmolike_core/theory/covariances_CMBxLSS_fourier.c\"\n\n#include \"../cosmolike_core/theory/covariances_binned_simple.c\"\n#include \"../cosmolike_core/theory/run_covariances_fourier_binned_6x2pt.c\"\n\n#include \"init_LSSxCMB.c\"\n\n\nint main(int argc, char** argv)\n{\n  \n  int i,l,m,n,o,s,p,nl1,t,k;\n  char OUTFILE[400],filename[400],arg1[400],arg2[400];\n  \n  int N_scenarios=2;\n  double area_table[2]={12300.0,16500.0}; // Y1 corresponds to DESC SRD Y1, Y6 corresponds to assuming that we cover the full SO area=0.4*fsky and at a depth of 26.1 which is in a range of reasonable scenarios (see https://github.com/LSSTDESC/ObsStrat/tree/static/static )\n  double nsource_table[2]={11.0,23.0};\n  double nlens_table[2]={18.0,41.0};\n  \n  char survey_designation[2][200]={\"LSSTxSO_Y1\",\"LSSTxSO_Y6\"};\n  \n  char source_zfile[2][400]={\"src_LSSTY1\",\"src_LSSTY6\"};\n\n#ifdef ONESAMPLE\n  char lens_zfile[2][400]={\"src_LSSTY1\",\"src_LSSTY6\"};\n  nlens_table[0] = nsource_table[0];\n  nlens_table[1] = nsource_table[1];\n#else\n  char lens_zfile[2][400]={\"lens_LSSTY1\",\"lens_LSSTY6\"};\n#endif\n\n  int hit=atoi(argv[1]);\n  Ntable.N_a=100;\n  k=1;\n  \n  t = atoi(argv[2]);\n  \n  //RUN MODE setup\n  init_cosmo_runmode(\"emu\");\n  // init_binning_fourier(20,30.0,3000.0,3000.0,21.0,10,10);\n  init_binning_fourier(15,20.0,3000.0,3000.0,0.0,10,10);\n  init_survey(survey_designation[t],nsource_table[t],nlens_table[t],area_table[t]);\n  sprintf(arg1,\"zdistris/%s\",source_zfile[t]);\n  sprintf(arg2,\"zdistris/%s\",lens_zfile[t]); \n  init_galaxies(arg1,arg2,\"none\",\"none\",\"source_std\",\"LSST_gold\");\n  init_IA(\"none\",\"GAMA\"); \n  init_probes(\"6x2pt\");\n\n  if(t==0) init_cmb(\"so_Y1\");\n  if(t==1) init_cmb(\"so_Y5\");\n  cmb.fsky = survey.area*survey.area_conversion_factor/(4.*M_PI);\n  //set l-bins for shear, ggl, clustering, clusterWL\n\n  double lmin=like.lmin;\n  double lmax=like.lmax;\n  int Nell=like.Ncl;\n  int Ncl = Nell;\n  double logdl=(log(lmax)-log(lmin))/Nell;\n  double *ellmin, *dell;\n  ellmin=create_double_vector(0,Nell);\n  dell=create_double_vector(0,Nell-1);\n  double ellmax;\n  for(i=0; i<Nell ; i++){\n    ellmin[i]=exp(log(lmin)+(i+0.0)*logdl);\n    ellmax = exp(log(lmin)+(i+1.0)*logdl);\n    dell[i]=ellmax-ellmin[i];\n  }\n  ellmin[Nell] = ellmax;\n  like.ell = ellmin;\n\n  covparams.ng = 1;\n  covparams.cng= 0;\n\n  printf(\"----------------------------------\\n\");  \n  sprintf(survey.name,\"%s_area%le_ng%le_nl%le\",survey_designation[t],survey.area,survey.n_gal,survey.n_lens);\n  printf(\"area: %le n_source: %le n_lens: %le\\n\",survey.area,survey.n_gal,survey.n_lens);\n\n  // sprintf(covparams.outdir,\"/home/u17/timeifler/covparallel/\"); \n#ifdef ONESAMPLE\n  sprintf(covparams.outdir,\"out_cov_lsstxso_1sample/\");\n#else\n  sprintf(covparams.outdir,\"out_cov_lsstxso/\");\n  //sprintf(covparams.outdir,\"/halo_nobackup/cosmos/teifler/covparallel/\");\n#endif\n\n  printf(\"----------------------------------\\n\");  \n  if (like.shear_shear)\n  {\n    sprintf(OUTFILE,\"%s_ssss_cov_Ncl%d_Ntomo%d\",survey.name,Ncl,tomo.shear_Nbin);\n\n    for (l=0;l<tomo.shear_Npowerspectra; l++){\n      for (m=l;m<tomo.shear_Npowerspectra; m++){\n        if(k==hit){\n          sprintf(filename,\"%s%s_%d\",covparams.outdir,OUTFILE,k);\n          // if (fopen(filename, \"r\") != NULL){exit(1);}\n          run_cov_shear_shear_fourier_bin(OUTFILE,covparams.outdir,ellmin,Ncl,l,m,k);\n        }\n\n        k=k+1;\n      }\n    }\n  }\n  if (like.pos_pos)\n  {\n    sprintf(OUTFILE,\"%s_llll_cov_Ncl%d_Ntomo%d\",survey.name,Ncl,tomo.shear_Nbin);\n    for (l=0;l<tomo.clustering_Npowerspectra; l++){ \n      for (m=l;m<tomo.clustering_Npowerspectra; m++){\n        if(k==hit){\n          sprintf(filename,\"%s%s_%d\",covparams.outdir,OUTFILE,k);\n          // if (fopen(filename, \"r\") != NULL){exit(1);}\n          run_cov_clustering_fourier_bin(OUTFILE,covparams.outdir,ellmin,Ncl,l,m,k); \n        }        \n        k=k+1;\n      }\n    }\n  }\n  if (like.shear_pos)\n  {\n    sprintf(OUTFILE,\"%s_lsls_cov_Ncl%d_Ntomo%d\",survey.name,Ncl,tomo.shear_Nbin);\n    for (l=0;l<tomo.ggl_Npowerspectra; l++){\n      for (m=l;m<tomo.ggl_Npowerspectra; m++){\n        if(k==hit) {\n          sprintf(filename,\"%s%s_%d\",covparams.outdir,OUTFILE,k);\n          // if (fopen(filename, \"r\") != NULL){exit(1);}\n          run_cov_ggl_fourier_bin(OUTFILE,covparams.outdir,ellmin,Ncl,l,m,k);  \n        }        \n        k=k+1;\n      }\n    }\n  }\n  if (like.shear_pos && like.shear_shear)\n  {\n    sprintf(OUTFILE,\"%s_lsss_cov_Ncl%d_Ntomo%d\",survey.name,Ncl,tomo.shear_Nbin);\n    for (l=0;l<tomo.ggl_Npowerspectra; l++){\n      for (m=0;m<tomo.shear_Npowerspectra; m++){\n        if(k==hit) {\n          sprintf(filename,\"%s%s_%d\",covparams.outdir,OUTFILE,k);\n          // if (fopen(filename, \"r\") != NULL){exit(1);}\n          run_cov_ggl_shear_fourier_bin(OUTFILE,covparams.outdir,ellmin,Ncl,l,m,k);  \n        } \n        k=k+1;\n      }\n    }\n  }\n  if (like.pos_pos && like.shear_shear)\n  {\n    sprintf(OUTFILE,\"%s_llss_cov_Ncl%d_Ntomo%d\",survey.name,Ncl,tomo.shear_Nbin);\n    for (l=0;l<tomo.clustering_Npowerspectra; l++){\n      for (m=0;m<tomo.shear_Npowerspectra; m++){\n        if(k==hit) {\n          sprintf(filename,\"%s%s_%d\",covparams.outdir,OUTFILE,k);\n          // if (fopen(filename, \"r\") != NULL){exit(1);}\n          run_cov_clustering_shear_fourier_bin(OUTFILE,covparams.outdir,ellmin,Ncl,l,m,k);  \n        } \n        k=k+1;\n      }\n    }\n  }\n  if (like.pos_pos && like.shear_pos)\n  {\n    sprintf(OUTFILE,\"%s_llls_cov_Ncl%d_Ntomo%d\",survey.name,Ncl,tomo.shear_Nbin);\n    for (l=0;l<tomo.clustering_Npowerspectra; l++){\n      for (m=0;m<tomo.ggl_Npowerspectra; m++){\n        if(k==hit) {\n          sprintf(filename,\"%s%s_%d\",covparams.outdir,OUTFILE,k);\n          // if (fopen(filename, \"r\") != NULL){exit(1);}\n          run_cov_clustering_ggl_fourier_bin(OUTFILE,covparams.outdir,ellmin,Ncl,l,m,k);  \n        }\n        k=k+1;\n      }\n    }\n  }\n  if (like.gk && like.shear_shear)\n  {\n    sprintf(OUTFILE,\"%s_lkss_cov_Ncl%d_Ntomo%d\",survey.name,Ncl,tomo.shear_Nbin);\n    for (l=0;l<tomo.clustering_Nbin; l++){\n      for (m=0;m<tomo.shear_Npowerspectra; m++){\n        if(k==hit) {\n          sprintf(filename,\"%s%s_%d\",covparams.outdir,OUTFILE,k);\n          // if (fopen(filename, \"r\") != NULL){exit(1);}\n          run_cov_gk_shear_fourier_bin(OUTFILE,covparams.outdir,ellmin,Ncl,l,m,k);  \n        } \n        k=k+1;\n      }\n    }\n  }\n  if (like.ks && like.shear_shear)\n  {\n    sprintf(OUTFILE,\"%s_ksss_cov_Ncl%d_Ntomo%d\",survey.name,Ncl,tomo.shear_Nbin);\n    for (l=0;l<tomo.shear_Nbin; l++){\n      for (m=0;m<tomo.shear_Npowerspectra; m++){\n        if(k==hit) {\n          sprintf(filename,\"%s%s_%d\",covparams.outdir,OUTFILE,k);\n          // if (fopen(filename, \"r\") != NULL){exit(1);}\n          run_cov_ks_shear_fourier_bin(OUTFILE,covparams.outdir,ellmin,Ncl,l,m,k);  \n        } \n        k=k+1;\n      }\n    }\n  }\n  if (like.gk && like.shear_pos)\n  {\n    sprintf(OUTFILE,\"%s_lkls_cov_Ncl%d_Ntomo%d\",survey.name,Ncl,tomo.shear_Nbin);\n    for (l=0;l<tomo.clustering_Nbin; l++){\n      for (m=0;m<tomo.ggl_Npowerspectra; m++){\n        if(k==hit) {\n          sprintf(filename,\"%s%s_%d\",covparams.outdir,OUTFILE,k);\n          // if (fopen(filename, \"r\") != NULL){exit(1);}\n          run_cov_gk_ggl_fourier_bin(OUTFILE,covparams.outdir,ellmin,Ncl,l,m,k);  \n        }\n        k=k+1;\n      }\n    }\n  }\n  if (like.ks && like.shear_pos)\n  {\n    sprintf(OUTFILE,\"%s_ksls_cov_Ncl%d_Ntomo%d\",survey.name,Ncl,tomo.shear_Nbin);\n    for (l=0;l<tomo.shear_Nbin; l++){\n      for (m=0;m<tomo.ggl_Npowerspectra; m++){\n        if(k==hit) {\n          sprintf(filename,\"%s%s_%d\",covparams.outdir,OUTFILE,k);\n          // if (fopen(filename, \"r\") != NULL){exit(1);}\n          run_cov_ks_ggl_fourier_bin(OUTFILE,covparams.outdir,ellmin,Ncl,l,m,k);  \n        }\n        k=k+1;\n      }\n    }\n  }\n  if (like.gk && like.pos_pos)\n  {\n    sprintf(OUTFILE,\"%s_lkll_cov_Ncl%d_Ntomo%d\",survey.name,Ncl,tomo.shear_Nbin);\n    for (l=0;l<tomo.clustering_Nbin; l++){\n      for (m=0;m<tomo.clustering_Npowerspectra; m++){\n        if(k==hit) {\n          sprintf(filename,\"%s%s_%d\",covparams.outdir,OUTFILE,k);\n          // if (fopen(filename, \"r\") != NULL){exit(1);}\n          run_cov_gk_clustering_fourier_bin(OUTFILE,covparams.outdir,ellmin,Ncl,l,m,k);  \n        }\n        k=k+1;\n      }\n    }\n  }\n  if (like.ks && like.pos_pos)\n  {\n    sprintf(OUTFILE,\"%s_ksll_cov_Ncl%d_Ntomo%d\",survey.name,Ncl,tomo.shear_Nbin);\n    for (l=0;l<tomo.shear_Nbin; l++){\n      for (m=0;m<tomo.clustering_Npowerspectra; m++){\n        if(k==hit) {\n          sprintf(filename,\"%s%s_%d\",covparams.outdir,OUTFILE,k);\n          // if (fopen(filename, \"r\") != NULL){exit(1);}\n          run_cov_ks_clustering_fourier_bin(OUTFILE,covparams.outdir,ellmin,Ncl,l,m,k);  \n        }\n        k=k+1;\n      }\n    }\n  }\n  if (like.gk)\n  {\n    sprintf(OUTFILE,\"%s_lklk_cov_Ncl%d_Ntomo%d\",survey.name,Ncl,tomo.shear_Nbin);\n    for (l=0;l<tomo.clustering_Nbin; l++){\n      for (m=l;m<tomo.clustering_Nbin; m++){\n        if(k==hit) {\n          sprintf(filename,\"%s%s_%d\",covparams.outdir,OUTFILE,k);\n          // if (fopen(filename, \"r\") != NULL){exit(1);}\n          run_cov_gk_gk_fourier_bin(OUTFILE,covparams.outdir,ellmin,Ncl,l,m,k);  \n        }\n        k=k+1;\n      }\n    }\n  }\n  if (like.ks && like.gk)\n  {\n    sprintf(OUTFILE,\"%s_kslk_cov_Ncl%d_Ntomo%d\",survey.name,Ncl,tomo.shear_Nbin);\n    for (l=0;l<tomo.shear_Nbin; l++){\n      for (m=0;m<tomo.clustering_Nbin; m++){\n        if(k==hit) {\n          sprintf(filename,\"%s%s_%d\",covparams.outdir,OUTFILE,k);\n          // if (fopen(filename, \"r\") != NULL){exit(1);}\n          run_cov_ks_gk_fourier_bin(OUTFILE,covparams.outdir,ellmin,Ncl,l,m,k);  \n        }\n        k=k+1;\n      }\n    }\n  }\n  if (like.ks)\n  {\n    sprintf(OUTFILE,\"%s_ksks_cov_Ncl%d_Ntomo%d\",survey.name,Ncl,tomo.shear_Nbin);\n    for (l=0;l<tomo.shear_Nbin; l++){\n      for (m=l;m<tomo.shear_Nbin; m++){\n        if(k==hit) {\n          sprintf(filename,\"%s%s_%d\",covparams.outdir,OUTFILE,k);\n          // if (fopen(filename, \"r\") != NULL){exit(1);}\n          run_cov_ks_ks_fourier_bin(OUTFILE,covparams.outdir,ellmin,Ncl,l,m,k);  \n        }\n        k=k+1;\n      }\n    }\n  }\n  ////////\n\n  if (like.kk && like.shear_shear)\n  {\n    sprintf(OUTFILE,\"%s_kkss_cov_Ncl%d_Ntomo%d\",survey.name,Ncl,tomo.shear_Nbin);\n    for (m=0;m<tomo.shear_Npowerspectra; m++){\n      if(k==hit) {\n        sprintf(filename,\"%s%s_%d\",covparams.outdir,OUTFILE,k);\n        // if (fopen(filename, \"r\") != NULL){exit(1);}\n        run_cov_kk_shear_fourier_bin(OUTFILE,covparams.outdir,ellmin,Ncl,m,k);  \n      } \n      k=k+1;\n    }\n  }\n  if (like.kk && like.shear_pos)\n  {\n    sprintf(OUTFILE,\"%s_kkls_cov_Ncl%d_Ntomo%d\",survey.name,Ncl,tomo.shear_Nbin);\n    for (m=0;m<tomo.ggl_Npowerspectra; m++){\n      if(k==hit) {\n        sprintf(filename,\"%s%s_%d\",covparams.outdir,OUTFILE,k);\n        // if (fopen(filename, \"r\") != NULL){exit(1);}\n        run_cov_kk_ggl_fourier_bin(OUTFILE,covparams.outdir,ellmin,Ncl,m,k);  \n      }\n      k=k+1;\n    }\n  }\n  if (like.kk && like.pos_pos)\n  {\n    sprintf(OUTFILE,\"%s_kkll_cov_Ncl%d_Ntomo%d\",survey.name,Ncl,tomo.shear_Nbin);\n    for (m=0;m<tomo.clustering_Npowerspectra; m++){\n      if(k==hit) {\n        sprintf(filename,\"%s%s_%d\",covparams.outdir,OUTFILE,k);\n        // if (fopen(filename, \"r\") != NULL){exit(1);}\n        run_cov_kk_clustering_fourier_bin(OUTFILE,covparams.outdir,ellmin,Ncl,m,k);  \n      }\n      k=k+1;\n    }\n  }\n  if (like.kk && like.gk)\n  {\n    sprintf(OUTFILE,\"%s_kklk_cov_Ncl%d_Ntomo%d\",survey.name,Ncl,tomo.shear_Nbin);\n    for (m=0;m<tomo.clustering_Nbin; m++){\n      if(k==hit) {\n        sprintf(filename,\"%s%s_%d\",covparams.outdir,OUTFILE,k);\n        // if (fopen(filename, \"r\") != NULL){exit(1);}\n        run_cov_kk_gk_fourier_bin(OUTFILE,covparams.outdir,ellmin,Ncl,m,k);  \n      }\n      k=k+1;\n    }\n  }\n  if (like.kk && like.ks)\n  {\n    sprintf(OUTFILE,\"%s_kkks_cov_Ncl%d_Ntomo%d\",survey.name,Ncl,tomo.shear_Nbin);\n    for (m=0;m<tomo.shear_Nbin; m++){\n      if(k==hit) {\n        sprintf(filename,\"%s%s_%d\",covparams.outdir,OUTFILE,k);\n        // if (fopen(filename, \"r\") != NULL){exit(1);}\n        run_cov_kk_ks_fourier_bin(OUTFILE,covparams.outdir,ellmin,Ncl,m,k);  \n      }\n      k=k+1;\n    }\n  }\n  if (like.kk)\n  {\n    sprintf(OUTFILE,\"%s_kkkk_cov_Ncl%d_Ntomo%d\",survey.name,Ncl,tomo.shear_Nbin);\n    if(k==hit) {\n      sprintf(filename,\"%s%s_%d\",covparams.outdir,OUTFILE,k);\n      // if (fopen(filename, \"r\") != NULL){exit(1);}\n      run_cov_kk_kk_fourier_bin(OUTFILE,covparams.outdir,ellmin,Ncl,k);  \n    }\n    k=k+1;\n  }\n\n\n  printf(\"number of cov blocks for parallelization: %d\\n\",k-1); \n  printf(\"-----------------\\n\");\n  printf(\"PROGRAM EXECUTED\\n\");\n  printf(\"-----------------\\n\");\n  return 0;   \n}\n\n", "meta": {"hexsha": "11d9fb27cc98578126998edf86ed60a9ccc44b2d", "size": 14095, "ext": "c", "lang": "C", "max_stars_repo_path": "compute_covariances_fourier_binned.c", "max_stars_repo_name": "CosmoLike/LSSTxSO", "max_stars_repo_head_hexsha": "43dfce33112480e17878b2de3421775ec9df296c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "compute_covariances_fourier_binned.c", "max_issues_repo_name": "CosmoLike/LSSTxSO", "max_issues_repo_head_hexsha": "43dfce33112480e17878b2de3421775ec9df296c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "compute_covariances_fourier_binned.c", "max_forks_repo_name": "CosmoLike/LSSTxSO", "max_forks_repo_head_hexsha": "43dfce33112480e17878b2de3421775ec9df296c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.1647058824, "max_line_length": 272, "alphanum_fraction": 0.6179496275, "num_tokens": 4740, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4378235137849365, "lm_q2_score": 0.022629198797146935, "lm_q1q2_score": 0.00990759533150473}}
{"text": "// Copyright (C) 2022. Huawei Technologies Co., Ltd. All rights reserved.\n\n// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"),\n// to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,\n// and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\n// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE\n// WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n#ifndef COMMON_H\n#define COMMON_H\n\n#include <cmath>\n#include <optional>\n#include <yato/array_view.h>\n\n//#define CHECK_ASSERT\n\n#include <training/system/Errors.h>\n#include <training/system/Name.h>\n#include <training/system/TypeHalf.h>\n#include <training/system/Types.h>\n\n#include <map>\n#include <utility>\n\n#if defined(_BLAS) && !defined(_BLAS_ENHANCE)\nextern \"C\"\n{\n#include <cblas.h>\n}\n#else\n#ifndef OPENBLAS_CONST\n#define OPENBLAS_CONST const\n#endif\n\ntypedef enum CBLAS_TRANSPOSE\n{\n    CblasNoTrans = 111,\n    CblasTrans = 112,\n    CblasConjTrans = 113,\n    CblasConjNoTrans = 114\n} CBLAS_TRANSPOSE;\n\ntypedef enum CBLAS_UPLO\n{\n    CblasUpper = 121,\n    CblasLower = 122\n} CBLAS_UPLO;\n#endif\n\n#ifdef CHECK_ASSERT\n#define CHECK_NEAR ASSERT_NEAR\n#else\n#define CHECK_NEAR EXPECT_NEAR\n#endif\n\n#define RAUL_E 2.71828182845904523536        // e\n#define RAUL_LOG2E 1.44269504088896340736    // log2(e)\n#define RAUL_LOG10E 0.434294481903251827651  // log10(e)\n#define RAUL_LN2 0.693147180559945309417     // ln(2)\n#define RAUL_LN10 2.30258509299404568402     // ln(10)\n#define RAUL_PI 3.14159265358979323846       // pi\n#define RAUL_PI_2 1.57079632679489661923     // pi/2\n#define RAUL_PI_4 0.785398163397448309616    // pi/4\n#define RAUL_1_PI 0.318309886183790671538    // 1/pi\n#define RAUL_2_PI 0.636619772367581343076    // 2/pi\n#define RAUL_2_SQRTPI 1.12837916709551257390 // 2/sqrt(pi)\n#define RAUL_SQRT2_PI 0.79788456080286535588 // sqrt(2/pi)\n#define RAUL_SQRT2 1.41421356237309504880    // sqrt(2)\n#define RAUL_SQRT1_2 0.707106781186547524401 // 1/sqrt(2)\n\n#define GELU_CONST 0.044715\n\nnamespace raul\n{\n\nenum class Limit : int\n{\n    Left = 0,\n    Middle = 1,\n    Right = 2\n};\n\nenum class Dimension : int\n{\n    Default = -1,\n    Batch = 0,\n    Depth = 1,\n    Height = 2,\n    Width = 3\n};\n\n#if defined(_MSC_VER)\n#define INLINE __forceinline\n#else\n#define INLINE __attribute__((always_inline))\n#endif\n\ntemplate<typename Type>\nclass TensorImpl;\ntypedef TensorImpl<dtype> Tensor;\ntypedef TensorImpl<half> TensorFP16;\n\n#if defined(ANDROID)\n#define TOMMTYPE(var) static_cast<typename MM::type>(var)\n#else\n#define TOMMTYPE(var) castHelper<typename MM::type>::cast(var)\n#endif\n\nusing shape = yato::dimensionality<4U, size_t>;\n} // raul namespace\n\nnamespace raul\n{\n\nenum class NetworkMode\n{\n    Train = 0,\n    Test = 1,\n    TrainCheckpointed = 2\n};\n\nenum class CompressionMode\n{\n    NONE = -1,\n    FP16 = 0,\n    INT8 = 1\n};\n\nenum class CalculationMode\n{\n    DETERMINISTIC = 0,\n#if defined(_OPENMP)\n    FAST = 1,\n#endif\n};\n\n/**\n * @brief Hardware target platform\n *\n */\nenum class ExecutionTarget\n{\n    CPU = 0,\n    CPUFP16 = 1\n};\n\n/**\n * @brief Hardware target platform per layer\n *\n * \\note Might override execution target for workflow, useful for mixed precision\n */\nenum class LayerExecutionTarget\n{\n    Default = -1, // use same as ExecutionTarget\n    CPU = 0,      // from this point enums should be aligned with ExecutionTarget (due to LayerExecutionTarget = static_cast<ExecutionTarget>(enum))\n    CPUFP16 = 1\n};\n\n/**\n * @brief Memory allocation mode\n */\nenum class AllocationMode\n{\n    STANDARD,\n    POOL\n};\n\nenum class DeclarationType\n{\n    Tensor = 0,\n    Shape = 1,\n    //    Alias = 2\n};\n\nclass OpenclInitializer;\n\nclass Common\n{\n  public:\n\n    // generate vector of random index permutation of [0..n-1]\n    static void generate_permutation(size_t n, std::vector<size_t>& ind_vector, unsigned int seed = 0);\n\n    /*\n     * [cols x rows]\n     * A[k x m]\n     * B[n x k]\n     * C[n x m]\n     * https://software.intel.com/en-us/mkl-developer-reference-c-cblas-gemm\n     * C = alpha * A * B + beta * C\n     * bOffset - in elements (not bytes)\n     */\n    static void gemm(OPENBLAS_CONST CBLAS_TRANSPOSE transA,\n                     OPENBLAS_CONST CBLAS_TRANSPOSE transB,\n                     size_t m,\n                     size_t n,\n                     size_t k,\n                     OPENBLAS_CONST dtype alpha,\n                     OPENBLAS_CONST dtype* a,\n                     OPENBLAS_CONST dtype* b,\n                     OPENBLAS_CONST dtype beta,\n                     dtype* c);\n\n    static void gemm(OPENBLAS_CONST CBLAS_TRANSPOSE transA,\n                     OPENBLAS_CONST CBLAS_TRANSPOSE transB,\n                     size_t m,\n                     size_t n,\n                     size_t k,\n                     OPENBLAS_CONST dtype alpha,\n                     OPENBLAS_CONST half* a,\n                     OPENBLAS_CONST half* b,\n                     OPENBLAS_CONST dtype beta,\n                     half* c);\n\n    /**\n     * @brief : Basic Linear Algebra Subroutine y = y + ax\n     *\n     *  \\f[\n     *      \\vec{y} = \\vec{y} + \\alpha * \\vec{x},\n     *  \\f]\n     *\n     * @param n The number of elements in vectors x and y.\n     * @param sa The scalar alpha.\n     * @param sx The vector x of length n. Specified as: a one-dimensional array of (at least) length \\f$ 1+(n-1)|incx| \\f$.\n     * @param incx The stride for vector x. Specified as: an integer. It can have any value.\n     * @param sy The vector y of length n. Specified as: a one-dimensional array of (at least) length \\f$ 1+(n-1)|incy| \\f$.\n     * @param incy The stride for vector y.\n     * @param xOffset The offset for vector x.\n     * @param yOffset The offset for vector y.\n     * @return The vector y, containing the results of the computation.\n     */\n    static void axpy(size_t n, OPENBLAS_CONST dtype sa, OPENBLAS_CONST dtype* sx, size_t incx, dtype* sy, size_t incy, size_t xOffset = 0, size_t yOffset = 0);\n    static void axpy(size_t n, OPENBLAS_CONST dtype sa, OPENBLAS_CONST half* sx, size_t incx, half* sy, size_t incy, size_t xOffset = 0, size_t yOffset = 0);\n\n    /**\n     * @brief : Basic Linear Algebra Subroutine y = ax + by\n     *\n     *  \\f[\n     *      \\vec{y} = \\alpha \\vec{x} + \\beta \\vec{y},\n     *  \\f]\n     *\n     * @param n The number of elements in vectors x and y.\n     * @param alpha The scalar alpha.\n     * @param x The vector x of length n. Specified as: a one-dimensional array of (at least) length \\f$ 1+(n-1)|incx| \\f$.\n     * @param incx The stride for vector x. Specified as: an integer. It can have any value.\n     * @param beta The scalar beta.\n     * @param y The vector y of length n. Specified as: a one-dimensional array of (at least) length \\f$ 1+(n-1)|incy| \\f$.\n     * @param incy The stride for vector y.\n     * @param xOffset The offset for vector x.\n     * @param yOffset The offset for vector y.\n     * @return The vector y, containing the results of the computation.\n     */\n    static int axpby(OPENBLAS_CONST size_t n,\n                     OPENBLAS_CONST dtype alpha,\n                     OPENBLAS_CONST dtype* x,\n                     OPENBLAS_CONST size_t incx,\n                     OPENBLAS_CONST dtype beta,\n                     dtype* y,\n                     OPENBLAS_CONST size_t incy,\n                     size_t xOffset,\n                     size_t yOffset);\n\n    static int axpby(OPENBLAS_CONST size_t n,\n                     OPENBLAS_CONST dtype alpha,\n                     OPENBLAS_CONST half* x,\n                     OPENBLAS_CONST size_t incx,\n                     OPENBLAS_CONST dtype beta,\n                     half* y,\n                     OPENBLAS_CONST size_t incy,\n                     size_t xOffset,\n                     size_t yOffset);\n    /**\n     * @brief : Basic Linear Algebra Subroutine y = alpha * a * x + beta * y\n     *\n     * Vector by vector element wise multiplication\n     *\n     *  \\f[\n     *      \\vec{y} = \\alpha \\vec{a} \\vec{x} + \\beta \\vec{y},\n     *  \\f]\n     *\n     * @param n The number of elements in vectors x and y.\n     * @param alpha The scalar alpha.\n     * @param a The vector of length n.\n     * @param x The vector x of length n. Specified as: a one-dimensional array of (at least) length \\f$ 1+(n-1)|incx| \\f$.\n     * @param incx The stride for vector x. Specified as: an integer. It can have any value.\n     * @param beta The scalar beta.\n     * @param y The vector y of length n. Specified as: a one-dimensional array of (at least) length \\f$ 1+(n-1)|incy| \\f$.\n     * @param incy The stride for vector y.\n     */\n\n    static void hadamard(OPENBLAS_CONST size_t n,\n                         OPENBLAS_CONST dtype alpha,\n                         OPENBLAS_CONST dtype* a,\n                         OPENBLAS_CONST dtype* x,\n                         OPENBLAS_CONST size_t incx,\n                         OPENBLAS_CONST dtype beta,\n                         dtype* y,\n                         OPENBLAS_CONST size_t incy);\n\n    static dtype dot(size_t n, OPENBLAS_CONST dtype* sx, size_t incx, OPENBLAS_CONST dtype* sy, size_t incy);\n\n    static void scal(size_t n, OPENBLAS_CONST dtype sa, dtype* sx, size_t incx);\n\n    static void transpose(Tensor& tensor, size_t cols);\n    static void transpose(TensorFP16& tensor, size_t cols);\n\n    /*\n     * memory for dst should be allocated externaly\n     */\n    static void addPadding1D(const dtype* src, dtype* dst, size_t srcChannels, size_t srcSize, size_t dstSize, bool reversedOrder = false);\n    template<typename T>\n    static void addPadding2D(const T* src, T* dst, size_t srcChannels, size_t srcWidth, size_t srcHeight, size_t dstWidth, size_t dstHeight)\n    {\n        if ((dstWidth >= srcWidth) && (dstHeight >= srcHeight))\n        {\n            size_t padWidth = dstWidth - srcWidth;\n            size_t padHeight = dstHeight - srcHeight;\n\n            size_t leftPad = padWidth / 2;\n            // size_t rightPad = padWidth - leftPad;\n            size_t topPad = padHeight / 2;\n            size_t bottomPad = padHeight - topPad;\n\n            for (size_t d = 0; d < srcChannels; ++d)\n            {\n                // top\n                for (size_t y = 0; y < topPad; ++y)\n                {\n                    for (size_t x = 0; x < dstWidth; ++x)\n                    {\n                        dst[d * dstWidth * dstHeight + dstWidth * y + x] = static_cast<T>(0.0_dt);\n                    }\n                }\n\n                for (size_t y = topPad; y < topPad + srcHeight; ++y)\n                {\n                    // left\n                    for (size_t x = 0; x < leftPad; ++x)\n                    {\n                        dst[d * dstWidth * dstHeight + dstWidth * y + x] = static_cast<T>(0.0_dt);\n                    }\n\n                    // src\n                    for (size_t x = leftPad; x < leftPad + srcWidth; ++x)\n                    {\n                        dst[d * dstWidth * dstHeight + dstWidth * y + x] = src[d * srcWidth * srcHeight + srcWidth * (y - topPad) + x - leftPad];\n                    }\n\n                    // right\n                    for (size_t x = leftPad + srcWidth; x < dstWidth; ++x)\n                    {\n                        dst[d * dstWidth * dstHeight + dstWidth * y + x] = static_cast<T>(0.0_dt);\n                    }\n                }\n\n                // bottom\n                for (size_t y = dstHeight - bottomPad; y < dstHeight; ++y)\n                {\n                    for (size_t x = 0; x < dstWidth; ++x)\n                    {\n                        dst[d * dstWidth * dstHeight + dstWidth * y + x] = static_cast<T>(0.0_dt);\n                    }\n                }\n            }\n        }\n    }\n\n    /*\n     * memory for dst should be allocated externaly\n     */\n    static void removePadding1D(const dtype* src, dtype* dst, size_t srcChannels, size_t srcSize, size_t dstSize, bool reversedOrder = false, bool overwrite = true);\n    template<typename T>\n    static void removePadding2D(const T* src, T* dst, size_t srcChannels, size_t srcWidth, size_t srcHeight, size_t dstWidth, size_t dstHeight, bool overwrite = true)\n    {\n        if ((dstWidth <= srcWidth) && (dstHeight <= srcHeight))\n        {\n            size_t padWidth = srcWidth - dstWidth;\n            size_t padHeight = srcHeight - dstHeight;\n\n            size_t leftPad = padWidth / 2;\n            // size_t rightPad = padWidth - leftPad;\n            size_t topPad = padHeight / 2;\n            // size_t bottomPad = padHeight - topPad;\n\n            if (overwrite)\n            {\n                for (size_t d = 0; d < srcChannels; ++d)\n                {\n                    for (size_t y = 0; y < dstHeight; ++y)\n                    {\n                        for (size_t x = 0; x < dstWidth; ++x)\n                        {\n                            dst[d * dstWidth * dstHeight + dstWidth * y + x] = src[d * srcWidth * srcHeight + srcWidth * (y + topPad) + x + leftPad];\n                        }\n                    }\n                }\n            }\n            else\n            {\n                for (size_t d = 0; d < srcChannels; ++d)\n                {\n                    for (size_t y = 0; y < dstHeight; ++y)\n                    {\n                        for (size_t x = 0; x < dstWidth; ++x)\n                        {\n                            dst[d * dstWidth * dstHeight + dstWidth * y + x] += src[d * srcWidth * srcHeight + srcWidth * (y + topPad) + x + leftPad];\n                        }\n                    }\n                }\n            }\n        }\n    }\n\n    /*\n     * paddingWidth, paddingHeight - zero padding added for both sides of the input\n     * memory for matrix should be allocated externaly\n     */\n    template<typename T>\n    static void im2col(const T* image,\n                       size_t imageWidth,\n                       size_t imageHeight,\n                       size_t imageChannels,\n                       size_t filterWidth,\n                       size_t filterHeight,\n                       size_t strideWidth,\n                       size_t strideHeight,\n                       size_t paddingWidth,\n                       size_t paddingHeight,\n                       T* matrix,\n                       bool reversedOrder = false);\n\n    static size_t im2colOutputSize(size_t imageWidth,\n                                   size_t imageHeight,\n                                   size_t imageChannels,\n                                   size_t filterWidth,\n                                   size_t filterHeight,\n                                   size_t strideWidth,\n                                   size_t strideHeight,\n                                   size_t paddingWidth,\n                                   size_t paddingHeight,\n                                   size_t dilationWidth,\n                                   size_t dilationHeight);\n\n    /*\n     * paddingWidth, paddingHeight - zero padding added for both sides of the input\n     * memory for image should be allocated externaly\n     */\n    template<typename T>\n    static void col2im(const T* matrix,\n                       size_t imageWidth,\n                       size_t imageHeight,\n                       size_t imageChannels,\n                       size_t filterWidth,\n                       size_t filterHeight,\n                       size_t strideWidth,\n                       size_t strideHeight,\n                       size_t paddingWidth,\n                       size_t paddingHeight,\n                       T* image,\n                       bool reversedOrder = false,\n                       bool zeroOutput = true);\n\n    /*\n     * Rectified Linear Unit\n     */\n    template<typename T>\n    static T ReLU(T x)\n    {\n        return std::max(static_cast<T>(0), x);\n    }\n    template<typename T>\n    static T ReLU6(T x)\n    {\n        return std::min(std::max(static_cast<T>(0), x), static_cast<T>(6.0_dt));\n    }\n\n    template<typename T>\n    static void ReLU(const T& in, T& out)\n    {\n        std::transform(in.begin(), in.end(), out.begin(), [&](typename T::type val) -> typename T::type { return ReLU(val); });\n    }\n\n    template<typename T>\n    static void ReLU6(const T& in, T& out)\n    {\n        std::transform(in.begin(), in.end(), out.begin(), [&](typename T::type val) -> typename T::type { return ReLU6(val); });\n    }\n\n    template<typename T>\n    static void ReLUBackward(const T& out, const T& delta, T& prevDelta)\n    {\n#if defined(_OPENMP)\n#pragma omp parallel for\n#endif\n        for (size_t q = 0; q < prevDelta.size(); ++q)\n        {\n            prevDelta[q] += (out[q] > static_cast<typename T::type>(0)) ? delta[q] : static_cast<typename T::type>(0);\n        }\n    }\n\n    template<typename T>\n    static void ReLU6Backward(const T& out, const T& delta, T& prevDelta)\n    {\n#if defined(_OPENMP)\n#pragma omp parallel for\n#endif\n        for (size_t q = 0; q < prevDelta.size(); ++q)\n        {\n            prevDelta[q] += (out[q] > static_cast<typename T::type>(0) && out[q] < static_cast<typename T::type>(6.0f)) ? delta[q] : static_cast<typename T::type>(0);\n        }\n    }\n\n    /*\n     * Gaussian error linear unit\n     * @see https://arxiv.org/abs/1606.08415\n     */\n    static dtype GeLU_Erf(dtype x);\n    static dtype GeLU_Tanh(dtype x);\n\n    /*\n     * Hard Sigmoid\n     */\n    template<typename T>\n    static T HSigmoid(T x)\n    {\n        return static_cast<T>(ReLU6(TODTYPE(x) + 3.0_dt) / 6.0_dt);\n    }\n\n    /*\n     * Hard Swish\n     */\n    template<typename T>\n    static T HSwish(T x)\n    {\n        return x * HSigmoid(x);\n    }\n    static dtype sign(dtype x) { return TODTYPE((0.0_dt < x) - (x < 0.0_dt)); }\n\n    template<typename T, typename U>\n    static void copyView(const T& view_from, U& view_to, const bool overwrite = false)\n    {\n        auto retLhs = [](typename T::value_type& lhs, [[maybe_unused]] typename T::value_type& rhs) { return lhs; };\n\n        auto copyViewImpl = [](const T& view_from, U& view_to, auto&& func)\n        {\n            for (size_t i1 = 0; i1 < view_from.size(0); ++i1)\n            {\n                for (size_t i2 = 0; i2 < view_from.size(1); ++i2)\n                {\n                    for (size_t i3 = 0; i3 < view_from.size(2); ++i3)\n                    {\n                        for (size_t i4 = 0; i4 < view_from.size(3); ++i4)\n                        {\n                            view_to[i1][i2][i3][i4] = func(view_from[i1][i2][i3][i4], view_to[i1][i2][i3][i4]);\n                        }\n                    }\n                }\n            }\n        };\n\n        if (overwrite)\n        {\n            copyViewImpl(view_from, view_to, retLhs);\n        }\n        else\n        {\n            copyViewImpl(view_from, view_to, std::plus<typename T::value_type>());\n        }\n    }\n\n    template<typename T>\n    static void unpack4D(const T& src, T& dst, Dimension dir, size_t index, const Name& layerType, const Name& layerName, bool overwrite)\n    {\n        auto input4d = src.get4DView();\n        auto inputDims = yato::dims(src.getDepth(), src.getHeight(), src.getWidth());\n\n        auto outputDims = dst.getShape();\n\n        const typename T::type* startEl = nullptr;\n        switch (dir)\n        {\n            case Dimension::Depth:\n                startEl = &input4d[0][index][0][0];\n                break;\n            case Dimension::Height:\n                startEl = &input4d[0][0][index][0];\n                break;\n            default:\n                throw std::runtime_error(layerType + \"[\" + layerName + \"]: unpack4D unknown dim\");\n        }\n\n        auto srcView = yato::array_view_4d<const typename T::type>(startEl, outputDims, inputDims);\n        auto outputView = dst.get4DView();\n        Common::copyView(srcView, outputView, overwrite);\n    }\n\n    template<typename T>\n    static void pack4D(const T& src, T& dst, Dimension dir, size_t index, const Name& layerType, const Name& layerName, bool overwrite)\n    {\n        auto output4d = dst.get4DView();\n\n        yato::dimensionality<3U, size_t> concatDims(dst.getDepth(), dst.getHeight(), dst.getWidth());\n\n        auto srcView = src.get4DView();\n        typename T::type* startEl = nullptr;\n        switch (dir)\n        {\n            case Dimension::Depth:\n                startEl = &output4d[0][index][0][0];\n                break;\n            case Dimension::Height:\n                startEl = &output4d[0][0][index][0];\n                break;\n            default:\n                throw std::runtime_error(layerType + \"[\" + layerName + \"]: pack4D unknown dim\");\n        }\n\n        auto dstView = yato::array_view_4d<typename T::type>(startEl, src.getShape(), concatDims);\n        Common::copyView(srcView, dstView, overwrite);\n    }\n\n    /*\n     * Upper triangle of a rectangular array\n     */\n    template<typename T>\n    static void triu(T* data, size_t nrows, size_t ncols, int diag = 0)\n    {\n        size_t i = 0;\n        int cols = (int)ncols;\n        int rows = (int)nrows;\n        for (int r = 0; r < rows; ++r)\n        {\n            for (int c = 0; c < cols; ++c, ++i)\n            {\n                if (c - r - diag < 0)\n                {\n                    data[i] = static_cast<T>(0);\n                }\n            }\n        }\n    }\n\n    /*\n     * Applies a 1D convolution over an input signal composed of several input planes.\n     * Supports 2 modes:\n     *  1. PyTorch style: Input[N, C, 1, L1] (or [N, 1, C, L1]) -> Output[N, FILTERS, 1, L2] (or [N, 1, FILTERS, L2])\n     *  2. TensorFlow style: Input[N, L1, 1, C] (or [N, 1, L1, C]) -> Output[N, L2, 1, FILTERS] (or [N, 1, L2, FILTERS])\n     * Output is not zeroed prior to convolution (operator += is used)\n     */\n    static void conv1d(const dtype* input,\n                       dtype* output,\n                       const dtype* kernel,\n                       const dtype* bias,\n                       size_t batchSize,\n                       size_t inputSize,\n                       size_t inputChannels,\n                       size_t outputSize,\n                       size_t outputChannels,\n                       size_t kernelSize,\n                       size_t padding,\n                       size_t stride,\n                       size_t dilation = 1U,\n                       size_t groups = 1U,\n                       bool tfStyle = false);\n\n    /*\n     * Applies 2D convolution over input tensor, all channels convolved\n     * Output is not zeroed prior to convolution (operator += is used)\n     */\n    template<typename T>\n    static void conv2d(const T* input,\n                       T* output,\n                       const T* kernel,\n                       const T* bias,\n                       size_t batchSize,\n                       size_t inputWidth,\n                       size_t inputHeight,\n                       size_t inputChannels,\n                       size_t outputWidth,\n                       size_t outputHeight,\n                       size_t outputChannels,\n                       size_t kernelWidth,\n                       size_t kernelHeight,\n                       size_t paddingW,\n                       size_t paddingH,\n                       size_t strideW,\n                       size_t strideH,\n                       size_t dilationW = 1U,\n                       size_t dilationH = 1U,\n                       size_t groups = 1U)\n    {\n        auto inputs3D = yato::array_view_3d<T>(const_cast<T*>(input), yato::dims(batchSize, inputChannels, inputHeight * inputWidth));\n        auto outputs3D = yato::array_view_3d<T>(output, yato::dims(batchSize, outputChannels, outputHeight * outputWidth));\n        auto kernelsWeights4D = yato::array_view_4d<T>(const_cast<T*>(kernel), yato::dims(outputChannels, inputChannels / groups, kernelHeight, kernelWidth));\n\n        for (size_t q = 0; q < batchSize; ++q)\n        {\n            for (size_t d = 0; d < outputChannels; ++d)\n            {\n                std::fill(outputs3D[q][d].begin(), outputs3D[q][d].end(), static_cast<T>(0.0_dt));\n            }\n\n            size_t inputWidthPadded = inputWidth + 2 * paddingW;\n            size_t inputHeightPadded = inputHeight + 2 * paddingH;\n\n            std::vector<T> inputPadded(inputChannels * inputHeightPadded * inputWidthPadded);\n\n            Common::addPadding2D(&inputs3D[q][0][0], inputPadded.data(), inputChannels, inputWidth, inputHeight, inputWidthPadded, inputHeightPadded);\n\n            auto inputPadded2D = yato::view(inputPadded).reshape(yato::dims(inputChannels, inputHeightPadded * inputWidthPadded));\n\n            for (size_t group = 0; group < groups; ++group)\n            {\n                for (size_t kernelIndex = 0; kernelIndex < outputChannels / groups; ++kernelIndex)\n                {\n                    for (size_t d = 0; d < inputChannels / groups; ++d)\n                    {\n                        for (size_t oy = 0; oy < outputHeight; ++oy)\n                        {\n                            for (size_t ox = 0; ox < outputWidth; ++ox)\n                            {\n                                for (size_t ky = 0; ky < kernelHeight; ++ky)\n                                {\n                                    for (size_t kx = 0; kx < kernelWidth; ++kx)\n                                    {\n                                        outputs3D[q][kernelIndex + group * outputChannels / groups][oy * outputWidth + ox] +=\n                                            kernelsWeights4D[kernelIndex + group * outputChannels / groups][d][ky][kx] *\n                                            inputPadded2D[d + group * inputChannels / groups][oy * inputWidthPadded * strideH + ky * dilationH * inputWidthPadded + ox * strideW + kx * dilationW];\n                                    }\n                                }\n                            }\n                        }\n                    }\n                }\n            }\n        }\n\n        if (bias)\n        {\n            for (size_t q = 0; q < batchSize; ++q)\n            {\n                for (size_t kernelIndex = 0; kernelIndex < outputChannels; ++kernelIndex)\n                {\n                    for (size_t oy = 0; oy < outputHeight; ++oy)\n                    {\n                        for (size_t ox = 0; ox < outputWidth; ++ox)\n                        {\n                            outputs3D[q][kernelIndex][oy * outputWidth + ox] += bias[kernelIndex];\n                        }\n                    }\n                }\n            }\n        }\n    }\n\n    template<typename T = dtype, typename Iterator>\n    static void arange(Iterator begin, Iterator end, T start = static_cast<T>(0), T step = static_cast<T>(1))\n    {\n        auto val = start;\n        for (auto p = begin; p != end; ++p)\n        {\n            *p = static_cast<std::remove_reference_t<decltype(*p)>>(val);\n            val += step;\n        }\n    }\n\n    template<typename T = dtype, typename Iterable>\n    static void arange(Iterable& i, T start = static_cast<T>(0), T step = static_cast<T>(1))\n    {\n        return arange(i.begin(), i.end(), start, step);\n    }\n\n    static void replaceAll(std::string& str, const std::string& srcSubstr, const std::string& tgtSubstr)\n    {\n        size_t start_pos = 0;\n        while ((start_pos = str.find(srcSubstr, start_pos)) != std::string::npos)\n        {\n            str.replace(start_pos, srcSubstr.length(), tgtSubstr);\n            start_pos += tgtSubstr.length(); // srcSubstr could be a substring of tgtSubstr\n        }\n    }\n\n    static bool startsWith(const std::string& str, const std::string& srcSubstr) { return (str.rfind(srcSubstr, 0) == 0); }\n\n    static std::vector<std::string> split(const std::string& string, char delimeter);\n\n    /*\n     * @see https://docs.scipy.org/doc/numpy-1.13.0/user/basics.broadcasting.html\n     */\n    template<typename T>\n    static bool shapeIsBroadcastable(const T& from, const T& to)\n    {\n        const auto n = to.dimensions_num();\n        for (size_t i = 0; i < n; ++i)\n        {\n            if (from[i] != to[i] && from[i] != 1U && to[i] != 1U)\n            {\n                return false;\n            }\n        }\n        return true;\n    }\n\n    static bool endsWith(std::string const& value, std::string const& ending)\n    {\n        if (ending.size() > value.size())\n        {\n            return false;\n        }\n        return std::equal(ending.rbegin(), ending.rend(), value.rbegin());\n    }\n\n    static shape getStrides(const shape& tensor_shape);\n\n    static shape offsetToIndexes(size_t offset, const shape& strides);\n\n    static size_t indexesToOffset(const shape& indexes, const shape& strides);\n};\n\ntemplate<class T>\nbool if_equals(const std::string&& error, const T val1, const T val2)\n{\n    if (val1 != val2)\n    {\n        throw(std::runtime_error(error));\n    }\n    return val1 == val2;\n}\n\n} // raul namespace\n\n#endif // COMMON_H\n", "meta": {"hexsha": "7afdb9731074bcdc6461c9829d2e1a3060d1bee4", "size": 29303, "ext": "h", "lang": "C", "max_stars_repo_path": "training/src/compiler/training/base/common/Common.h", "max_stars_repo_name": "steelONIONknight/bolt", "max_stars_repo_head_hexsha": "9bd3d08f2abb14435ca3ad0179889e48fa7e9b47", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "training/src/compiler/training/base/common/Common.h", "max_issues_repo_name": "steelONIONknight/bolt", "max_issues_repo_head_hexsha": "9bd3d08f2abb14435ca3ad0179889e48fa7e9b47", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "training/src/compiler/training/base/common/Common.h", "max_forks_repo_name": "steelONIONknight/bolt", "max_forks_repo_head_hexsha": "9bd3d08f2abb14435ca3ad0179889e48fa7e9b47", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.926102503, "max_line_length": 195, "alphanum_fraction": 0.533324233, "num_tokens": 7228, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.24220562872535947, "lm_q2_score": 0.04023794219201673, "lm_q1q2_score": 0.00974585608723208}}
{"text": "#include \"../include/paralleltt.h\"\n\n#include <stdio.h>\n#include <stdlib.h>\n#include <cblas.h>\n#include <lapacke.h>\n#include <time.h>\n\nflattening_info* flattening_info_init(const MPI_tensor* ten, int flattening, int iscol, int t_v_block)\n{\n    // Tensor info\n    flattening_info* fi = (flattening_info*) malloc(sizeof(flattening_info));\n    int t_d = ten->d;\n\n    int* t_nps = (int*) malloc(t_d*sizeof(int));\n    int t_Nblocks = 1;\n    for (int ii = 0; ii < t_d; ++ii){\n        t_nps[ii] = ten->nps[ii];\n        t_Nblocks = t_Nblocks * t_nps[ii];\n    }\n\n    int* t_t_block = (int*) malloc(t_d*sizeof(int));\n    to_tensor_ind(t_t_block, t_v_block, t_nps, t_d);\n\n    long t_N = 1;\n    int* t_t_sizes = (int*) malloc(t_d*sizeof(int));\n    int* t_t_index = (int*) malloc(t_d*sizeof(int));\n    for (int ii = 0; ii < t_d; ++ii){\n        int* partition_ii = ten->partitions[ii];\n        t_t_index[ii] = partition_ii[t_t_block[ii]];\n        t_t_sizes[ii] = partition_ii[t_t_block[ii]+1] - t_t_index[ii];\n        t_N = t_N * t_t_sizes[ii];\n    }\n\n    // Flattening info\n    int f_d = (iscol) ? flattening : t_d-flattening;\n\n    int offset = (iscol) ? 0 : flattening;\n    long f_N = 1;\n    int f_Nblocks = 1;\n    int* f_nps     = (int*) malloc(f_d * sizeof(int));\n    int* f_t_block = (int*) malloc(f_d * sizeof(int));\n    int* f_t_index = (int*) malloc(f_d * sizeof(int));\n    int* f_t_sizes = (int*) malloc(f_d * sizeof(int));\n    for (int ii = 0; ii < f_d; ++ii){\n        f_nps[ii]     = t_nps[ii+offset];\n        f_t_block[ii] = t_t_block[ii+offset];\n        f_t_index[ii] = t_t_index[ii+offset];\n        f_t_sizes[ii] = t_t_sizes[ii+offset];\n        f_N = f_N * f_t_sizes[ii];\n        f_Nblocks = f_Nblocks * f_nps[ii];\n    }\n    int f_v_block = to_vec_ind(f_t_block, f_nps, f_d);\n\n    // Sketching dimensions info\n    int s_d = t_d - f_d;\n    long s_N = 1;\n\n    offset = (iscol) ? flattening : 0;\n    int* s_nps     = (int*) malloc(s_d * sizeof(int));\n    int* s_t_index = (int*) malloc(s_d * sizeof(int));\n    int* s_t_sizes = (int*) malloc(s_d * sizeof(int));\n    for (int ii = 0; ii < s_d; ++ii){\n        s_nps[ii]     = t_nps[ii+offset];\n        s_t_index[ii] = t_t_index[ii+offset];\n        s_t_sizes[ii] = t_t_sizes[ii+offset];\n        s_N = s_N * s_t_sizes[ii];\n    }\n\n    // Assigning\n    fi->t_d       = t_d;\n    fi->t_N       = t_N;\n    fi->t_Nblocks = t_Nblocks;\n    fi->t_nps     = t_nps;\n    fi->t_v_block = t_v_block;\n    fi->t_t_block = t_t_block;\n    fi->t_t_index = t_t_index;\n    fi->t_t_sizes = t_t_sizes;\n\n    fi->flattening = flattening;\n    fi->iscol      = iscol;\n    fi->f_d        = f_d;\n    fi->f_N        = f_N;\n    fi->f_Nblocks  = f_Nblocks;\n    fi->f_nps      = f_nps;\n    fi->f_v_block  = f_v_block;\n    fi->f_t_block  = f_t_block;\n    fi->f_t_index  = f_t_index;\n    fi->f_t_sizes  = f_t_sizes;\n\n    fi->s_d       = s_d;\n    fi->s_N       = s_N;\n    fi->s_nps     = s_nps;\n    fi->s_t_index = s_t_index;\n    fi->s_t_sizes = s_t_sizes;\n\n    return fi;\n}\n\nvoid flattening_info_free(flattening_info* fi)\n{\n    free(fi->t_nps);     fi->t_nps = NULL;\n    free(fi->t_t_block); fi->t_t_block = NULL;\n    free(fi->t_t_index); fi->t_t_index = NULL;\n    free(fi->t_t_sizes); fi->t_t_sizes = NULL;\n    free(fi->f_nps);     fi->f_nps = NULL;\n    free(fi->f_t_block); fi->f_t_block = NULL;\n    free(fi->f_t_index); fi->f_t_index = NULL;\n    free(fi->f_t_sizes); fi->f_t_sizes = NULL;\n    free(fi->s_nps);     fi->s_nps = NULL;\n    free(fi->s_t_index); fi->s_t_index = NULL;\n    free(fi->s_t_sizes); fi->s_t_sizes = NULL;\n\n    free(fi);\n}\n\nvoid flattening_info_update(flattening_info* fi, const MPI_tensor* ten, int t_v_block)\n{\n    // Tensor info\n    int t_d = ten->d;\n    int* t_nps = fi->t_nps;\n    int* t_t_block = fi->t_t_block;\n    to_tensor_ind(t_t_block, t_v_block, t_nps, t_d);\n\n    long t_N = 1;\n    int* t_t_sizes = fi->t_t_sizes;\n    int* t_t_index = fi->t_t_index;\n    for (int ii = 0; ii < t_d; ++ii){\n        int* partition_ii = ten->partitions[ii];\n        t_t_index[ii] = partition_ii[t_t_block[ii]];\n        t_t_sizes[ii] = partition_ii[t_t_block[ii]+1] - t_t_index[ii];\n        t_N = t_N * t_t_sizes[ii];\n    }\n\n    // Flattening info\n    int flattening = fi->flattening;\n    int iscol = fi->iscol;\n    int f_d = fi->f_d;\n\n    int offset = (iscol) ? 0 : flattening;\n    long f_N = 1;\n    int* f_nps     = fi->f_nps;\n    int* f_t_block = fi->f_t_block;\n    int* f_t_index = fi->f_t_index;\n    int* f_t_sizes = fi->f_t_sizes;\n    for (int ii = 0; ii < f_d; ++ii){\n        f_nps[ii]     = t_nps[ii+offset];\n        f_t_block[ii] = t_t_block[ii+offset];\n        f_t_index[ii] = t_t_index[ii+offset];\n        f_t_sizes[ii] = t_t_sizes[ii+offset];\n        f_N = f_N * f_t_sizes[ii];\n    }\n    int f_v_block = to_vec_ind(f_t_block, f_nps, f_d);\n\n    // Sketching dimensions info\n    int s_d = fi->s_d;\n    long s_N = 1;\n\n    offset = (iscol) ? flattening : 0;\n    int* s_nps     = fi->s_nps;\n    int* s_t_index = fi->s_t_index;\n    int* s_t_sizes = fi->s_t_sizes;\n    for (int ii = 0; ii < s_d; ++ii){\n        s_nps[ii]     = t_nps[ii+offset];\n        s_t_index[ii] = t_t_index[ii+offset];\n        s_t_sizes[ii] = t_t_sizes[ii+offset];\n        s_N = s_N * s_t_sizes[ii];\n    }\n\n    // Assigning\n    fi->t_d = t_d;\n    fi->t_N = t_N;\n    fi->t_nps = t_nps;\n    fi->t_v_block = t_v_block;\n    fi->t_t_block = t_t_block;\n    fi->t_t_index = t_t_index;\n    fi->t_t_sizes = t_t_sizes;\n\n    fi->flattening = flattening;\n    fi->iscol = iscol;\n    fi->f_d = f_d;\n    fi->f_N       = f_N;\n    fi->f_nps     = f_nps;\n    fi->f_v_block = f_v_block;\n    fi->f_t_block = f_t_block;\n    fi->f_t_index = f_t_index;\n    fi->f_t_sizes = f_t_sizes;\n\n    fi->s_d = s_d;\n    fi->s_N = s_N;\n    fi->s_nps = s_nps;\n    fi->s_t_index = s_t_index;\n    fi->s_t_sizes = s_t_sizes;\n}\n\nvoid flattening_info_f_update(flattening_info* fi, const MPI_tensor* ten, int f_v_block)\n{\n    // tensor info\n    int t_d = fi->t_d;\n\n    long t_N = -1;\n    int t_v_block = -1;\n    int* t_t_block = fi->t_t_block;\n    int* t_t_index = fi->t_t_index;\n    int* t_t_sizes = fi->t_t_sizes;\n    for (int ii = 0; ii < t_d; ++ii){\n        t_t_block[ii] = -1;\n        t_t_index[ii] = 0;\n        t_t_sizes[ii] = 0;\n    }\n    fi->t_N = t_N;\n    fi->t_v_block = t_v_block;\n\n    // flattening info\n    int flattening = fi->flattening;\n    int iscol = fi->iscol;\n    int f_d = fi->f_d;\n    int f_Nblocks = fi->f_Nblocks;\n    int* f_nps = fi->f_nps;\n\n    int* f_t_block = fi->f_t_block;\n    to_tensor_ind(f_t_block, (long) f_v_block, f_nps, f_d);\n\n    long f_N = 1;\n    int* f_t_index = fi->f_t_index;\n    int* f_t_sizes = fi->f_t_sizes;\n    int offset = (iscol) ? 0 : flattening;\n    for (int ii = 0; ii < f_d; ++ii){\n        int* partition_ii = ten->partitions[ii + offset];\n        f_t_index[ii] = partition_ii[f_t_block[ii]];\n        f_t_sizes[ii] = partition_ii[f_t_block[ii]+1] - f_t_index[ii];\n        f_N = f_N * f_t_sizes[ii];\n    }\n    fi->f_N = f_N;\n    fi->f_v_block = f_v_block;\n\n    // Sketching dimensions info\n    int s_d = fi->s_d;\n    long s_N = 0;\n\n    int* s_t_index = fi->s_t_index;\n    int* s_t_sizes = fi->s_t_sizes;\n\n    for (int ii = 0; ii < s_d; ++ii){\n        s_t_index[ii] = 0;\n        s_t_sizes[ii] = 0;\n    }\n    fi->s_N = s_N;\n}\n\nvoid flattening_info_print(flattening_info* fi)\n{\n    printf(\"\\n~~~~~~~~~~~~~~~ Flattening Info ~~~~~~~~~~~~~~~\\n\");\n    int t_d = fi->t_d;\n    printf(\"t_d = %d\\n\", t_d);\n\n    printf(\"t_N = %ld\\n\", fi->t_N);\n\n    printf(\"t_Nblocks = %d\\n\", fi->t_Nblocks);\n\n    if (t_d>0){\n        printf(\"t_nps = [%d\", fi->t_nps[0]);\n        for (int ii = 1; ii < t_d; ++ii){printf(\", %d\", fi->t_nps[ii]); }\n        printf(\"]\\n\");\n    }\n    else{ printf(\"t_nps = []\\n\"); }\n\n    printf(\"t_v_block = %d\\n\", fi->t_v_block);\n\n    if (t_d>0){\n        printf(\"t_t_block = [%d\", fi->t_t_block[0]);\n        for (int ii = 1; ii < t_d; ++ii){printf(\", %d\", fi->t_t_block[ii]);}\n        printf(\"]\\n\");\n    }\n    else{ printf(\"t_t_block = []\\n\"); }\n\n    if (t_d>0){\n        printf(\"t_t_index = [%d\", fi->t_t_index[0]);\n        for (int ii = 1; ii < t_d; ++ii){printf(\", %d\", fi->t_t_index[ii]);}\n        printf(\"]\\n\");\n    }\n    else{ printf(\"t_t_index = []\\n\"); }\n\n    if (t_d>0){\n        printf(\"t_t_sizes = [%d\", fi->t_t_sizes[0]);\n        for (int ii = 1; ii < t_d; ++ii){printf(\", %d\", fi->t_t_sizes[ii]);}\n        printf(\"]\\n\");\n    }\n    else{ printf(\"t_t_sizes = []\\n\"); }\n\n    printf(\"flattening = %d\\n\", fi->flattening);\n\n    printf(\"iscol = %d\\n\", fi->iscol);\n\n    int f_d = fi->f_d;\n    printf(\"f_d = %d\\n\", f_d);\n\n    printf(\"f_N = %ld\\n\", fi->f_N);\n\n    printf(\"f_Nblocks = %d\\n\", fi->f_Nblocks);\n\n    if (f_d>0){\n        printf(\"f_nps = [%d\", fi->f_nps[0]);\n        for (int ii = 1; ii < f_d; ++ii){printf(\", %d\", fi->f_nps[ii]);}\n        printf(\"]\\n\");\n    }\n    else{ printf(\"f_nps = []\\n\"); }\n\n    printf(\"f_v_block = %d\\n\", fi->f_v_block);\n\n    if (f_d>0){\n        printf(\"f_t_block = [%d\", fi->f_t_block[0]);\n        for (int ii = 1; ii < f_d; ++ii){printf(\", %d\", fi->f_t_block[ii]);}\n        printf(\"]\\n\");\n    }\n    else{ printf(\"f_t_block = []\\n\"); }\n\n    if (f_d>0){\n        printf(\"f_t_index = [%d\", fi->f_t_index[0]);\n        for (int ii = 1; ii < f_d; ++ii){printf(\", %d\", fi->f_t_index[ii]);}\n        printf(\"]\\n\");\n    }\n    else{ printf(\"f_t_index = []\\n\"); }\n\n    if (f_d>0){\n        printf(\"f_t_sizes = [%d\", fi->f_t_sizes[0]);\n        for (int ii = 1; ii < f_d; ++ii){printf(\", %d\", fi->f_t_sizes[ii]);}\n        printf(\"]\\n\");\n    }\n    else{ printf(\"f_t_sizes = []\\n\"); }\n\n    int s_d = fi->s_d;\n    printf(\"s_d = %d\\n\", s_d);\n\n    printf(\"s_N = %ld\\n\", fi->s_N);\n\n    if (s_d>0){\n        printf(\"s_nps = [%d\", fi->s_nps[0]);\n        for (int ii = 1; ii < s_d; ++ii){printf(\", %d\", fi->s_nps[ii]);}\n        printf(\"]\\n\");\n    }\n    else{ printf(\"s_nps = []\\n\"); }\n\n    if (s_d>0){\n        printf(\"s_t_index = [%d\", fi->s_t_index[0]);\n        for (int ii = 1; ii < s_d; ++ii){printf(\", %d\", fi->s_t_index[ii]);}\n        printf(\"]\\n\");\n    }\n    else{ printf(\"s_t_index = []\\n\"); }\n\n\n    if (s_d>0){\n        printf(\"s_t_sizes = [%d\", fi->s_t_sizes[0]);\n        for (int ii = 1; ii < s_d; ++ii){printf(\", %d\", fi->s_t_sizes[ii]);}\n        printf(\"]\\n\");\n    }\n    else{ printf(\"s_t_sizes = []\\n\"); }\n    printf(\"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\n\\n\");\n}\n\n\nint* get_sketch_owners(MPI_tensor* ten, int flattening, int iscol)\n{\n    int np_flattening = 1;\n    int* nps = ten->nps;\n    int ii0 = (iscol) ? 0 : flattening;\n    int ii1 = (iscol) ? flattening : ten->d;\n\n    for (int ii = ii0; ii < ii1; ++ii){\n        np_flattening = np_flattening * nps[ii];\n    }\n\n    int* owners = get_partition(ten->comm_size, np_flattening);\n    return owners;\n}\n\nvoid get_sketch_height(MPI_tensor* ten, int* owners, int flattening, int iscol, long* X_height_ptr, long* buf_height_ptr)\n{\n    *X_height_ptr = 0;\n    *buf_height_ptr = 0;\n\n    flattening_info* fi = flattening_info_init(ten, flattening, iscol, 0);\n\n    for (int rank = 0; rank < ten->comm_size; ++rank){\n        long X_height_tmp = 0;\n        for (int jj = owners[rank]; jj < owners[rank + 1]; ++jj){\n            flattening_info_f_update(fi, ten, jj);\n            X_height_tmp = X_height_tmp + fi->f_N;\n            *buf_height_ptr = (fi->f_N > *buf_height_ptr) ? fi->f_N : *buf_height_ptr;\n        }\n\n        *X_height_ptr = (X_height_tmp > *X_height_ptr) ? X_height_tmp : *X_height_ptr;\n    }\n\n    flattening_info_free(fi);\n}\n\nmatrix_tt** get_sketch_Omega(const MPI_tensor* ten, int flattening, int r, int buf, int iscol)\n{\n    // Seed random numbers\n    double t = (double) time(NULL);\n    MPI_Bcast(&t, 1, MPI_DOUBLE, 0, ten->comm);\n    srand((unsigned long) t);\n\n    int ii0 = iscol ? flattening : 0;\n    int n_Omega = iscol ? (ten->d) - flattening : flattening;\n\n    matrix_tt** Omegas = (matrix_tt**) malloc(n_Omega * sizeof(matrix_tt*));\n    for (int ii = 0; ii < n_Omega; ++ii){\n        Omegas[ii] = matrix_tt_init(ten->n[ii+ii0], r+buf);\n        matrix_tt_dlarnv(Omegas[ii]);\n    }\n\n    return Omegas;\n}\n\nvoid get_KR_info(int *d_KR, int *stride_KR, matrix_tt** KRs, MPI_tensor* ten, int flattening, int r, int buf, int iscol)\n{\n    int max_m = 1000;\n\n\n    int assigned = 0;\n    *d_KR = 0;\n    int N_KR = 1;\n\n    int ii0 = iscol ? flattening : 0;\n    int n_Omega = iscol ? (ten->d) - flattening : flattening;\n\n    KRs[2] = matrix_tt_init(1, r+buf);\n\n    for (int ii = 0; ii < n_Omega; ++ii){\n        if (assigned == 0){\n            int* partition_ii = ten->partitions[ii + ii0];\n            int sz_ii = 0;\n            for (int jj = 0; jj < ten->nps[ii+ii0]; ++jj){\n                int candidate_n = partition_ii[jj+1] - partition_ii[jj];\n                sz_ii = (sz_ii > candidate_n) ? sz_ii : candidate_n;\n            }\n            if (N_KR * sz_ii < max_m){\n                *d_KR = ii+1;\n                N_KR = N_KR * sz_ii;\n            }\n            else{\n                *stride_KR = max_m / N_KR;\n                KRs[0] = matrix_tt_init(N_KR, r+buf);\n                KRs[1] = matrix_tt_init(*stride_KR, r+buf);\n                N_KR = N_KR * (*stride_KR);\n                KRs[3] = matrix_tt_init(N_KR, r+buf);\n                assigned = 1;\n            }\n        }\n    }\n    if (assigned == 0){\n        *stride_KR = 0;\n        KRs[0] = matrix_tt_init(N_KR, r+buf);\n        KRs[1] = matrix_tt_init(1, r+buf);\n        KRs[3] = matrix_tt_init(N_KR, r+buf);\n    }\n}\n\n\nsketch* sketch_init(MPI_tensor* ten, int flattening, int r, int buf, int iscol)\n{\n    sketch* s = (sketch*) malloc(sizeof(sketch));\n\n    s->ten = ten;\n    s->flattening = flattening;\n    s->r = r;\n    s->buf = buf;\n    s->iscol = iscol;\n    s->owner_partition = get_sketch_owners(ten, flattening, iscol);\n    long recv_buf_height = 0;\n    get_sketch_height(ten, s->owner_partition, flattening, iscol, &(s->lda), &recv_buf_height);\n    s->Omegas = get_sketch_Omega(ten, flattening, r, buf, iscol);\n    s->X_size = (s->lda)*(r+buf);\n    s->X = (double*) calloc(s->X_size, sizeof(double));\n    s->scratch = (double*) calloc(s->X_size, sizeof(double));\n    s->recv_buf = (double*) calloc(recv_buf_height * (r+buf), sizeof(double));\n    s->fi = flattening_info_init(ten, flattening, iscol, 0);\n    s->KRs = (matrix_tt**) calloc(4, sizeof(matrix_tt*));\n    get_KR_info(&(s->d_KR), &(s->stride_KR), s->KRs, ten, flattening, r, buf, iscol);\n\n    return s;\n}\n\nmatrix_tt** copy_sketch_Omega(matrix_tt** Omegas, MPI_tensor* ten, int flattening, int r, int buf, int iscol)\n{\n    int ii0 = iscol ? flattening : 0;\n    int n_Omega = iscol ? (ten->d) - flattening : flattening;\n\n    matrix_tt** Omegas_cp = (matrix_tt**) malloc(n_Omega * sizeof(matrix_tt*));\n    for (int ii = 0; ii < n_Omega; ++ii){\n        submatrix_update(Omegas[ii], 0, ten->n[ii+ii0], 0, r+buf);\n        Omegas_cp[ii] = matrix_tt_copy(Omegas[ii]);\n    }\n\n    return Omegas_cp;\n}\n\n\nsketch* sketch_init_with_Omega(MPI_tensor* ten, int flattening, int r, int buf, int iscol, matrix_tt** Omegas)\n{\n    sketch* s = (sketch*) malloc(sizeof(sketch));\n    s->ten = ten;\n    s->flattening = flattening;\n    s->r = r;\n    s->buf = buf;\n    s->iscol = iscol;\n    s->owner_partition = get_sketch_owners(ten, flattening, iscol);\n    long recv_buf_height;\n    get_sketch_height(ten, s->owner_partition, flattening, iscol, &(s->lda), &recv_buf_height);\n    s->Omegas = copy_sketch_Omega(Omegas, ten, flattening, r, buf, iscol);\n    s->X_size = (s->lda)*(r+buf);\n    s->X = (double*) calloc(s->X_size, sizeof(double));\n    s->scratch = (double*) calloc(s->X_size, sizeof(double));\n    s->recv_buf = (double*) calloc(recv_buf_height * (r+buf), sizeof(double));\n    s->fi = flattening_info_init(ten, flattening, iscol, 0);\n    s->KRs = (matrix_tt**) calloc(4, sizeof(matrix_tt*));\n    get_KR_info(&(s->d_KR), &(s->stride_KR), s->KRs, ten, flattening, r, buf, iscol);\n\n    return s;\n}\n\n\n// NOTE: does not free the MPI_tensor. We assume this is shared, and should not be freed this way.\nvoid sketch_free(sketch* s)\n{\n    MPI_tensor* ten = s->ten; s->ten = NULL;\n    int d = ten->d;\n    int n_Omega = s->iscol ? d - s->flattening : s->flattening;\n    for (int ii = 0; ii < n_Omega; ++ii){\n        matrix_tt_free(s->Omegas[ii]); s->Omegas[ii] = NULL;\n    }\n    for (int ii = 0; ii < 4; ++ii){\n        matrix_tt_free(s->KRs[ii]); s->KRs[ii] = NULL;\n    }\n    free(s->KRs); s->KRs = NULL;\n\n    free(s->owner_partition); s->owner_partition = NULL;\n    free(s->X);               s->X = NULL;\n    free(s->scratch);         s->scratch = NULL;\n    free(s->Omegas);          s->Omegas = NULL;\n    free(s->recv_buf);        s->recv_buf = NULL;\n    flattening_info_free(s->fi); s->fi = NULL;\n    free(s);\n}\n\nvoid sketch_print(sketch* s)\n{\n    printf(\"Printing sketch at %p\\n\", s);\n\n    printf(\"\\nten address: %p\\n\", s->ten);\n    printf(\"flattening = %d\\n\",s->flattening);\n    printf(\"r = %d\\n\", s->r);\n    printf(\"buf = %d\\n\", s->buf);\n    printf(\"iscol = %d\\n\", s->iscol);\n\n    int* op = s->owner_partition;\n    MPI_tensor* ten = s->ten;\n    printf(\"owner_partition = [%d\", op[0]);\n    for (int ii = 1; ii < (ten->comm_size) + 1; ++ii){\n        printf(\", %d\", op[ii]);\n    }\n    printf(\"]\\n\");\n\n    printf(\"lda = %ld\\n\", s->lda);\n    printf(\"X_size = %ld\\n\", s->X_size);\n\n    printf(\"\\nX = \\n\");\n    int r = s->r; int buf = s->buf; long X_size = s->X_size; long lda = s->lda;\n    matrix_tt* X_mat = matrix_tt_wrap(lda, r+buf, s->X);\n    matrix_tt_print(X_mat, 1);\n    free(X_mat); X_mat = NULL;\n\n    printf(\"\\nscratch = \\n\");\n    matrix_tt* scratch_mat = matrix_tt_wrap(lda, r+buf, s->scratch);\n    matrix_tt_print(scratch_mat, 1);\n    free(scratch_mat); scratch_mat = NULL;\n\n    int n_Omega = s->iscol ? (s->ten)->d-s->flattening : s->flattening;\n    for (int ii = 0; ii < n_Omega; ++ii){\n        printf(\"\\nOmegas[%d] = \\n\", ii);\n        matrix_tt_print(s->Omegas[ii], 1);\n    }\n}\n\n// Performs C[ii + n_ii * jj,kk] = A[ii, kk] * B[jj, kk]\nvoid submatrix_khatri_rao_outer_product(matrix_tt* A, matrix_tt* B, matrix_tt* C)\n{\n    for (int kk = 0; kk < A->n; ++kk){\n        int A_offset = A->offset + kk*(A->lda);\n        int B_offset = B->offset + kk*(B->lda);\n        int C_offset = C->offset + kk*(C->lda);\n\n\n        cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans,\n                A->m, B->m, 1,\n                1.0,\n                A->X + A_offset, A->m,\n                B->X + B_offset, 1,\n                0.0,\n                C->X + C_offset, A->m);\n    }\n}\n\n// General idea of the algorithm:\n// Split the Omegas into 3 parts: ii < d_KR, ii == d_KR, ii > d_KR\n// For ii <  d_KR, we will pre-multiply the sketch matrices Omega[ii] (Call this KR_1)\n// For ii == d_KR, we will loop through blocks of Omega[d_KR]\n// For ii > d_KR, we will loop and multiply to get a row vector       (Call this KR_3)\n\n// Then, at each point in the loop, we will perform\n//     KR_2 = Omegas[ii] * KR_3 and\n//     KR_4 = KR_1 * KR_2,\n// where * is the Khatri-Rao product. Finally, we multiply X_mat by KR_4 to update the sketch, and repeat.\nvoid subtensor_khatri_rao(sketch* s, matrix_tt* C, flattening_info* fi, double beta, matrix_tt* X_mat)\n{\n    int r = s->r + s->buf;\n    matrix_tt** Omegas = s->Omegas;\n\n    MPI_tensor* ten = s->ten;\n    int d_KR = s->d_KR;\n    matrix_tt* KR_1;\n    matrix_tt* KR_4;\n    if ((d_KR == 0) || (d_KR%2 == 1)){\n        KR_1 = s->KRs[0];\n        KR_4 = s->KRs[3];\n    }\n    else{\n        KR_1 = s->KRs[3];\n        KR_4 = s->KRs[0];\n    }\n    int s_d = fi->s_d;\n\n    int N_kk = 1;\n\n    int h = 0;\n\n    int Omega_offset_KR;\n\n//    printf(\"Starting loop to get KR_1\\n\");\n    for (int ii = 0; ii < s_d; ++ii){\n        int ii0 = fi->s_t_index[ii];\n        int ii1 = ii0 + fi->s_t_sizes[ii];\n\n        submatrix_update(Omegas[ii], ii0, ii1, 0, r);\n\n        if (ii > d_KR){\n            N_kk = N_kk * fi->s_t_sizes[ii]; // Number of elements in outer loop\n        }\n        else if (ii == d_KR){\n            Omega_offset_KR = ii0;\n        }\n\n\n        if ((ii == 0) && (d_KR > 0)){\n            matrix_tt_reshape(ii1-ii0, r, KR_1);\n            matrix_tt_copy_data(KR_1, Omegas[0]);\n            h = ii1 - ii0;\n        }\n        else if (ii < d_KR){ // Multiply inner matrices\n            matrix_tt* tmp = KR_1;\n            KR_1 = KR_4;\n            KR_4 = tmp;\n\n            h = h*(ii1-ii0);\n            matrix_tt_reshape(h, r, KR_1);\n            submatrix_khatri_rao_outer_product(KR_4, Omegas[ii], KR_1);\n        }\n    }\n//    printf(\"Finished loop to get KR_1\\n\");\n\n    if (fi->iscol){\n        matrix_tt_wrap_update(X_mat, fi->f_N, fi->s_N, get_X(ten));\n    }\n    else{\n        matrix_tt_wrap_update(X_mat, fi->s_N, fi->f_N, get_X(ten));\n    }\n    X_mat->transpose = (fi->iscol ? 0 : 1);\n\n    if (d_KR == s_d){ // If we have done everything, just multiply (the sketch is relatively small)\n        matrix_tt_dgemm(X_mat, KR_1, C, 1.0, beta);\n        return;\n    }\n\n    int stride_KR = s->stride_KR;\n    matrix_tt* KR_2 = s->KRs[1];\n    matrix_tt* KR_3 = s->KRs[2];\n\n    int* t_kk = ten->t_kk;\n    int size_KR = fi->s_t_sizes[d_KR];\n    int N_ll = 1 + (size_KR - 1) / stride_KR;\n\n    int tensor_offset = 0;\n\n    for (int kk = 0; kk < N_kk; ++kk) {\n        to_tensor_ind(t_kk, (long) kk, fi->s_t_sizes + d_KR + 1, s_d - 1 - d_KR);\n\n        for (int ii = d_KR + 1; ii < s_d; ++ii){\n            if (ii == d_KR + 1){\n                for (int jj = 0; jj < r; ++jj){\n                    KR_3->X[jj] = matrix_tt_element(Omegas[ii], t_kk[ii-d_KR-1], jj);\n                }\n            }\n            else{\n                for (int jj = 0; jj < r; ++jj){\n                    KR_3->X[jj] *= matrix_tt_element(Omegas[ii], t_kk[ii-d_KR-1], jj);\n                }\n            }\n        }\n\n        for (int ll = 0; ll < N_ll; ++ll){\n            double bb = ((kk==0) && (ll==0)) ? beta : 1.0;\n            int ii0 = Omega_offset_KR + ll * stride_KR;\n            int ii1 = ((ll+1)*stride_KR > size_KR) ? size_KR + Omega_offset_KR: (ll+1)*stride_KR + Omega_offset_KR;\n\n            submatrix_update(Omegas[d_KR], ii0, ii1, 0, r);\n            if (d_KR + 1 == s_d){ // If we only need KR_1 and Omegas[ii]\n                matrix_tt_reshape((KR_1->m) * (ii1-ii0), r, KR_4);\n                submatrix_khatri_rao_outer_product(KR_1, Omegas[d_KR], KR_4);\n            }\n            else if (d_KR == 0){ // If we only need Omegas[ii] and KR_3\n                matrix_tt_reshape(Omegas[d_KR]->m, r, KR_4);\n                submatrix_khatri_rao_outer_product(Omegas[d_KR], KR_3, KR_4);\n            }\n            else{ // We need everything...\n                matrix_tt_reshape(ii1-ii0, r, KR_2);\n                submatrix_khatri_rao_outer_product(Omegas[d_KR], KR_3, KR_2);\n                matrix_tt_reshape((ii1-ii0) * (KR_1->m), r, KR_4);\n                submatrix_khatri_rao_outer_product(KR_1, KR_2, KR_4);\n            }\n\n\n            if (fi->iscol) {\n                submatrix_update(X_mat, 0, fi->f_N, tensor_offset, tensor_offset + KR_4->m);\n            }\n            else {\n                submatrix_update(X_mat, tensor_offset, tensor_offset + KR_4->m, 0, fi->f_N);\n            }\n\n            matrix_tt_dgemm(X_mat, KR_4, C, 1.0, bb);\n            tensor_offset = tensor_offset + KR_4->m;\n        }\n    }\n}\n\nint get_owner(int block, int* owner_partition, int comm_size)\n{\n    int color = -1;\n    for (int ii = 0; ii < comm_size; ++ii){\n        if ((block >= owner_partition[ii]) && (block < owner_partition[ii+1])){\n            color = ii;\n        }\n    }\n\n    return color;\n}\n\nint s_get_owner(sketch* s, int f_v_block){\n    int* op = s->owner_partition;\n    MPI_tensor* ten = s->ten;\n    int size = ten->comm_size;\n\n    // Binary search (basically wikipedia)\n    int a = 0;\n    int b = size-1;\n    int c;\n\n    while (a <= b){\n        c = (a+b)/2;\n        if (f_v_block < op[c]){\n            b = c-1;\n        }\n        else if(f_v_block >= op[c+1]){\n            a = c+1;\n        }\n        else{\n            return c;\n        }\n    }\n\n    return -1;\n}\n\nvoid own_submatrix_update(matrix_tt* mat, sketch* s, int f_v_block, int with_buf){\n    if (f_v_block == -1){\n        return;\n    }\n\n    int sketch_offset = 0;\n    int sketch_lda = s->lda;\n    MPI_tensor* ten = s->ten;\n    int world_rank = ten->rank;\n    int* owner_partition = s->owner_partition;\n\n    flattening_info* fi = s->fi;\n    if ((f_v_block < owner_partition[world_rank]) || (f_v_block >= owner_partition[world_rank+1])){\n        printf(\"r%d own_submatrix: This core does not own f_v_block = %d\\n\", world_rank, f_v_block);\n    }\n\n    for (int block = s->owner_partition[world_rank]; block < f_v_block; ++block){\n        flattening_info_f_update(fi, ten, block);\n        sketch_offset = sketch_offset + fi->f_N;\n    }\n    flattening_info_f_update(fi, ten, f_v_block);\n\n\n    matrix_tt_wrap_update(mat, sketch_lda, s->r + s->buf, s->X);\n    int r = (with_buf) ? s->r + s->buf : s->r;\n    submatrix_update(mat, sketch_offset, sketch_offset + fi->f_N, 0, r);\n}\n\nmatrix_tt* own_submatrix(sketch* s, int f_v_block, int with_buf){\n    matrix_tt* mat = (matrix_tt*) malloc(sizeof(matrix_tt));\n    own_submatrix_update(mat, s, f_v_block, with_buf);\n    return mat;\n}\n\nvoid subtensor_sketch_multiply(sketch* s, flattening_info* fi, matrix_tt** holders)\n{\n    MPI_tensor* ten = s->ten;\n    int* owner_partition = s->owner_partition;\n    int world_size = ten->comm_size;\n    int world_rank = ten->rank;\n\n    // Actually sketch the thing\n    matrix_tt* sketch_mat = holders[0];\n    double beta = 0.0;\n    if (ten->current_part != -1){\n        int current_color = get_owner(fi->f_v_block, owner_partition, world_size);\n        if (current_color == world_rank){\n            own_submatrix_update(sketch_mat, s, fi->f_v_block, 1);\n            beta = 1.0;\n        }\n        else{\n            matrix_tt_wrap_update(sketch_mat, fi->f_N, s->r + s->buf, s->scratch);\n            beta = 0.0;\n        }\n\n        subtensor_khatri_rao(s, sketch_mat, fi, beta, holders[1]);\n    }\n}\n\nvoid subtensor_sketch_communicate(sketch* s, int stream_step, flattening_info* fi, matrix_tt** holders)\n{\n    MPI_tensor* ten = s->ten;\n    int* owner_partition = s->owner_partition;\n    int world_size = ten->comm_size;\n    int world_rank = ten->rank;\n    int* group_ranks = ten->group_ranks;\n\n    flattening_info* fi_tmp = s->fi;\n    matrix_tt* sketch_mat = holders[0];\n\n    // For each flattening block\n    for (int ii = 0; ii < fi->f_Nblocks; ++ii){\n        int kk = 0;\n        int owner_ii = get_owner(ii, owner_partition, world_size);\n        int group_owner;\n        // For each rank in the world\n        for (int jj = 0; jj < world_size; ++jj){\n            // If the rank owns the block\n            if (owner_ii == jj){\n                // Add it to the group\n                group_ranks[kk] = jj;\n                kk = kk+1;\n                group_owner = jj;\n            }\n            else{\n                int* schedule_jj = ten->schedule[jj];\n                int stream_jj = schedule_jj[stream_step];\n                if (stream_jj != -1){\n                    flattening_info_update(fi_tmp, ten, schedule_jj[stream_step]);\n                    // Else, if the rank just calculated something that adds to the block\n                    if (ii == fi_tmp->f_v_block){\n                        // Add it to the group\n                        group_ranks[kk] = jj;\n                        kk = kk+1;\n                    }\n                }\n            }\n        }\n\n\n        if (world_rank == owner_ii){\n            matrix_tt* comm_matrix = holders[1];\n            own_submatrix_update(comm_matrix, s, ii, 1);\n            matrix_tt* buf_mat = holders[2];\n            matrix_tt_wrap_update(buf_mat, comm_matrix->m, comm_matrix->n, s->recv_buf);\n\n            matrix_tt_group_reduce(ten->comm, world_rank, comm_matrix, buf_mat, owner_ii, group_ranks, kk);\n        }\n        else if (sketch_mat->X){\n            matrix_tt* buf_mat = holders[2];\n            matrix_tt_wrap_update(buf_mat, sketch_mat->m, sketch_mat->n, s->recv_buf);\n            matrix_tt_group_reduce(ten->comm, world_rank,sketch_mat, buf_mat, owner_ii, group_ranks, kk);\n        }\n\n    }\n}\n\n\nvoid multi_perform_sketch(sketch** sketches, int n_sketch)\n{\n    int n_holders = 3;\n    matrix_tt** holders = (matrix_tt**) malloc(n_holders*n_sketch*sizeof(matrix_tt*));\n    for (int ii = 0; ii < n_holders*n_sketch; ++ii){\n        holders[ii] = (matrix_tt*) calloc(1, sizeof(matrix_tt));\n    }\n\n    MPI_tensor* ten = sketches[0]->ten; // Tensor\n    int rank = ten->rank;\n    int* schedule_rank = ten->schedule[rank];\n\n    flattening_info** fis = (flattening_info**) calloc(n_sketch, sizeof(flattening_info*));\n    for (int ii = 0; ii < n_sketch; ++ii){\n        fis[ii] = flattening_info_init(ten, sketches[ii]->flattening, sketches[ii]->iscol, 0);\n    }\n\n\n\n    for (int ii = 0; ii < ten->n_schedule; ++ii){\n        stream(ten, schedule_rank[ii]);\n        for (int jj = 0; jj < n_sketch; ++jj){\n            matrix_tt** holders_jj = holders + jj*n_holders;\n            flattening_info_update(fis[jj], ten, ten->current_part);\n            holders_jj[0]->X = NULL;\n            subtensor_sketch_multiply(sketches[jj], fis[jj], holders_jj);\n        }\n\n        for (int jj = 0; jj < n_sketch; ++jj){\n            matrix_tt** holders_jj = holders + jj*n_holders;\n            subtensor_sketch_communicate(sketches[jj], ii, fis[jj], holders_jj);\n        }\n    }\n\n    for (int ii = 0; ii < n_holders*n_sketch; ++ii){\n        free(holders[ii]); holders[ii] = NULL;\n    }\n\n    for (int ii = 0; ii < n_sketch; ++ii){\n        flattening_info_free(fis[ii]); fis[ii] = NULL;\n    }\n    free(fis); fis = NULL;\n    free(holders); holders = NULL;\n}\n\nvoid sketch_qr(sketch* sketch)\n{\n\n    MPI_tensor* ten = sketch->ten;\n    int* owner_partition = sketch->owner_partition;\n    int flattening = sketch->flattening;\n    int iscol = sketch->iscol;\n    int r = sketch->r;\n    int buf = sketch->buf;\n\n    MPI_Comm comm = ten->comm;\n    int size = ten->comm_size;\n    int rank = ten->rank;\n\n    // A little pre-processing\n    int head = 0;\n    flattening_info* fi = flattening_info_init(ten, flattening, iscol, 0);\n    int* Ns = (int*) calloc(size, sizeof(int));\n\n    for (int ii = 0; ii < size; ++ii){\n        for (int jj = owner_partition[ii]; jj < owner_partition[ii+1]; ++jj){\n            flattening_info_f_update(fi, ten, jj);\n            Ns[ii] = Ns[ii] + fi->f_N;\n        }\n    }\n\n    int N_rank = Ns[rank];\n    int lda = sketch->lda;\n    matrix_tt* Q_big = matrix_tt_wrap(lda, r+buf, sketch->X);\n    matrix_tt* Q = submatrix(Q_big, 0, N_rank, 0, r+buf);\n    matrix_tt* Q_head = NULL;\n    matrix_tt* R = NULL;\n\n    if (rank == head){\n        Q_head = matrix_tt_init(size * (r+buf), r+buf);\n        R = submatrix(Q_head, 0, r+buf, 0, r+buf);\n    }\n    else{\n        R = matrix_tt_init(r+buf, r+buf);\n    }\n\n    matrix_tt_truncated_qr(Q, R, r+buf);\n\n\n\n    // Gather the Rs\n    for (int jj = 0; jj < r+buf; ++jj){\n//        printf(\"r%d jj%d\\n\", rank, jj);\n        if (rank == head){\n            double* col = Q_head->X + jj*(Q_head->lda);\n            MPI_Gather(col, r+buf, MPI_DOUBLE, col, r+buf, MPI_DOUBLE, head, comm);\n        }\n        else{\n            MPI_Gather(R->X + jj*(R->lda), r+buf, MPI_DOUBLE, NULL, r+buf, MPI_DOUBLE, head, comm);\n        }\n    }\n\n    // Take the QR of the Rs\n    if (rank == head){\n        matrix_tt_truncated_qr(Q_head, NULL, r+buf);\n    }\n\n    // Scatter the Q of the preceding step\n    for (int jj = 0; jj < r+buf; ++jj){\n        if (rank == head){\n            double* col = Q_head->X + jj*(Q_head->lda);\n            MPI_Scatter(col, r+buf, MPI_DOUBLE, col, r+buf, MPI_DOUBLE, head, comm);\n        }\n        else{\n            MPI_Scatter(NULL, r+buf, MPI_DOUBLE, R->X + jj*(R->lda), r+buf, MPI_DOUBLE, head, comm);\n        }\n    }\n\n    // Multiply to get the final Q\n    matrix_tt* X_big = matrix_tt_wrap(lda, r, sketch->scratch);\n    matrix_tt* new_X = submatrix(X_big, 0, N_rank, 0, r);\n    matrix_tt* Q_head_sub = submatrix(R, 0, r+buf, 0, r);\n    matrix_tt_dgemm(Q, Q_head_sub, new_X, 1.0, 0.0);\n\n    // Switch so the QR lives in X\n    double* tmp = sketch->scratch;\n    sketch->scratch = sketch->X;\n    sketch->X = tmp;\n\n    free(X_big);              X_big = NULL;\n    free(new_X);              new_X = NULL;\n    free(Q_head_sub);         Q_head_sub = NULL;\n    flattening_info_free(fi); fi = NULL;\n    free(Ns);                 Ns = NULL;\n    free(Q_big);              Q_big = NULL;\n    free(Q);                  Q = NULL;\n    if (rank == head){\n        matrix_tt_free(Q_head); Q_head = NULL;\n        free(R);             R = NULL;\n    }\n    else{\n        matrix_tt_free(R); R = NULL;\n    }\n}\n\nvoid perform_sketch(sketch* s)\n{\n    multi_perform_sketch(&s, 1);\n}\n\n// Gets the sketch block from the correct owner (stored in fi->f_v_block). Returns a matrix with the correct dimensions\nvoid sendrecv_sketch_block(matrix_tt* mat, sketch* s, flattening_info* fi, int recv_rank, int with_buf)\n{\n    int f_v_block = fi->f_v_block;\n\n\n    MPI_tensor* ten = s->ten;\n    int rank = ten->rank;\n    MPI_Comm comm = ten->comm;\n\n    int owner = s_get_owner(s, f_v_block);\n    int r = (with_buf) ? s->r + s->buf : s->r;\n\n    if (rank == recv_rank){\n        if (rank == owner){\n            own_submatrix_update(mat, s, f_v_block, with_buf);\n        }\n        else{\n            matrix_tt_wrap_update(mat, fi->f_N, r, s->scratch);\n            matrix_tt_recv(comm, mat, owner);\n        }\n    }\n    else{\n        if(rank == owner){\n            own_submatrix_update(mat, s, f_v_block, with_buf);\n            matrix_tt_send(comm, mat, recv_rank);\n        }\n        mat->X = NULL;\n    }\n}\n\n// Eats s, so be careful!\nMPI_tensor* sketch_to_tensor(sketch** s_ptr)\n{\n    sketch* s = *s_ptr;\n\n    MPI_tensor* sten = (MPI_tensor*) malloc(sizeof(MPI_tensor));\n    MPI_tensor* ten = s->ten;\n    int rank = ten->rank;\n    int size = ten->comm_size;\n\n    flattening_info* fi = flattening_info_init(ten, s->flattening, s->iscol, 0);\n\n    // Get the schedule from the owner_partition\n    int n_schedule = 0;\n    int* owners = s->owner_partition;\n    for (int ii = 0; ii < size; ++ii){\n        int sz = owners[ii+1] - owners[ii];\n        n_schedule = (n_schedule > sz) ? n_schedule : sz;\n    }\n\n    int** schedule = (int**) malloc(size * sizeof(int*));\n    int* inverse_schedule = (int*) malloc(fi->f_Nblocks * sizeof(int));\n    for (int ii = 0; ii < size; ++ii){\n        schedule[ii] = (int*) malloc(n_schedule * sizeof(int));\n\n        int* schedule_ii = schedule[ii];\n        int jj0 = owners[ii];\n        int sz = owners[ii+1] - jj0;\n        for (int jj = 0; jj < n_schedule; ++jj){\n            if (jj < sz){\n                schedule_ii[jj] = jj+jj0;\n                inverse_schedule[jj+jj0] = ii*n_schedule + jj;\n            }\n            else{\n                schedule_ii[jj] = -1;\n            }\n        }\n    }\n\n    int d = fi->f_d + 1;\n    int soffset = (s->iscol) ? 0 : 1;\n    int offset = (s->iscol) ? 0 : s->flattening;\n    int end_ind = (s->iscol) ? d-1 : 0;\n\n    // Inherit the properties of ten\n    int* n = (int*) malloc(d * sizeof(int));\n    int* nps = (int*) malloc(d * sizeof(int));\n    int** partitions = (int**) malloc(d * sizeof(int*));\n    for (int ii = 0; ii < d-1; ++ii){\n        n[ii + soffset] = ten->n[ii + offset];\n        nps[ii + soffset] = ten->nps[ii + offset];\n        partitions[ii + soffset] = (int*) malloc( (nps[ii+soffset] + 1) * sizeof(int));\n\n        int* spartition_ii = partitions[ii+soffset];\n        int* partition_ii = ten->partitions[ii+offset];\n        for (int jj = 0; jj < nps[ii+soffset] + 1; ++jj){\n            spartition_ii[jj] = partition_ii[jj];\n        }\n    }\n    // Set the special sketched dimension properties\n    n[end_ind] = s->r;\n    nps[end_ind] = 1;\n    partitions[end_ind] = (int*) malloc( (nps[end_ind] + 1) * sizeof(int));\n    int* spartition_end = partitions[end_ind];\n    spartition_end[0] = 0; spartition_end[1] = n[end_ind];\n\n\n    // Get the parameters giving the subtensor locations\n    double** subtensors = (double**) malloc(n_schedule * sizeof(double*));\n    int* schedule_rank = schedule[rank];\n    int with_buf = 0;\n    long scratch_offset = 0;\n    for (int ii = 0; ii < n_schedule; ++ii){\n        if (schedule_rank[ii] != -1){\n            matrix_tt* X_submat = own_submatrix(s, schedule_rank[ii], with_buf);\n            subtensors[ii] = s->scratch + scratch_offset;\n            matrix_tt* scratch_submat = matrix_tt_wrap(X_submat->m, X_submat->n, subtensors[ii]);\n            matrix_tt_copy_data(scratch_submat, X_submat);\n            scratch_offset = scratch_offset + X_submat->n * X_submat->m;\n            free(X_submat);\n            free(scratch_submat);\n        }\n    }\n    void* parameters = p_static_init(subtensors);\n\n    // Assigning fields\n    sten->d = d;\n    sten->n = n;\n\n    sten->comm = ten->comm;\n    sten->rank = ten->rank;\n    sten->comm_size = ten->comm_size;\n\n    sten->schedule = schedule;\n    sten->n_schedule = n_schedule;\n    sten->inverse_schedule = inverse_schedule;\n\n    sten->partitions = partitions;\n    sten->nps = nps;\n\n    sten->current_part = -1;\n\n    sten->f_ten = NULL;\n    sten->parameters = parameters;\n\n    sten->X_size = s->X_size;\n    sten->X = s->scratch;\n\n    sten->ind1 = (int*) malloc(d * sizeof(int));\n    sten->ind2 = (int*) malloc(d * sizeof(int));\n    sten->tensor_part = (int*) malloc(d * sizeof(int));\n    sten->group_ranks = (int*) malloc(ten->comm_size * sizeof(int));\n    sten->t_kk = (int*) malloc(d * sizeof(int));\n\n    // Freeing sketch things\n    int n_Omega = s->iscol ? ten->d - s->flattening : s->flattening;\n    for (int ii = 0; ii < n_Omega; ++ii){\n        matrix_tt_free(s->Omegas[ii]); s->Omegas[ii] = NULL;\n    }\n    for (int ii = 0; ii < 4; ++ii){\n        matrix_tt_free(s->KRs[ii]); s->KRs[ii] = NULL;\n    }\n    free(s->KRs); s->KRs = NULL;\n    s->ten = NULL;\n    free(s->owner_partition); s->owner_partition = NULL;\n    free(s->X);               s->X = NULL;\n    free(s->Omegas);          s->Omegas = NULL;\n    free(s->recv_buf);        s->recv_buf = NULL;\n    flattening_info_free(s->fi); s->fi = NULL;\n    free(s);                  *s_ptr = NULL;\n\n\n    flattening_info_free(fi);\n\n    return sten;\n}", "meta": {"hexsha": "f839fadf2b29677c37488abe76ddcb5c097db805", "size": 37971, "ext": "c", "lang": "C", "max_stars_repo_path": "src/sketch.c", "max_stars_repo_name": "SidShi/Parallel_TT_sketching", "max_stars_repo_head_hexsha": "e2c00c289d75d3ac1df32ed2b95af579a517fcbf", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/sketch.c", "max_issues_repo_name": "SidShi/Parallel_TT_sketching", "max_issues_repo_head_hexsha": "e2c00c289d75d3ac1df32ed2b95af579a517fcbf", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/sketch.c", "max_forks_repo_name": "SidShi/Parallel_TT_sketching", "max_forks_repo_head_hexsha": "e2c00c289d75d3ac1df32ed2b95af579a517fcbf", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.1493027071, "max_line_length": 121, "alphanum_fraction": 0.554265097, "num_tokens": 12193, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4339814648038985, "lm_q2_score": 0.021948251635672697, "lm_q1q2_score": 0.009525134394733799}}
{"text": "\n/*\n* -----------------------------------------------------------------\n*  isat_lib.c\n*  In Situ Adaptive Tabulation Library\n*  Version: 2.0\n*  Last Update: Nov 3, 2019\n*  \n*  Programmer: Americo Barbosa da Cunha Junior\n*              americo.cunhajr@gmail.com\n* -----------------------------------------------------------------\n*  Copyright (c) 2010-2019, Americo Barbosa da Cunha Junior\n*  All rights reserved.\n* -----------------------------------------------------------------\n*  This is the implementation file for ISAT_LIB module, a \n*  computational library with In Situ Adaptive Tabulation (ISAT) \n*  algorithm routines.\n* -----------------------------------------------------------------\n*/\n\n\n\n\n#include <stdlib.h>\n#include <math.h>\n#include <time.h>\n#include <gsl/gsl_math.h>\n#include <gsl/gsl_errno.h>\n\n#include \"../include/thrm_lib.h\"\n#include \"../include/ell_lib.h\"\n#include \"../include/ode_lib.h\"\n#include \"../include/isat_lib.h\"\n\n\n\n\n/*\n*------------------------------------------------------------\n*   isat_alloc\n*\n*   This function alocates memory for an ISAT workspace\n*   structure and initialize its elements.\n*\n*   Output:\n*   isat_mem - pointer to ISAT workspace\n*\n*   last update: Oct 9, 2019\n*------------------------------------------------------------\n*/\n\nisat_wrk *isat_alloc()\n{\n    /* create ISAT workspace */\n    isat_wrk *isat_mem = NULL;\n\n    /* memory allocation for ISAT workspace */\n    isat_mem = (isat_wrk *) malloc(sizeof(isat_wrk));\n    if ( isat_mem == NULL )\n        return NULL;\n    \n    /* initialize ISAT workspace elements */\n    isat_mem->root      = NULL;\n    isat_mem->lf        = 0;\n    isat_mem->nd        = 0;\n    isat_mem->add       = 0;\n    isat_mem->grw       = 0;\n    isat_mem->rtv       = 0;\n    isat_mem->dev       = 0;\n    isat_mem->hgt       = 0;\n    isat_mem->maxleaves = 0;\n    isat_mem->time_add  = 0.0;\n    isat_mem->time_grw  = 0.0;\n    isat_mem->time_rtv  = 0.0;\n    isat_mem->time_dev  = 0.0;\n    \n    return isat_mem;\n}\n/*------------------------------------------------------------*/\n\n\n\n\n/*\n*------------------------------------------------------------\n*   isat_free\n*\n*   This function release the memory used by ISAT workspace.\n*\n*   Input:\n*   isat_bl - pointer to ISAT workspace\n*\n*   last update: Oct 9, 2019\n*------------------------------------------------------------\n*/\n\nvoid isat_free(void **isat_bl)\n{\n    /* create ISAT workspace */\n    isat_wrk *isat_mem = NULL;\n    \n    /* check if ISAT workspace memory block is NULL */\n    if ( *isat_bl == NULL )\n        return;\n    \n    isat_mem = (isat_wrk *) (*isat_bl);\n    \n    /* release the memory allocated for ISAT workspace elements */\n    if( isat_mem->root != NULL )\n    {\n        bst_node_free((void **)&(isat_mem->root));\n        isat_mem->root = NULL;\n    }\n    \n    /* release the memory allocated for ISAT workspace */\n    free(*isat_bl);\n    *isat_bl = NULL;\n    \n    return;\n}\n/*------------------------------------------------------------*/\n\n\n\n\n/*\n*------------------------------------------------------------\n*   isat_bst_init\n*\n*   This function initiates ISAT binary search tree.\n*\n*   Input:\n*   isat_mem - pointer to ISAT workspace\n*\n*   last update: Oct 9, 2019\n*------------------------------------------------------------\n*/\n\nint isat_bst_init(isat_wrk *isat_mem)\n{\n    /* check if ISAT workspece is allocated */\n    if ( isat_mem == NULL )\n        return GSL_EINVAL;\n    \n    /* memory allocation for ISAT binary search tree root */\n    if ( isat_mem->root == NULL )\n    {\n        isat_mem->root = bst_node_alloc();\n        if ( isat_mem->root == NULL )\n        {\n            free(isat_mem);\n            isat_mem = NULL;\n            return GSL_EINVAL;\n        }\n    }\n    \n    return GSL_SUCCESS;\n}\n/*------------------------------------------------------------*/\n\n\n\n\n/*\n*------------------------------------------------------------\n*   isat_statistics\n*\n*   This function prints on screen ISAT workspace\n*   statistics of usage.\n*\n*   Input:\n*   isat_mem - pointer to ISAT workspace\n*\n*   last update: Oct 1, 2019\n*------------------------------------------------------------\n*/\n\nvoid isat_statistics(isat_wrk *isat_mem)\n{\n    double time_add;\n    double time_grw;\n    double time_rtv;\n    double time_dev;\n    \n    time_add = (double) (isat_mem->time_add / CLOCKS_PER_SEC) / isat_mem->add;\n    time_grw = (double) (isat_mem->time_grw / CLOCKS_PER_SEC) / isat_mem->grw;\n    time_rtv = (double) (isat_mem->time_rtv / CLOCKS_PER_SEC) / isat_mem->rtv;\n    time_dev = (double) (isat_mem->time_dev / CLOCKS_PER_SEC) / isat_mem->dev;\n    \n    printf(\"\\n ISAT statistics:\");\n    printf(\"\\n # of adds         = %d\",   isat_mem->add);\n    printf(\"\\n # of grows        = %d\",   isat_mem->grw);\n    printf(\"\\n # of retrieves    = %d\",   isat_mem->rtv);\n    printf(\"\\n # of dir. eval.   = %d\",   isat_mem->dev);\n    printf(\"\\n # of leaves       = %d\",   isat_mem->lf);\n    printf(\"\\n # of nodes        = %d\",   isat_mem->nd);\n    printf(\"\\n tree height       = %d\\n\", isat_mem->hgt);\n    \n    printf(\"\\n average values for CPU time (s):\");\n    printf(\"\\n add: %+.6e\",time_add);\n    printf(\"\\n grw: %+.6e\",time_grw);\n    printf(\"\\n rtv: %+.6e\",time_rtv);\n    printf(\"\\n dev: %+.6e\",time_dev);\n    \n    return;\n}\n/*------------------------------------------------------------*/\n\n\n\n\n/*\n* -----------------------------------------------------------------\n*   isat_input\n*\n*   This function receives ISAT input parameters from the user.\n*\n*   Input:\n*   maxleaves - maximum number of ISAT tree leaves\n*   etol      - ISAT error tolerance\n*\n*   Output:\n*   success or error\n*\n*   last update: Nov 3, 2019\n* -----------------------------------------------------------------\n*/\n\nint isat_input(unsigned int *maxleaves,double *etol)\n{\n    printf(\"\\n Input ISAT parameters:\\n\");\n    \n    printf(\"\\n maximum of tree leaves:\");\n    scanf(\"%d\", maxleaves);\n    printf(\"\\n %d\\n\", *maxleaves);\n    if( *maxleaves <= 0 )\n\tGSL_ERROR(\" maxleaves must be a positive integer\",GSL_EINVAL);\n\n    printf(\"\\n ISAT error tolerance:\");\n    scanf(\"%lf\", etol);\n    printf(\"\\n %+.1e\\n\", *etol);\n    if( *etol < 0.0 )\n\tGSL_ERROR(\" etol must be grather than zero\",GSL_EINVAL);\n    \n    return GSL_SUCCESS;\n}\n/*----------------------------------------------------------------*/\n\n\n\n\n/*\n*------------------------------------------------------------\n*   isat_eoa_matrix\n*\n*   This function computes the EOA matrix in Cholesky form.\n*   \n*   Input:\n*   A    - gradient matrix\n*   etol - error tolerance\n*\n*   Output:\n*   L    - EOA Cholesky matrix\n*\n*   last update: Oct 9, 2019\n*------------------------------------------------------------\n*/\n\nvoid isat_eoa_mtrx(gsl_matrix *A,\n                   double etol,\n                   gsl_matrix *L)\n{\n    unsigned int i;\n    double  eps_max   = 0.5;\n    gsl_matrix *Aetol = NULL;\n    gsl_matrix *V     = NULL;\n    gsl_vector *sigma = NULL;\n\n    /* memory allocation */\n    Aetol = gsl_matrix_calloc(A->size2,A->size2);\n    V     = gsl_matrix_calloc(A->size2,A->size2);\n    sigma = gsl_vector_calloc(A->size2);\n    \n    /* Aetol := A */\n    gsl_matrix_memcpy(Aetol,A);\n    \n    /* Aetol := (1/etol).A */\n    gsl_matrix_scale (Aetol,1.0/etol);\n\n    /* Aetol = U*sigma*V^T */\n    ell_psd2eig(Aetol,V,sigma);\n\n    /* eliminate small and large singular values */\n    for ( i = 0; i < sigma->size; i++ )\n        sigma->data[i] = GSL_MAX(sigma->data[i],eps_max);\n    \n    /* V*sigma^2*V^T = L*L^T */\n    ell_eig2chol(V,sigma,L);\n    \n    /* release allocated memory */\n    gsl_vector_free(sigma);\n    gsl_matrix_free(V);\n    gsl_matrix_free(Aetol);\n    sigma = NULL;\n    V     = NULL;\n    Aetol = NULL;\n    \n    return;\n}\n/*------------------------------------------------------------*/\n\n\n\n\n/*\n*------------------------------------------------------------\n*   isat_lerror\n*\n*   This function computes the local error defined as\n*\n*   eps = ||Rl(phi)- R(phi)||_2 where\n*\n*   Rl(phi) = R(phi0) + A*(phi-phi0).\n*\n*   Input:\n*   Rphi  - reaction mapping of phi\n*   Rphi0 - reaction mapping of phi0\n*   A     - mapping gradient matrix\n*   phi   - query composition\n*   phi0  - initial composition\n*\n*   Output:\n*   eps   - local error\n*\n*   last update: Feb 19, 2010\n*------------------------------------------------------------\n*/\n\ndouble isat_lerror(gsl_vector *Rphi,\n                   gsl_vector *Rphi0,\n                   gsl_matrix *A,\n                   gsl_vector *phi,\n                   gsl_vector *phi0)\n{\n    double eps;\n    gsl_vector *Rlphi = NULL;\n    \n    /* memory allocation for Rlphi */\n    Rlphi = gsl_vector_calloc(phi->size);\n    \n    /* Rlphi := R(phi0) + A*(phi-phi0) */\n    linear_approx(phi,phi0,Rphi0,A,Rlphi);\n    \n    /* Rlphi := Rl(phi) - R(phi) */\n    gsl_vector_sub(Rlphi,Rphi);\n    \n    /* eps := 2-norm(Rl(phi) - R(phi)) */\n    eps = gsl_blas_dnrm2(Rlphi);\n    \n    /* releasing allocated memory */\n    gsl_vector_free(Rlphi);\n    Rlphi = NULL;\n    \n    return eps;\n}\n/*------------------------------------------------------------*/\n\n\n\n\n/*\n*------------------------------------------------------------\n*   isat4\n*\n*   This function executes the 4-th version of the\n*   In Situ Adaptive Tabulation (ISAT) algorithm.\n*\n*   \n*   Input:\n*   isat_mem  - ISAT workspace\n*   cvode_mem - ODE solver workspace\n*   etol      - error tolerance\n*   t0        - initial time\n*   delta_t   - time step\n*   phi       - query composition\n*   A         - mapping gradient matrix\n*   L         - EOA Cholesky matrix\n*\n*   Output:\n*   Rphi      - reaction mapping\n*   success or error\n*\n*   last update: Nov 3, 2019\n*------------------------------------------------------------\n*/\n\nint isat4(isat_wrk *isat_mem,\n          void *cvode_mem,\n          double etol,\n          double t0,\n          double delta_t,\n          gsl_vector *phi,\n          gsl_matrix *A,\n          gsl_matrix *L,\n          gsl_vector *Rphi)\n{\n\n    /* CPU clock start counter */\n    clock_t cpu_start = clock();\n\n    int flag;\n    unsigned int bst_side;\n    bst_leaf *end_leaf     = NULL;\n    bst_node *end_node     = NULL;\n    \n    /****** First call for ISAT algorithm ******/\n\n    /* check if there is no leaf in the binary search tree */\n    if( isat_mem->lf == 0 )\n    {\n        int flag;\n        bst_leaf *first_leaf = NULL;\n\t\n\t/* memory allocation for BST first leaf */\n        first_leaf = bst_leaf_alloc();\n\tif ( first_leaf == NULL )\n                return GSL_ENOMEM;\n        \n        /* direct integration */\n        flag = odesolver_reinit(t0,phi,cvode_mem);\n        if ( flag != GSL_SUCCESS )\n            return flag;\n        \n        flag = odesolver(cvode_mem,\n                         delta_t,\n                         Rphi);\n        if ( flag != GSL_SUCCESS )\n            return flag;\n        \n        /* compute the mapping gradient matrix */\n        flag = gradient(cvode_mem,t0,delta_t,phi,Rphi,A);\n        if ( flag != GSL_SUCCESS )\n            return flag;\n        \n        /* compute EOA Cholesky matrix */\n        isat_eoa_mtrx(A,etol,L);\n        \n        /* define first leaf elements */\n        bst_leaf_set(phi,Rphi,A,L,first_leaf);\n        isat_mem->root->r_leaf = first_leaf;\n        \n        /* update ISAT workspace counters */\n        isat_mem->lf++;\n        isat_mem->hgt = bst_height(isat_mem->root);\n        \n        return GSL_SUCCESS;\n    }\n    \n    \n    /****** Further calls for ISAT algorithm ******/  \n    \n    /* search for the near composition in binary search tree */\n    if( isat_mem->lf > 1 )\n\tbst_side = bst_search(isat_mem->root,\n                              phi,\n                              &end_node,\n                              &end_leaf);\n    else\n    {\n        end_node = isat_mem->root;\n        end_leaf = isat_mem->root->r_leaf;\n        bst_side = BST_RIGHT;\n    }\n    \n    /* check if the near composition is inside the ellipsoid */\n    flag = ell_pt_in(phi,end_leaf->phi,end_leaf->L);\n    if( flag == ELL_TRUE )\n    {\n        /* compute the linear approximation */\n        linear_approx(phi,end_leaf->phi,end_leaf->Rphi,end_leaf->A,Rphi);\n        \n        /* update ISAT workspace counters */\n        isat_mem->rtv++;\n\t    isat_mem->time_rtv += clock() - cpu_start;\n        \n        return GSL_SUCCESS;\n    }\n    else\n    {\n        double lerror = 0.0;\n\t\n        /* performe direct integration */\n        flag = odesolver_reinit(t0,phi,cvode_mem);\n        if ( flag != GSL_SUCCESS )\n            return flag;\n        \n        flag = odesolver(cvode_mem,delta_t,Rphi);\n        if ( flag != GSL_SUCCESS )\n            return flag;\n        \n        /* compute ISAT local error */\n        lerror = isat_lerror(Rphi,end_leaf->Rphi,\n                             end_leaf->A,phi,end_leaf->phi);\n        \n        /* check if the local error is greater than etol */\n        if( lerror < etol )\n        {\n            /* grow the ellipsoid */\n            ell_pt_modify(phi,end_leaf->phi,end_leaf->L);\n            \n            /* update ISAT workspace counters */\n            isat_mem->grw++;\n\t        isat_mem->time_grw += clock() - cpu_start;\n            \n            return GSL_SUCCESS;\n        }\n        else\n        {\n\t    /* check if the maximum number of leaves is excced */\n\t    if( isat_mem->lf > isat_mem->maxleaves )\n\t    {\n\t        /*  update ISAT workspace counters */\n\t        isat_mem->dev++;\n\t\t    isat_mem->time_dev +=  clock() - cpu_start;\n\t\t    return GSL_SUCCESS;\n\t    }\n\t    \n            bst_leaf *new_leaf = NULL;\n            \n\t    /* memory allocation */\n            new_leaf = bst_leaf_alloc();\n            if ( new_leaf == NULL )\n                return GSL_ENOMEM;\n            \n            /* compute the mapping gradient matrix */\n            flag = gradient(cvode_mem,t0,delta_t,phi,Rphi,A);\n            if ( flag != GSL_SUCCESS )\n                return flag;\n            \n            /* compute ellipsoid matrix */\n            isat_eoa_mtrx(A,etol,L);\n            \n            /* define the new leaf elements */\n            bst_leaf_set(phi,Rphi,A,L,new_leaf);\n            \n            /* check if the binary search tree has more than one leaf */\n            if( isat_mem->lf > 1 )\n            {\n                bst_node *new_node = NULL;\n\t\t\n\t\t        /* memory allocation for the new node */\n                new_node = bst_node_alloc();\n                if ( new_node == NULL )\n                    return GSL_ENOMEM;\n                \n\t\t        /* define the new node leaves */\n                bst_node_set(end_leaf,new_leaf,new_node);\n\t\t\n\t\t        /* add the new node to the binary search tree */\n                bst_node_add(bst_side,end_node,new_node);\n            }\n\t        else\n                bst_node_set(end_leaf,new_leaf,end_node);\n            \n            /* update ISAT workspace counters */\n            isat_mem->add++;\n            isat_mem->lf++;\n            isat_mem->nd++;\n            isat_mem->hgt = bst_height(isat_mem->root);\n\t        isat_mem->time_add += clock() - cpu_start;\n            \n            return GSL_SUCCESS;\n        }\n    }\n}\n/*------------------------------------------------------------*/\n", "meta": {"hexsha": "7114e18da121f5a8e494e7c54eeadcb0df60f4e6", "size": 15022, "ext": "c", "lang": "C", "max_stars_repo_path": "CRFlowLib-2.0/src/isat_lib.c", "max_stars_repo_name": "americocunhajr/CRFlowLib", "max_stars_repo_head_hexsha": "35b67f798c1c33118c028691f42b98ba06220eeb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-12-29T12:56:14.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-29T12:56:14.000Z", "max_issues_repo_path": "CRFlowLib-2.0/src/isat_lib.c", "max_issues_repo_name": "americocunhajr/CRFlowLib", "max_issues_repo_head_hexsha": "35b67f798c1c33118c028691f42b98ba06220eeb", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "CRFlowLib-2.0/src/isat_lib.c", "max_forks_repo_name": "americocunhajr/CRFlowLib", "max_forks_repo_head_hexsha": "35b67f798c1c33118c028691f42b98ba06220eeb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-11-15T03:57:44.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-30T01:44:13.000Z", "avg_line_length": 26.0346620451, "max_line_length": 78, "alphanum_fraction": 0.4840900013, "num_tokens": 3742, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.27512972382317524, "lm_q2_score": 0.034618834979657495, "lm_q1q2_score": 0.009524670507033246}}
{"text": "/* adept_source.h - Source code for the Adept library\n\n  Copyright (C) 2012-2015 The University of Reading\n  Copyright (C) 2015-2017 European Centre for Medium-Range Weather Forecasts\n\n  Licensed under the Apache License, Version 2.0 (the \"License\"); you\n  may not use this file except in compliance with the License.  You\n  may obtain a copy of the License at\n\n      http://www.apache.org/licenses/LICENSE-2.0\n\n  Unless required by applicable law or agreed to in writing, software\n  distributed under the License is distributed on an \"AS IS\" BASIS,\n  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\n  implied.  See the License for the specific language governing\n  permissions and limitations under the License.\n\n\n  This file was created automatically by script ./create_adept_source_header \n  on Sun 28 Jan 21:05:14 GMT 2018\n\n  It contains a concatenation of the source files from the Adept\n  library. The idea is that a program may #include this file in one of\n  its source files (typically the one containing the main function),\n  and then the Adept library will be built into the executable without\n  the need to link to an external library. All other source files\n  should just #include <adept.h> or <adept_arrays.h>. The ability to\n  use Adept in this way makes it easier to distribute an Adept package\n  that is usable on non-Unix platforms that are unable to use the\n  autoconf configure script to build external libraries.\n\n  If HAVE_BLAS is defined below then matrix multiplication will be\n  enabled; the BLAS library should be provided at the link stage\n  although no header file is required.  If HAVE_LAPACK is defined\n  below then linear algebra routines will be enabled (matrix inverse\n  and solving linear systems of equations); again, the LAPACK library\n  should be provided at the link stage although no header file is\n  required.\n\n*/\n\n/* Feel free to delete this warning: */\n#ifdef _MSC_FULL_VER \n#pragma message(\"warning: the adept_source.h header file has not been edited so BLAS matrix multiplication and LAPACK linear-algebra support have been disabled\")\n#else\n#warning \"The adept_source.h header file has not been edited so BLAS matrix multiplication and LAPACK linear-algebra support have been disabled\"\n#endif\n\n/* Uncomment this if you are linking to the BLAS library (header file\n   not required) to enable matrix multiplication */\n#define HAVE_BLAS 1\n\n/* Uncomment this if you are linking to the LAPACK library (header\n   file not required) */\n//#define HAVE_LAPACK 1\n\n/* Uncomment this if you have the cblas.h header from OpenBLAS */\n//#define HAVE_OPENBLAS_CBLAS_HEADER\n\n/*\n\n  The individual source files now follow.\n\n*/\n\n#ifndef AdeptSource_H\n#define AdeptSource_H 1\n\n\n\n\n// =================================================================\n// Contents of config_platform_independent.h\n// =================================================================\n\n/* config_platform_independent.h.  Generated from config_platform_independent.h.in by configure.  */\n/* config_platform_independent.h.in. */\n\n/* Name of package */\n#define PACKAGE \"adept\"\n\n/* Define to the address where bug reports for this package should be sent. */\n#define PACKAGE_BUGREPORT \"r.j.hogan@ecmwf.int\"\n\n/* Define to the full name of this package. */\n#define PACKAGE_NAME \"adept\"\n\n/* Define to the full name and version of this package. */\n#define PACKAGE_STRING \"adept 2.0.5\"\n\n/* Define to the one symbol short name of this package. */\n#define PACKAGE_TARNAME \"adept\"\n\n/* Define to the home page for this package. */\n#define PACKAGE_URL \"http://www.met.reading.ac.uk/clouds/adept/\"\n\n/* Define to the version of this package. */\n#define PACKAGE_VERSION \"2.0.5\"\n\n/* Version number of package */\n#define VERSION \"2.0.5\"\n\n\n\n// =================================================================\n// Contents of cpplapack.h\n// =================================================================\n\n/* cpplapack.h -- C++ interface to LAPACK\n\n    Copyright (C) 2015-2016 European Centre for Medium-Range Weather Forecasts\n\n    Author: Robin Hogan <r.j.hogan@ecmwf.int>\n\n    This file is part of the Adept library.\n*/\n\n#ifndef AdeptCppLapack_H\n#define AdeptCppLapack_H 1                       \n\n#include <vector>\n\n#ifdef HAVE_CONFIG_H\n#include \"config.h\"\n#endif\n\n#ifdef HAVE_LAPACK\n\nextern \"C\" {\n  // External LAPACK Fortran functions\n  void sgetrf_(const int* m, const int* n, float*  a, const int* lda, int* ipiv, int* info);\n  void dgetrf_(const int* m, const int* n, double* a, const int* lda, int* ipiv, int* info);\n  void sgetri_(const int* n, float* a, const int* lda, const int* ipiv, \n\t       float* work, const int* lwork, int* info);\n  void dgetri_(const int* n, double* a, const int* lda, const int* ipiv, \n\t       double* work, const int* lwork, int* info);\n  void ssytrf_(const char* uplo, const int* n, float* a, const int* lda, int* ipiv,\n\t       float* work, const int* lwork, int* info);\n  void dsytrf_(const char* uplo, const int* n, double* a, const int* lda, int* ipiv,\n\t       double* work, const int* lwork, int* info);\n  void ssytri_(const char* uplo, const int* n, float* a, const int* lda, \n\t       const int* ipiv, float* work, int* info);\n  void dsytri_(const char* uplo, const int* n, double* a, const int* lda, \n\t       const int* ipiv, double* work, int* info);\n  void ssysv_(const char* uplo, const int* n, const int* nrhs, float* a, const int* lda, \n\t      int* ipiv, float* b, const int* ldb, float* work, const int* lwork, int* info);\n  void dsysv_(const char* uplo, const int* n, const int* nrhs, double* a, const int* lda, \n\t      int* ipiv, double* b, const int* ldb, double* work, const int* lwork, int* info);\n  void sgesv_(const int* n, const int* nrhs, float* a, const int* lda, \n\t      int* ipiv, float* b, const int* ldb, int* info);\n  void dgesv_(const int* n, const int* nrhs, double* a, const int* lda, \n\t      int* ipiv, double* b, const int* ldb, int* info);\n}\n\nnamespace adept {\n\n  // Overloaded functions provide both single &\n  // double precision versions, and prevents the huge lapacke.h having\n  // to be included in all user code\n  namespace internal {\n    typedef int lapack_int;\n    // Factorize a general matrix\n    inline\n    int cpplapack_getrf(int n, float* a,  int lda, int* ipiv) {\n      int info;\n      sgetrf_(&n, &n, a, &lda, ipiv, &info);\n      return info;\n    }\n    inline\n    int cpplapack_getrf(int n, double* a, int lda, int* ipiv) {\n      int info;\n      dgetrf_(&n, &n, a, &lda, ipiv, &info);\n      return info;\n    }\n\n    // Invert a general matrix\n    inline\n    int cpplapack_getri(int n, float* a,  int lda, const int* ipiv) {\n      int info;\n      float work_query;\n      int lwork = -1;\n      // Find out how much work memory required\n      sgetri_(&n, a, &lda, ipiv, &work_query, &lwork, &info);\n      lwork = static_cast<int>(work_query);\n      std::vector<float> work(static_cast<size_t>(lwork));\n      // Do full calculation\n      sgetri_(&n, a, &lda, ipiv, &work[0], &lwork, &info);\n      return info;\n    }\n    inline\n    int cpplapack_getri(int n, double* a,  int lda, const int* ipiv) {\n      int info;\n      double work_query;\n      int lwork = -1;\n      // Find out how much work memory required\n      dgetri_(&n, a, &lda, ipiv, &work_query, &lwork, &info);\n      lwork = static_cast<int>(work_query);\n      std::vector<double> work(static_cast<size_t>(lwork));\n      // Do full calculation\n      dgetri_(&n, a, &lda, ipiv, &work[0], &lwork, &info);\n      return info;\n    }\n\n    // Factorize a symmetric matrix\n    inline\n    int cpplapack_sytrf(char uplo, int n, float* a, int lda, int* ipiv) {\n      int info;\n      float work_query;\n      int lwork = -1;\n      // Find out how much work memory required\n      ssytrf_(&uplo, &n, a, &lda, ipiv, &work_query, &lwork, &info);\n      lwork = static_cast<int>(work_query);\n      std::vector<float> work(static_cast<size_t>(lwork));\n      // Do full calculation\n      ssytrf_(&uplo, &n, a, &lda, ipiv, &work[0], &lwork, &info);\n      return info;\n    }\n    inline\n    int cpplapack_sytrf(char uplo, int n, double* a, int lda, int* ipiv) {\n      int info;\n      double work_query;\n      int lwork = -1;\n      // Find out how much work memory required\n      dsytrf_(&uplo, &n, a, &lda, ipiv, &work_query, &lwork, &info);\n      lwork = static_cast<int>(work_query);\n      std::vector<double> work(static_cast<size_t>(lwork));\n      // Do full calculation\n      dsytrf_(&uplo, &n, a, &lda, ipiv, &work[0], &lwork, &info);\n      return info;\n    }\n\n    // Invert a symmetric matrix\n    inline\n    int cpplapack_sytri(char uplo, int n, float* a, int lda, const int* ipiv) {\n      int info;\n      std::vector<float> work(n);\n      ssytri_(&uplo, &n, a, &lda, ipiv, &work[0], &info);\n      return info;\n    }\n    inline\n    int cpplapack_sytri(char uplo, int n, double* a, int lda, const int* ipiv) {\n      int info;\n      std::vector<double> work(n);\n      dsytri_(&uplo, &n, a, &lda, ipiv, &work[0], &info);\n      return info;\n    }\n\n    // Solve system of linear equations with general matrix\n    inline\n    int cpplapack_gesv(int n, int nrhs, float* a, int lda,\n\t\t       int* ipiv, float* b, int ldb) {\n      int info;\n      sgesv_(&n, &nrhs, a, &lda, ipiv, b, &lda, &info);\n      return info;\n    }\n    inline\n    int cpplapack_gesv(int n, int nrhs, double* a, int lda,\n\t\t       int* ipiv, double* b, int ldb) {\n      int info;\n      dgesv_(&n, &nrhs, a, &lda, ipiv, b, &lda, &info);\n      return info;\n    }\n\n    // Solve system of linear equations with symmetric matrix\n    inline\n    int cpplapack_sysv(char uplo, int n, int nrhs, float* a, int lda, int* ipiv,\n\t\t       float* b, int ldb) {\n      int info;\n      float work_query;\n      int lwork = -1;\n      // Find out how much work memory required\n      ssysv_(&uplo, &n, &nrhs, a, &lda, ipiv, b, &ldb, &work_query, &lwork, &info);\n      lwork = static_cast<int>(work_query);\n      std::vector<float> work(static_cast<size_t>(lwork));\n      // Do full calculation\n      ssysv_(&uplo, &n, &nrhs, a, &lda, ipiv, b, &ldb, &work[0], &lwork, &info);\n      return info;\n    }\n    inline\n    int cpplapack_sysv(char uplo, int n, int nrhs, double* a, int lda, int* ipiv,\n\t\t       double* b, int ldb) {\n      int info;\n      double work_query;\n      int lwork = -1;\n      // Find out how much work memory required\n      dsysv_(&uplo, &n, &nrhs, a, &lda, ipiv, b, &ldb, &work_query, &lwork, &info);\n      lwork = static_cast<int>(work_query);\n      std::vector<double> work(static_cast<size_t>(lwork));\n      // Do full calculation\n      dsysv_(&uplo, &n, &nrhs, a, &lda, ipiv, b, &ldb, &work[0], &lwork, &info);\n      return info;\n    }\n\n  }\n}\n\n#endif\n\n#endif\n\n\n// =================================================================\n// Contents of Array.cpp\n// =================================================================\n\n/* Array.cpp -- Functions and global variables controlling array behaviour\n\n    Copyright (C) 2015-2016 European Centre for Medium-Range Weather Forecasts\n\n    Robin Hogan <r.j.hogan@ecmwf.int>\n\n    This file is part of the Adept library.\n*/\n\n\n#include <adept/Array.h>\n\nnamespace adept {\n  namespace internal {\n    bool array_row_major_order = true;\n    //    bool array_print_curly_brackets = true;\n\n    // Variables describing how arrays are written to a stream\n    ArrayPrintStyle array_print_style = PRINT_STYLE_CURLY;\n    std::string vector_separator = \", \";\n    std::string vector_print_before = \"{\";\n    std::string vector_print_after = \"}\";\n    std::string array_opening_bracket = \"{\";\n    std::string array_closing_bracket = \"}\";\n    std::string array_contiguous_separator = \", \";\n    std::string array_non_contiguous_separator = \",\\n\";\n    std::string array_print_before = \"\\n{\";\n    std::string array_print_after = \"}\";\n    std::string array_print_empty_before = \"(empty rank-\";\n    std::string array_print_empty_after = \" array)\";\n    bool array_print_indent = true;\n    bool array_print_empty_rank = true;\n  }\n\n  void set_array_print_style(ArrayPrintStyle ps) {\n    using namespace internal;\n    switch (ps) {\n    case PRINT_STYLE_PLAIN:\n       vector_separator = \" \";\n       vector_print_before = \"\";\n       vector_print_after = \"\";\n       array_opening_bracket = \"\";\n       array_closing_bracket = \"\";\n       array_contiguous_separator = \" \";\n       array_non_contiguous_separator = \"\\n\";\n       array_print_before = \"\";\n       array_print_after = \"\";\n       array_print_empty_before = \"(empty rank-\";\n       array_print_empty_after = \" array)\";\n       array_print_indent = false;\n       array_print_empty_rank = true;\n       break;\n    case PRINT_STYLE_CSV:\n       vector_separator = \", \";\n       vector_print_before = \"\";\n       vector_print_after = \"\";\n       array_opening_bracket = \"\";\n       array_closing_bracket = \"\";\n       array_contiguous_separator = \", \";\n       array_non_contiguous_separator = \"\\n\";\n       array_print_before = \"\";\n       array_print_after = \"\";\n       array_print_empty_before = \"empty\";\n       array_print_empty_after = \"\";\n       array_print_indent = false;\n       array_print_empty_rank = false;\n       break;\n    case PRINT_STYLE_MATLAB:\n       vector_separator = \" \";\n       vector_print_before = \"[\";\n       vector_print_after = \"]\";\n       array_opening_bracket = \"\";\n       array_closing_bracket = \"\";\n       array_contiguous_separator = \" \";\n       array_non_contiguous_separator = \";\\n\";\n       array_print_before = \"[\";\n       array_print_after = \"]\";\n       array_print_empty_before = \"[\";\n       array_print_empty_after = \"]\";\n       array_print_indent = true;\n       array_print_empty_rank = false;\n       break;\n    case PRINT_STYLE_CURLY:\n       vector_separator = \", \";\n       vector_print_before = \"{\";\n       vector_print_after = \"}\";\n       array_opening_bracket = \"{\";\n       array_closing_bracket = \"}\";\n       array_contiguous_separator = \", \";\n       array_non_contiguous_separator = \",\\n\";\n       array_print_before = \"\\n{\";\n       array_print_after = \"}\";\n       array_print_empty_before = \"(empty rank-\";\n       array_print_empty_after = \" array)\";\n       array_print_indent = true;\n       array_print_empty_rank = true;\n       break;\n    default:\n      //throw invalid_operation(\"Array print style not understood\");\n      printf(\"invalid operation\\n\");\n      assert(false);\n    }\n    array_print_style = ps;\n  }\n\n}\n\n\n// =================================================================\n// Contents of Stack.cpp\n// =================================================================\n\n/* Stack.cpp -- Stack for storing automatic differentiation information\n\n     Copyright (C) 2012-2014 University of Reading\n    Copyright (C) 2015 European Centre for Medium-Range Weather Forecasts\n\n    Author: Robin Hogan <r.j.hogan@ecmwf.int>\n\n    This file is part of the Adept library.\n\n*/\n\n\n#include <iostream>\n#include <cstring> // For memcpy\n\n\n\n#ifdef _OPENMP\n#include <omp.h>\n#endif\n\n#include <adept/Stack.h>\n\n\nnamespace adept {\n\n  using namespace internal;\n\n  // Global pointers to the current thread, the second of which is\n  // thread safe. The first is only used if ADEPT_STACK_THREAD_UNSAFE\n  // is defined.\n  ADEPT_THREAD_LOCAL Stack* _stack_current_thread = 0;\n  Stack* _stack_current_thread_unsafe = 0;\n\n  // MEMBER FUNCTIONS OF THE STACK CLASS\n\n  // Destructor: frees dynamically allocated memory (if any)\n  Stack::~Stack() {\n    // If this is the currently active stack then set to NULL as\n    // \"this\" is shortly to become invalid\n    if (is_thread_unsafe_) {\n      if (_stack_current_thread_unsafe == this) {\n\t_stack_current_thread_unsafe = 0; \n      }\n    }\n    else if (_stack_current_thread == this) {\n      _stack_current_thread = 0; \n    }\n#ifndef ADEPT_STACK_STORAGE_STL\n    if (gradient_) {\n      delete[] gradient_;\n    }\n#endif\n  }\n  \n  // Make this stack \"active\" by copying its \"this\" pointer to a\n  // global variable; this makes it the stack that aReal objects\n  // subsequently interact with when being created and participating\n  // in mathematical expressions\n  void\n  Stack::activate()\n  {\n    // Check that we don't already have an active stack in this thread\n    if ((is_thread_unsafe_ && _stack_current_thread_unsafe \n\t && _stack_current_thread_unsafe != this)\n\t|| ((!is_thread_unsafe_) && _stack_current_thread\n\t    && _stack_current_thread != this)) {\n      //throw(stack_already_active());\n      printf(\"stack already active\\n\");\n      assert(false);\n    }\n    else {\n      if (!is_thread_unsafe_) {\n\t_stack_current_thread = this;\n      }\n      else {\n\t_stack_current_thread_unsafe = this;\n      }\n    }    \n  }\n\n  \n  // Set the maximum number of threads to be used in Jacobian\n  // calculations, if possible. A value of 1 indicates that OpenMP\n  // will not be used, while a value of 0 indicates that the number\n  // will match the number of available processors. Returns the\n  // maximum that will be used, which will be 1 if the Adept library\n  // was compiled without OpenMP support. Note that a value of 1 will\n  // disable the use of OpenMP with Adept, so Adept will then use no\n  // OpenMP directives or function calls. Note that if in your program\n  // you use OpenMP with each thread performing automatic\n  // differentiaion with its own independent Adept stack, then\n  // typically only one OpenMP thread is available for each Jacobian\n  // calculation, regardless of whether you call this function.\n  int\n  Stack::set_max_jacobian_threads(int n)\n  {\n#ifdef _OPENMP\n    if (have_openmp_) {\n      if (n == 1) {\n\topenmp_manually_disabled_ = true;\n\treturn 1;\n      }\n      else if (n < 1) {\n\topenmp_manually_disabled_ = false;\n\tomp_set_num_threads(omp_get_num_procs());\n\treturn omp_get_max_threads();\n      }\n      else {\n\topenmp_manually_disabled_ = false;\n\tomp_set_num_threads(n);\n\treturn omp_get_max_threads();\n      }\n    }\n#endif\n    return 1;\n  }\n\n\n  // Return maximum number of OpenMP threads to be used in Jacobian\n  // calculation\n  int \n  Stack::max_jacobian_threads() const\n  {\n#ifdef _OPENMP\n    if (have_openmp_) {\n      if (openmp_manually_disabled_) {\n\treturn 1;\n      }\n      else {\n\treturn omp_get_max_threads();\n      }\n    }\n#endif\n    return 1;\n  }\n\n\n  // Perform to adjoint computation (reverse mode). It is assumed that\n  // some gradients have been assigned already, otherwise the function\n  // returns with an error.\n  void\n  Stack::compute_adjoint()\n  {\n    if (gradients_are_initialized()) {\n      // Loop backwards through the derivative statements\n      for (uIndex ist = n_statements_-1; ist > 0; ist--) {\n\tconst Statement& statement = statement_[ist];\n\t// We copy the RHS gradient (LHS in the original derivative\n\t// statement but swapped in the adjoint equivalent) to \"a\" in\n\t// case it appears on the LHS in any of the following statements\n\tReal a = gradient_[statement.index];\n\tgradient_[statement.index] = 0.0;\n\t// By only looping if a is non-zero we gain a significant speed-up\n\tif (a != 0.0) {\n\t  // Loop over operations\n\t  for (uIndex i = statement_[ist-1].end_plus_one;\n\t       i < statement.end_plus_one; i++) {\n\t    gradient_[index_[i]] += multiplier_[i]*a;\n\t  }\n\t}\n      }\n    }  \n    else {\n      //throw(gradients_not_initialized());\n      printf(\"gradients not initialized\\n\");\n      assert(false);\n    }  \n  }\n\n\n  // Perform tangent linear computation (forward mode). It is assumed\n  // that some gradients have been assigned already, otherwise the\n  // function returns with an error.\n  void\n  Stack::compute_tangent_linear()\n  {\n    if (gradients_are_initialized()) {\n      // Loop forward through the statements\n      for (uIndex ist = 1; ist < n_statements_; ist++) {\n\tconst Statement& statement = statement_[ist];\n\t// We copy the LHS to \"a\" in case it appears on the RHS in any\n\t// of the following statements\n\tReal a = 0.0;\n\tfor (uIndex i = statement_[ist-1].end_plus_one;\n\t     i < statement.end_plus_one; i++) {\n\t  a += multiplier_[i]*gradient_[index_[i]];\n\t}\n\tgradient_[statement.index] = a;\n      }\n    }\n    else {\n      //throw(gradients_not_initialized());\n      printf(\"gradients not initialized\\n\");\n      assert(false);\n    }\n  }\n\n\n\n  // Register n gradients\n  uIndex\n  Stack::do_register_gradients(const uIndex& n) {\n    n_gradients_registered_ += n;\n    if (!gap_list_.empty()) {\n      uIndex return_val;\n      // Insert in a gap, if there is one big enough\n      for (GapListIterator it = gap_list_.begin();\n\t   it != gap_list_.end(); it++) {\n\tuIndex len = it->end + 1 - it->start;\n\tif (len > n) {\n\t  // Gap a bit larger than needed: reduce its size\n\t  return_val = it->start;\n\t  it->start += n;\n\t  return return_val;\n\t}\n\telse if (len == n) {\n\t  // Gap exactly the size needed: fill it and remove from list\n\t  return_val = it->start;\n\t  if (most_recent_gap_ == it) {\n\t    gap_list_.erase(it);\n\t    most_recent_gap_ = gap_list_.end();\n\t  }\n\t  else {\n\t    gap_list_.erase(it);\n\t  }\n\t  return return_val;\n\t}\n      }\n    }\n    // No suitable gap found; instead add to end of gradient vector\n    i_gradient_ += n;\n    if (i_gradient_ > max_gradient_) {\n      max_gradient_ = i_gradient_;\n    }\n    return i_gradient_ - n;\n  }\n  \n\n  // If an aReal object is deleted, its gradient_index is\n  // unregistered from the stack.  If this is at the top of the stack\n  // then this is easy and is done inline; this is the usual case\n  // since C++ trys to deallocate automatic objects in the reverse\n  // order to that in which they were allocated.  If it is not at the\n  // top of the stack then a non-inline function is called to ensure\n  // that the gap list is adjusted correctly.\n  void\n  Stack::unregister_gradient_not_top(const uIndex& gradient_index)\n  {\n    enum {\n      ADDED_AT_BASE,\n      ADDED_AT_TOP,\n      NEW_GAP,\n      NOT_FOUND\n    } status = NOT_FOUND;\n    // First try to find if the unregistered element is at the\n    // start or end of an existing gap\n    if (!gap_list_.empty() && most_recent_gap_ != gap_list_.end()) {\n      // We have a \"most recent\" gap - check whether the gradient\n      // to be unregistered is here\n      Gap& current_gap = *most_recent_gap_;\n      if (gradient_index == current_gap.start - 1) {\n\tcurrent_gap.start--;\n\tstatus = ADDED_AT_BASE;\n      }\n      else if (gradient_index == current_gap.end + 1) {\n\tcurrent_gap.end++;\n\tstatus = ADDED_AT_TOP;\n      }\n      // Should we check for erroneous removal from middle of gap?\n    }\n    if (status == NOT_FOUND) {\n      // Search other gaps\n      for (GapListIterator it = gap_list_.begin();\n\t   it != gap_list_.end(); it++) {\n\tif (gradient_index <= it->end + 1) {\n\t  // Gradient to unregister is either within the gap\n\t  // referenced by iterator \"it\", or it is between \"it\"\n\t  // and the previous gap in the list\n\t  if (gradient_index == it->start - 1) {\n\t    status = ADDED_AT_BASE;\n\t    it->start--;\n\t    most_recent_gap_ = it;\n\t  }\n\t  else if (gradient_index == it->end + 1) {\n\t    status = ADDED_AT_TOP;\n\t    it->end++;\n\t    most_recent_gap_ = it;\n\t  }\n\t  else {\n\t    // Insert a new gap of width 1; note that list::insert\n\t    // inserts *before* the specified location\n\t    most_recent_gap_\n\t      = gap_list_.insert(it, Gap(gradient_index));\n\t    status = NEW_GAP;\n\t  }\n\t  break;\n\t}\n      }\n      if (status == NOT_FOUND) {\n\tgap_list_.push_back(Gap(gradient_index));\n\tmost_recent_gap_ = gap_list_.end();\n\tmost_recent_gap_--;\n      }\n    }\n    // Finally check if gaps have merged\n    if (status == ADDED_AT_BASE\n\t&& most_recent_gap_ != gap_list_.begin()) {\n      // Check whether the gap has merged with the next one\n      GapListIterator it = most_recent_gap_;\n      it--;\n      if (it->end == most_recent_gap_->start - 1) {\n\t// Merge two gaps\n\tmost_recent_gap_->start = it->start;\n\tgap_list_.erase(it);\n      }\n    }\n    else if (status == ADDED_AT_TOP) {\n      GapListIterator it = most_recent_gap_;\n      it++;\n      if (it != gap_list_.end()\n\t  && it->start == most_recent_gap_->end + 1) {\n\t// Merge two gaps\n\tmost_recent_gap_->end = it->end;\n\tgap_list_.erase(it);\n      }\n    }\n  }\t\n\n\n  // Unregister n gradients starting at gradient_index\n  void\n  Stack::unregister_gradients(const uIndex& gradient_index,\n\t\t\t      const uIndex& n)\n  {\n    n_gradients_registered_ -= n;\n    if (gradient_index+n == i_gradient_) {\n      // Gradient to be unregistered is at the top of the stack\n      i_gradient_ -= n;\n      if (!gap_list_.empty()) {\n\tGap& last_gap = gap_list_.back();\n\tif (i_gradient_ == last_gap.end+1) {\n\t  // We have unregistered the elements between the \"gap\" of\n\t  // unregistered element and the top of the stack, so can set\n\t  // the variables indicating the presence of the gap to zero\n\t  i_gradient_ = last_gap.start;\n\t  GapListIterator it = gap_list_.end();\n\t  it--;\n\t  if (most_recent_gap_ == it) {\n\t    most_recent_gap_ = gap_list_.end();\n\t  }\n\t  gap_list_.pop_back();\n\t}\n      }\n    }\n    else { // Gradients to be unregistered not at top of stack.\n      enum {\n\tADDED_AT_BASE,\n\tADDED_AT_TOP,\n\tNEW_GAP,\n\tNOT_FOUND\n      } status = NOT_FOUND;\n      // First try to find if the unregistered element is at the start\n      // or end of an existing gap\n      if (!gap_list_.empty() && most_recent_gap_ != gap_list_.end()) {\n\t// We have a \"most recent\" gap - check whether the gradient\n\t// to be unregistered is here\n\tGap& current_gap = *most_recent_gap_;\n\tif (gradient_index == current_gap.start - n) {\n\t  current_gap.start -= n;\n\t  status = ADDED_AT_BASE;\n\t}\n\telse if (gradient_index == current_gap.end + 1) {\n\t  current_gap.end += n;\n\t  status = ADDED_AT_TOP;\n\t}\n\t/*\n\telse if (gradient_index > current_gap.start - n\n\t\t && gradient_index < current_gap.end + 1) {\n\t  std::cout << \"** Attempt to find \" << gradient_index << \" in gaps \";\n\t  print_gaps();\n\t  std::cout << \"\\n\";\n\t  throw invalid_operation(\"Gap list corruption\");\n\t}\n\t*/\n\t// Should we check for erroneous removal from middle of gap?\n      }\n      if (status == NOT_FOUND) {\n\t// Search other gaps\n\tfor (GapListIterator it = gap_list_.begin();\n\t     it != gap_list_.end(); it++) {\n\t  if (gradient_index <= it->end + 1) {\n\t    // Gradient to unregister is either within the gap\n\t    // referenced by iterator \"it\", or it is between \"it\" and\n\t    // the previous gap in the list\n\t    if (gradient_index == it->start - n) {\n\t      status = ADDED_AT_BASE;\n\t      it->start -= n;\n\t      most_recent_gap_ = it;\n\t    }\n\t    else if (gradient_index == it->end + 1) {\n\t      status = ADDED_AT_TOP;\n\t      it->end += n;\n\t      most_recent_gap_ = it;\n\t    }\n\t    /*\n\t    else if (gradient_index > it->start - n) {\n\t      std::cout << \"*** Attempt to find \" << gradient_index << \" in gaps \";\n\t      print_gaps();\n\t      std::cout << \"\\n\";\n\t      throw invalid_operation(\"Gap list corruption\");\n\t    }\n\t    */\n\t    else {\n\t      // Insert a new gap; note that list::insert inserts\n\t      // *before* the specified location\n\t      most_recent_gap_\n\t\t= gap_list_.insert(it, Gap(gradient_index,\n\t\t\t\t\t   gradient_index+n-1));\n\t      status = NEW_GAP;\n\t    }\n\t    break;\n\t  }\n\t}\n\tif (status == NOT_FOUND) {\n\t  gap_list_.push_back(Gap(gradient_index,\n\t\t\t\t  gradient_index+n-1));\n\t  most_recent_gap_ = gap_list_.end();\n\t  most_recent_gap_--;\n\t}\n      }\n      // Finally check if gaps have merged\n      if (status == ADDED_AT_BASE\n\t  && most_recent_gap_ != gap_list_.begin()) {\n\t// Check whether the gap has merged with the next one\n\tGapListIterator it = most_recent_gap_;\n\tit--;\n\tif (it->end == most_recent_gap_->start - 1) {\n\t  // Merge two gaps\n\t  most_recent_gap_->start = it->start;\n\t  gap_list_.erase(it);\n\t}\n      }\n      else if (status == ADDED_AT_TOP) {\n\tGapListIterator it = most_recent_gap_;\n\n\tit++;\n\tif (it != gap_list_.end()\n\t    && it->start == most_recent_gap_->end + 1) {\n\t  // Merge two gaps\n\t  most_recent_gap_->end = it->end;\n\t  gap_list_.erase(it);\n\t}\n      }\n    }\n  }\n  \n  \n  // Print each derivative statement to the specified stream (standard\n  // output if omitted)\n  void\n  Stack::print_statements(std::ostream& os) const\n  {\n    for (uIndex ist = 1; ist < n_statements_; ist++) {\n      const Statement& statement = statement_[ist];\n      os << ist\n\t\t<< \": d[\" << statement.index\n\t\t<< \"] = \";\n      \n      if (statement_[ist-1].end_plus_one == statement_[ist].end_plus_one) {\n\tos << \"0\\n\";\n      }\n      else {    \n\tfor (uIndex i = statement_[ist-1].end_plus_one;\n\t     i < statement.end_plus_one; i++) {\n\t  os << \" + \" << multiplier_[i] << \"*d[\" << index_[i] << \"]\";\n\t}\n\tos << \"\\n\";\n      }\n    }\n  }\n  \n  // Print the current gradient list to the specified stream (standard\n  // output if omitted)\n  bool\n  Stack::print_gradients(std::ostream& os) const\n  {\n    if (gradients_are_initialized()) {\n      for (uIndex i = 0; i < max_gradient_; i++) {\n\tif (i%10 == 0) {\n\t  if (i != 0) {\n\t    os << \"\\n\";\n\t  }\n\t  os << i << \":\";\n\t}\n\tos << \" \" << gradient_[i];\n      }\n      os << \"\\n\";\n      return true;\n    }\n    else {\n      os << \"No gradients initialized\\n\";\n      return false;\n    }\n  }\n\n  // Print the list of gaps in the gradient list to the specified\n  // stream (standard output if omitted)\n  void\n  Stack::print_gaps(std::ostream& os) const\n  {\n    for (std::list<Gap>::const_iterator it = gap_list_.begin();\n\t it != gap_list_.end(); it++) {\n      os << it->start << \"-\" << it->end << \" \";\n    }\n  }\n\n\n#ifndef ADEPT_STACK_STORAGE_STL\n  // Initialize the vector of gradients ready for the adjoint\n  // calculation\n  void\n  Stack::initialize_gradients()\n  {\n    if (max_gradient_ > 0) {\n      if (n_allocated_gradients_ < max_gradient_) {\n\tif (gradient_) {\n\t  delete[] gradient_;\n\t}\n\tgradient_ = new Real[max_gradient_];\n\tn_allocated_gradients_ = max_gradient_;\n      }\n      for (uIndex i = 0; i < max_gradient_; i++) {\n\tgradient_[i] = 0.0;\n      }\n    }\n    gradients_initialized_ = true;\n  }\n#else\n  void\n  Stack::initialize_gradients()\n  {\n    gradient_.resize(max_gradient_+10, 0.0);\n      gradients_initialized_ = true;\n  }\n#endif\n\n  // Report information about the stack to the specified stream, or\n  // standard output if omitted; note that this is synonymous with\n  // sending the Stack object to a stream using the \"<<\" operator.\n  void\n  Stack::print_status(std::ostream& os) const\n  {\n    os << \"Automatic Differentiation Stack (address \" << this << \"):\\n\";\n    if ((!is_thread_unsafe_) && _stack_current_thread == this) {\n      os << \"   Currently attached - thread safe\\n\";\n    }\n    else if (is_thread_unsafe_ && _stack_current_thread_unsafe == this) {\n      os << \"   Currently attached - thread unsafe\\n\";\n    }\n    else {\n      os << \"   Currently detached\\n\";\n    }\n    os << \"   Recording status:\\n\";\n    if (is_recording_) {\n      os << \"      Recording is ON\\n\";  \n    }\n    else {\n      os << \"      Recording is PAUSED\\n\";\n    }\n    // Account for the null statement at the start by subtracting one\n    os << \"      \" << n_statements()-1 << \" statements (\" \n       << n_allocated_statements() << \" allocated)\";\n    os << \" and \" << n_operations() << \" operations (\" \n       << n_allocated_operations() << \" allocated)\\n\";\n    os << \"      \" << n_gradients_registered() << \" gradients currently registered \";\n    os << \"and a total of \" << max_gradients() << \" needed (current index \"\n       << i_gradient() << \")\\n\";\n    if (gap_list_.empty()) {\n      os << \"      Gradient list has no gaps\\n\";\n    }\n    else {\n      os << \"      Gradient list has \" << gap_list_.size() << \" gaps (\";\n      print_gaps(os);\n      os << \")\\n\";\n    }\n    os << \"   Computation status:\\n\";\n    if (gradients_are_initialized()) {\n      os << \"      \" << max_gradients() << \" gradients assigned (\" \n\t << n_allocated_gradients() << \" allocated)\\n\";\n    }\n    else {\n      os << \"      0 gradients assigned (\" << n_allocated_gradients()\n\t << \" allocated)\\n\";\n    }\n    os << \"      Jacobian size: \" << n_dependents() << \"x\" << n_independents() << \"\\n\";\n    if (n_dependents() <= 10 && n_independents() <= 10) {\n      os << \"      Independent indices:\";\n      for (std::size_t i = 0; i < independent_index_.size(); ++i) {\n\tos << \" \" << independent_index_[i];\n      }\n      os << \"\\n      Dependent indices:  \";\n      for (std::size_t i = 0; i < dependent_index_.size(); ++i) {\n\tos << \" \" << dependent_index_[i];\n      }\n      os << \"\\n\";\n    }\n\n#ifdef _OPENMP\n    if (have_openmp_) {\n      if (openmp_manually_disabled_) {\n\tos << \"      Parallel Jacobian calculation manually disabled\\n\";\n      }\n      else {\n\tos << \"      Parallel Jacobian calculation can use up to \"\n\t   << omp_get_max_threads() << \" threads\\n\";\n\tos << \"      Each thread treats \" << ADEPT_MULTIPASS_SIZE \n\t   << \" (in)dependent variables\\n\";\n      }\n    }\n    else {\n#endif\n      os << \"      Parallel Jacobian calculation not available\\n\";\n#ifdef _OPENMP\n    }\n#endif\n  }\n} // End namespace adept\n\n\n\n// =================================================================\n// Contents of StackStorageOrig.cpp\n// =================================================================\n\n/* StackStorageOrig.cpp -- Original storage of stacks using STL containers\n\n    Copyright (C) 2014-2015 University of Reading\n\n    Author: Robin Hogan <r.j.hogan@ecmwf.int>\n\n    This file is part of the Adept library.\n\n   The Stack class inherits from a class providing the storage (and\n   interface to the storage) for the derivative statements that are\n   accumulated during the execution of an algorithm.  The derivative\n   statements are held in two stacks described by Hogan (2014): the\n   \"statement stack\" and the \"operation stack\".\n\n   This file provides one of the original storage engine, which used\n   std::vector to hold the two stacks. Note that these stacks are\n   contiguous in memory, which is not ideal for very large algorithms.\n\n*/\n\n#include <cstring>\n\n#include <adept/StackStorageOrig.h>\n\nnamespace adept {\n  namespace internal {\n\n    StackStorageOrig::~StackStorageOrig() {\n      if (statement_) {\n\tdelete[] statement_;\n      }\n      if (multiplier_) {\n\tdelete[] multiplier_;\n      }\n      if (index_) {\n\tdelete[] index_;\n      }\n    }\n\n\n    // Double the size of the operation stack, or grow it even more if\n    // the requested minimum number of extra entries (min) is greater\n    // than this would allow\n    void\n    StackStorageOrig::grow_operation_stack(uIndex min)\n    {\n      uIndex new_size = 2*n_allocated_operations_;\n      if (min > 0 && new_size < n_allocated_operations_+min) {\n\tnew_size += min;\n      }\n      Real* new_multiplier = new Real[new_size];\n      uIndex* new_index = new uIndex[new_size];\n      \n      std::memcpy(new_multiplier, multiplier_, n_operations_*sizeof(Real));\n      std::memcpy(new_index, index_, n_operations_*sizeof(uIndex));\n      \n      delete[] multiplier_;\n      delete[] index_;\n      \n      multiplier_ = new_multiplier;\n      index_ = new_index;\n      \n      n_allocated_operations_ = new_size;\n    }\n    \n    // ... likewise for the statement stack\n    void\n    StackStorageOrig::grow_statement_stack(uIndex min)\n    {\n      uIndex new_size = 2*n_allocated_statements_;\n      if (min > 0 && new_size < n_allocated_statements_+min) {\n\tnew_size += min;\n      }\n      Statement* new_statement = new Statement[new_size];\n      std::memcpy(new_statement, statement_,\n\t\t  n_statements_*sizeof(Statement));\n      delete[] statement_;\n      \n      statement_ = new_statement;\n      \n      n_allocated_statements_ = new_size;\n    }\n\n  }\n}\n\n\n// =================================================================\n// Contents of Storage.cpp\n// =================================================================\n\n/* Storage.cpp -- Global variables recording use of Storage objects\n\n    Copyright (C) 2015 European Centre for Medium-Range Weather Forecasts\n\n    Author: Robin Hogan <r.j.hogan@ecmwf.int>\n\n    This file is part of the Adept library.\n\n*/\n\n#include <adept/Storage.h>\n\nnamespace adept {\n  namespace internal {\n    Index n_storage_objects_created_;\n    Index n_storage_objects_deleted_;\n  }\n}\n\n\n// =================================================================\n// Contents of cppblas.cpp\n// =================================================================\n\n/* cppblas.cpp -- C++ interface to BLAS functions\n\n    Copyright (C) 2015-2016 European Centre for Medium-Range Weather Forecasts\n\n    Author: Robin Hogan <r.j.hogan@ecmwf.int>\n\n    This file is part of the Adept library.\n\n   This file provides a C++ interface to selected Level-2 and -3 BLAS\n   functions in which the precision of the arguments (float versus\n   double) is inferred via overloading\n\n*/\n\n#include <adept/exception.h>\n#include <adept/cppblas.h>\n\n#ifdef HAVE_CONFIG_H\n#include \"config.h\"\n#endif\n\n#ifdef HAVE_BLAS\n\nextern \"C\" {\n  void sgemm_(const char* TransA, const char* TransB, const int* M,\n\t      const int* N, const int* K, const float* alpha,\n\t      const float* A, const int* lda, const float* B, const int* ldb,\n\t      const float* beta, const float* C, const int* ldc);\n  void dgemm_(const char* TransA, const char* TransB, const int* M,\n\t      const int* N, const int* K, const double* alpha,\n\t      const double* A, const int* lda, const double* B, const int* ldb,\n\t      const double* beta, const double* C, const int* ldc);\n  void sgemv_(const char* TransA, const int* M, const int* N, const float* alpha,\n\t      const float* A, const int* lda, const float* X, const int* incX,\n\t      const float* beta, const float* Y, const int* incY);\n  void dgemv_(const char* TransA, const int* M, const int* N, const double* alpha,\n\t      const double* A, const int* lda, const double* X, const int* incX,\n\t      const double* beta, const double* Y, const int* incY);\n  void ssymm_(const char* side, const char* uplo, const int* M, const int* N,\n\t      const float* alpha, const float* A, const int* lda, const float* B,\n\t      const int* ldb, const float* beta, float* C, const int* ldc);\n  void dsymm_(const char* side, const char* uplo, const int* M, const int* N,\n\t      const double* alpha, const double* A, const int* lda, const double* B,\n\t      const int* ldb, const double* beta, double* C, const int* ldc);\n  void ssymv_(const char* uplo, const int* N, const float* alpha, const float* A, \n\t      const int* lda, const float* X, const int* incX, const float* beta, \n\t      const float* Y, const int* incY);\n  void dsymv_(const char* uplo, const int* N, const double* alpha, const double* A, \n\t      const int* lda, const double* X, const int* incX, const double* beta, \n\t      const double* Y, const int* incY);\n  void sgbmv_(const char* TransA, const int* M, const int* N, const int* kl, \n\t      const int* ku, const float* alpha, const float* A, const int* lda,\n\t      const float* X, const int* incX, const float* beta, \n\t      const float* Y, const int* incY);\n  void dgbmv_(const char* TransA, const int* M, const int* N, const int* kl, \n\t      const int* ku, const double* alpha, const double* A, const int* lda,\n\t      const double* X, const int* incX, const double* beta, \n\t      const double* Y, const int* incY);\n};\n\nnamespace adept {\n\n  namespace internal {\n    \n    // Matrix-matrix multiplication for general dense matrices\n#define ADEPT_DEFINE_GEMM(T, FUNC, FUNC_COMPLEX)\t\t\\\n    void cppblas_gemm(BLAS_ORDER Order,\t\t\t\t\\\n\t\t      BLAS_TRANSPOSE TransA,\t\t\t\\\n\t\t      BLAS_TRANSPOSE TransB,\t\t\t\\\n\t\t      int M, int N,\t\t\t\t\\\n\t\t      int K, T alpha, const T *A,\t\t\\\n\t\t      int lda, const T *B, int ldb,\t\t\\\n\t\t      T beta, T *C, int ldc) {\t\t\t\\\n      if (Order == BlasColMajor) {\t\t\t\t\\\n        FUNC(&TransA, &TransB, &M, &N, &K, &alpha, A, &lda,\t\\\n\t     B, &ldb, &beta, C, &ldc);\t\t\t\t\\\n      }\t\t\t\t\t\t\t\t\\\n      else {\t\t\t\t\t\t\t\\\n        FUNC(&TransB, &TransA, &N, &M, &K, &alpha, B, &ldb,\t\\\n\t     A, &lda, &beta, C, &ldc);\t\t\t\t\\\n      }\t\t\t\t\t\t\t\t\\\n    }\n    ADEPT_DEFINE_GEMM(double, dgemm_, zgemm_);\n    ADEPT_DEFINE_GEMM(float,  sgemm_, cgemm_);\n#undef ADEPT_DEFINE_GEMM\n    \n    // Matrix-vector multiplication for a general dense matrix\n#define ADEPT_DEFINE_GEMV(T, FUNC, FUNC_COMPLEX)\t\t\\\n    void cppblas_gemv(const BLAS_ORDER Order,\t\t\t\\\n\t\t      const BLAS_TRANSPOSE TransA,\t\t\\\n\t\t      const int M, const int N,\t\t\t\\\n\t\t      const T alpha, const T *A, const int lda,\t\\\n\t\t      const T *X, const int incX, const T beta,\t\\\n\t\t      T *Y, const int incY) {\t\t\t\\\n      if (Order == BlasColMajor) {\t\t\t\t\\\n        FUNC(&TransA, &M, &N, &alpha, A, &lda, X, &incX, \t\\\n\t     &beta, Y, &incY);\t\t\t\t\t\\\n      }\t\t\t\t\t\t\t\t\\\n      else {\t\t\t\t\t\t\t\\\n        BLAS_TRANSPOSE TransNew\t\t\t\t\t\\\n\t  = TransA == BlasTrans ? BlasNoTrans : BlasTrans;\t\\\n        FUNC(&TransNew, &N, &M, &alpha, A, &lda, X, &incX, \t\\\n\t     &beta, Y, &incY);\t\t\t\t\t\\\n      }\t\t\t\t\t\t\t\t\\\n    }\n    ADEPT_DEFINE_GEMV(double, dgemv_, zgemv_);\n    ADEPT_DEFINE_GEMV(float,  sgemv_, cgemv_);\n#undef ADEPT_DEFINE_GEMV\n    \n    // Matrix-matrix multiplication where matrix A is symmetric\n    // FIX! CHECK ROW MAJOR VERSION IS RIGHT\t\t\t\n#define ADEPT_DEFINE_SYMM(T, FUNC, FUNC_COMPLEX)\t\t\t\\\n    void cppblas_symm(const BLAS_ORDER Order,\t\t\t\t\\\n\t\t      const BLAS_SIDE Side,\t\t\t\t\\\n\t\t      const BLAS_UPLO Uplo,\t\t\t\t\\\n\t\t      const int M, const int N,\t\t\t\t\\\n\t\t      const T alpha, const T *A, const int lda,\t\t\\\n\t\t      const T *B, const int ldb, const T beta,\t\t\\\n\t\t      T *C, const int ldc) {\t\t\t\t\\\n      if (Order == BlasColMajor) {\t\t\t\t\t\\\n        FUNC(&Side, &Uplo, &M, &N, &alpha, A, &lda,\t\t\t\\\n\t     B, &ldb, &beta, C, &ldc);\t\t\t\t\t\\\n      }\t\t\t\t\t\t\t\t\t\\\n      else {\t\t\t\t\t\t\t\t\\\n\tBLAS_SIDE SideNew = Side == BlasLeft  ? BlasRight : BlasLeft;\t\\\n\tBLAS_UPLO UploNew = Uplo == BlasUpper ? BlasLower : BlasUpper;  \\\n        FUNC(&SideNew, &UploNew, &N, &M, &alpha, A, &lda,\t\t\\\n\t     B, &ldb, &beta, C, &ldc);\t\t\t\t\t\\\n      }\t\t\t\t\t\t\t\t\t\\\n    }\n    ADEPT_DEFINE_SYMM(double, dsymm_, zsymm_);\n    ADEPT_DEFINE_SYMM(float,  ssymm_, csymm_);\n#undef ADEPT_DEFINE_SYMM\n    \n    // Matrix-vector multiplication where the matrix is symmetric\n#define ADEPT_DEFINE_SYMV(T, FUNC, FUNC_COMPLEX)\t\t\t\\\n    void cppblas_symv(const BLAS_ORDER Order,\t\t\t\t\\\n\t\t      const BLAS_UPLO Uplo,\t\t\t\t\\\n\t\t      const int N, const T alpha, const T *A,\t\t\\\n\t\t      const int lda, const T *X, const int incX,\t\\\n\t\t      const T beta, T *Y, const int incY) {\t\t\\\n      if (Order == BlasColMajor) {\t\t\t\t\t\\\n        FUNC(&Uplo, &N, &alpha, A, &lda, X, &incX, &beta, Y, &incY);\t\\\n      }\t\t\t\t\t\t\t\t\t\\\n      else {\t\t\t\t\t\t\t\t\\\n        BLAS_UPLO UploNew = Uplo == BlasUpper ? BlasLower : BlasUpper;  \\\n        FUNC(&UploNew, &N, &alpha, A, &lda, X, &incX, &beta, Y, &incY);\t\\\n      }\t\t\t\t\t\t\t\t\t\\\n    }\n    ADEPT_DEFINE_SYMV(double, dsymv_, zsymv_);\n    ADEPT_DEFINE_SYMV(float,  ssymv_, csymv_);\n#undef ADEPT_DEFINE_SYMV\n    \n    // Matrix-vector multiplication for a general band matrix\n#define ADEPT_DEFINE_GBMV(T, FUNC, FUNC_COMPLEX)\t\t\\\n    void cppblas_gbmv(const BLAS_ORDER Order,\t\t\t\\\n\t\t      const BLAS_TRANSPOSE TransA,\t\t\\\n\t\t      const int M, const int N,\t\t\t\\\n\t\t      const int KL, const int KU, const T alpha,\\\n\t\t      const T *A, const int lda, const T *X,\t\\\n\t\t      const int incX, const T beta, T *Y,\t\\\n\t\t      const int incY) {\t\t\t\t\\\n      if (Order == BlasColMajor) {\t\t\t\t\\\n        FUNC(&TransA, &M, &N, &KL, &KU, &alpha, A, &lda,\t\\\n\t     X, &incX, &beta, Y, &incY);\t\t\t\\\n      }\t\t\t\t\t\t\t\t\\\n      else {\t\t\t\t\t\t\t\\\n\tBLAS_TRANSPOSE TransNew\t\t\t\t\t\\\n\t  = TransA == BlasTrans ? BlasNoTrans : BlasTrans;\t\\\n\tFUNC(&TransNew, &N, &M, &KU, &KL, &alpha, A, &lda,\t\\\n\t     X, &incX, &beta, Y, &incY);\t\t\t\\\n      }\t\t\t\t\t\t\t\t\\\n    }\n    ADEPT_DEFINE_GBMV(double, dgbmv_, zgbmv_);\n    ADEPT_DEFINE_GBMV(float,  sgbmv_, cgbmv_);\n#undef ADEPT_DEFINE_GBMV\n  \n  } // End namespace internal\n  \n} // End namespace adept\n  \n\n#else // Don't have BLAS\n\n\nnamespace adept {\n\n  namespace internal {\n    \n    // Matrix-matrix multiplication for general dense matrices\n#define ADEPT_DEFINE_GEMM(T, FUNC, FUNC_COMPLEX)\t\t\\\n    void cppblas_gemm(BLAS_ORDER Order,\t\t\t\t\\\n\t\t      BLAS_TRANSPOSE TransA,\t\t\t\\\n\t\t      BLAS_TRANSPOSE TransB,\t\t\t\\\n\t\t      int M, int N,\t\t\t\t\\\n\t\t      int K, T alpha, const T *A,\t\t\\\n\t\t      int lda, const T *B, int ldb,\t\t\\\n\t\t      T beta, T *C, int ldc) {\t\t\t\\\n      throw feature_not_available(\"Cannot perform matrix-matrix multiplication because compiled without BLAS\"); \\\n    }\n    ADEPT_DEFINE_GEMM(double, dgemm_, zgemm_);\n    ADEPT_DEFINE_GEMM(float,  sgemm_, cgemm_);\n#undef ADEPT_DEFINE_GEMM\n    \n    // Matrix-vector multiplication for a general dense matrix\n#define ADEPT_DEFINE_GEMV(T, FUNC, FUNC_COMPLEX)\t\t\\\n    void cppblas_gemv(const BLAS_ORDER Order,\t\t\t\\\n\t\t      const BLAS_TRANSPOSE TransA,\t\t\\\n\t\t      const int M, const int N,\t\t\t\\\n\t\t      const T alpha, const T *A, const int lda,\t\\\n\t\t      const T *X, const int incX, const T beta,\t\\\n\t\t      T *Y, const int incY) {\t\t\t\\\n      throw feature_not_available(\"Cannot perform matrix-vector multiplication because compiled without BLAS\"); \\\n    }\n    ADEPT_DEFINE_GEMV(double, dgemv_, zgemv_);\n    ADEPT_DEFINE_GEMV(float,  sgemv_, cgemv_);\n#undef ADEPT_DEFINE_GEMV\n    \n    // Matrix-matrix multiplication where matrix A is symmetric\n    // FIX! CHECK ROW MAJOR VERSION IS RIGHT\t\t\t\n#define ADEPT_DEFINE_SYMM(T, FUNC, FUNC_COMPLEX)\t\t\t\\\n    void cppblas_symm(const BLAS_ORDER Order,\t\t\t\t\\\n\t\t      const BLAS_SIDE Side,\t\t\t\t\\\n\t\t      const BLAS_UPLO Uplo,\t\t\t\t\\\n\t\t      const int M, const int N,\t\t\t\t\\\n\t\t      const T alpha, const T *A, const int lda,\t\t\\\n\t\t      const T *B, const int ldb, const T beta,\t\t\\\n\t\t      T *C, const int ldc) {\t\t\t\t\\\n      throw feature_not_available(\"Cannot perform symmetric matrix-matrix multiplication because compiled without BLAS\"); \\\n    }\n    ADEPT_DEFINE_SYMM(double, dsymm_, zsymm_);\n    ADEPT_DEFINE_SYMM(float,  ssymm_, csymm_);\n#undef ADEPT_DEFINE_SYMM\n    \n    // Matrix-vector multiplication where the matrix is symmetric\n#define ADEPT_DEFINE_SYMV(T, FUNC, FUNC_COMPLEX)\t\t\t\\\n    void cppblas_symv(const BLAS_ORDER Order,\t\t\t\t\\\n\t\t      const BLAS_UPLO Uplo,\t\t\t\t\\\n\t\t      const int N, const T alpha, const T *A,\t\t\\\n\t\t      const int lda, const T *X, const int incX,\t\\\n\t\t      const T beta, T *Y, const int incY) {\t\t\\\n      throw feature_not_available(\"Cannot perform symmetric matrix-vector multiplication because compiled without BLAS\"); \\\n    }\n    ADEPT_DEFINE_SYMV(double, dsymv_, zsymv_);\n    ADEPT_DEFINE_SYMV(float,  ssymv_, csymv_);\n#undef ADEPT_DEFINE_SYMV\n    \n    // Matrix-vector multiplication for a general band matrix\n#define ADEPT_DEFINE_GBMV(T, FUNC, FUNC_COMPLEX)\t\t\\\n    void cppblas_gbmv(const BLAS_ORDER Order,\t\t\t\\\n\t\t      const BLAS_TRANSPOSE TransA,\t\t\\\n\t\t      const int M, const int N,\t\t\t\\\n\t\t      const int KL, const int KU, const T alpha,\\\n\t\t      const T *A, const int lda, const T *X,\t\\\n\t\t      const int incX, const T beta, T *Y,\t\\\n\t\t      const int incY) {\t\t\t\t\\\n      throw feature_not_available(\"Cannot perform band matrix-vector multiplication because compiled without BLAS\"); \\\n    }\n    ADEPT_DEFINE_GBMV(double, dgbmv_, zgbmv_);\n    ADEPT_DEFINE_GBMV(float,  sgbmv_, cgbmv_);\n#undef ADEPT_DEFINE_GBMV\n\n  }\n}\n\n#endif\n\n\n// =================================================================\n// Contents of index.cpp\n// =================================================================\n\n/* index.cpp -- Definitions of \"end\" and \"__\" for array indexing\n\n    Copyright (C) 2015 European Centre for Medium-Range Weather Forecasts\n\n    Robin Hogan <r.j.hogan@ecmwf.int>\n\n    This file is part of the Adept library.\n*/\n\n#include <adept/RangeIndex.h>\n\nnamespace adept {\n\n  ::adept::internal::EndIndex end;\n  ::adept::internal::AllIndex __;\n\n}\n\n\n// =================================================================\n// Contents of inv.cpp\n// =================================================================\n\n/* inv.cpp -- Invert matrices\n\n    Copyright (C) 2015-2016 European Centre for Medium-Range Weather Forecasts\n\n    Author: Robin Hogan <r.j.hogan@ecmwf.int>\n\n    This file is part of the Adept library.\n*/\n                             \n#include <vector>\n\n#include <adept/Array.h>\n#include <adept/SpecialMatrix.h>\n\n#ifndef AdeptSource_H\n#include \"cpplapack.h\"\n#endif\n\n#ifdef HAVE_LAPACK\n\nnamespace adept {\n\n  // -------------------------------------------------------------------\n  // Invert general square matrix A\n  // -------------------------------------------------------------------\n  template <typename Type>\n  Array<2,Type,false> \n  inv(const Array<2,Type,false>& A) {\n    using internal::cpplapack_getrf;\n    using internal::cpplapack_getri;\n\n    if (A.dimension(0) != A.dimension(1)) {\n      //throw invalid_operation(\"Only square matrices can be inverted\"\n\t//\t\t      ADEPT_EXCEPTION_LOCATION);\n      printf(\"invalid operation\\n\");\n      assert(false);\n    }\n\n    Array<2,Type,false> A_;\n\n    // LAPACKE is more efficient with column-major input\n    A_.resize_column_major(A.dimensions());\n    A_ = A;\n\n    std::vector<lapack_int> ipiv(A_.dimension(0));\n\n    //    lapack_int status = LAPACKE_dgetrf(LAPACK_COL_MAJOR, A_.dimension(0), A_.dimension(1),\n    //\t\t\t\t       A_.data(), A_.offset(1), &ipiv[0]);\n\n    lapack_int status = cpplapack_getrf(A_.dimension(0),\n\t\t\t\t\tA_.data(), A_.offset(1), &ipiv[0]);\n    if (status != 0) {\n      std::stringstream s;\n      s << \"Failed to factorize matrix: LAPACK ?getrf returned code \" << status;\n      //throw(matrix_ill_conditioned(s.str() ADEPT_EXCEPTION_LOCATION));\n      printf(\"matrix ill conditioned\\n\");\n      assert(false);\n    }\n\n    //    status = LAPACKE_dgetri(LAPACK_COL_MAJOR, A_.dimension(0),\n    //\t\t\t    A_.data(), A_.offset(1), &ipiv[0]);\n    status = cpplapack_getri(A_.dimension(0),\n\t\t\t     A_.data(), A_.offset(1), &ipiv[0]);\n\n    if (status != 0) {\n      std::stringstream s;\n      s << \"Failed to invert matrix: LAPACK ?getri returned code \" << status;\n      //throw(matrix_ill_conditioned(s.str() ADEPT_EXCEPTION_LOCATION));\n      printf(\"matrix ill conditioned\\n\");\n      assert(false);\n    }\n    return A_;\n  }\n\n\n\n  // -------------------------------------------------------------------\n  // Invert symmetric matrix A\n  // -------------------------------------------------------------------\n  template <typename Type, SymmMatrixOrientation Orient>\n  SpecialMatrix<Type,SymmEngine<Orient>,false> \n  inv(const SpecialMatrix<Type,SymmEngine<Orient>,false>& A) {\n    using internal::cpplapack_sytrf;\n    using internal::cpplapack_sytri;\n\n    SpecialMatrix<Type,SymmEngine<Orient>,false> A_;\n\n    A_.resize(A.dimension());\n    A_ = A;\n\n    // Treat symmetric matrix as column-major\n    char uplo;\n    if (Orient == ROW_LOWER_COL_UPPER) {\n      uplo = 'U';\n    }\n    else {\n      uplo = 'L';\n    }\n\n    std::vector<lapack_int> ipiv(A_.dimension(0));\n\n    //    lapack_int status = LAPACKE_dsytrf(LAPACK_COL_MAJOR, uplo, A_.dimension(),\n    //\t\t\t\t       A_.data(), A_.offset(), &ipiv[0]);\n    lapack_int status = cpplapack_sytrf(uplo, A_.dimension(),\n\t\t\t\t\tA_.data(), A_.offset(), &ipiv[0]);\n    if (status != 0) {\n      std::stringstream s;\n      s << \"Failed to factorize symmetric matrix: LAPACK ?sytrf returned code \" << status;\n      //throw(matrix_ill_conditioned(s.str() ADEPT_EXCEPTION_LOCATION));\n      printf(\"matrix ill conditioned\\n\");\n      assert(false);\n    }\n\n    //    status = LAPACKE_dsytri(LAPACK_COL_MAJOR, uplo, A_.dimension(),\n    //\t\t\t    A_.data(), A_.offset(), &ipiv[0]);\n    status = cpplapack_sytri(uplo, A_.dimension(),\n\t\t\t     A_.data(), A_.offset(), &ipiv[0]);\n    if (status != 0) {\n      std::stringstream s;\n      s << \"Failed to invert symmetric matrix: LAPACK ?sytri returned code \" << status;\n      //throw(matrix_ill_conditioned(s.str() ADEPT_EXCEPTION_LOCATION));\n      printf(\"matrix ill conditioned\\n\");\n      assert(false);\n    }\n    return A_;\n  }\n\n}\n\n#else // LAPACK not available\n    \nnamespace adept {\n\n  // -------------------------------------------------------------------\n  // Invert general square matrix A\n  // -------------------------------------------------------------------\n  template <typename Type>\n  Array<2,Type,false> \n  inv(const Array<2,Type,false>& A) {\n    //throw feature_not_available(\"Cannot invert matrix because compiled without LAPACK\");\n    printf(\"feature not available\\n\");\n    assert(false);\n  }\n\n  // -------------------------------------------------------------------\n  // Invert symmetric matrix A\n  // -------------------------------------------------------------------\n  template <typename Type, SymmMatrixOrientation Orient>\n  SpecialMatrix<Type,SymmEngine<Orient>,false> \n  inv(const SpecialMatrix<Type,SymmEngine<Orient>,false>& A) {\n    //throw feature_not_available(\"Cannot invert matrix because compiled without LAPACK\");\n    printf(\"feature not available\\n\");\n    assert(false);\n  }\n  \n}\n\n#endif\n\nnamespace adept {\n  // -------------------------------------------------------------------\n  // Explicit instantiations\n  // -------------------------------------------------------------------\n#define ADEPT_EXPLICIT_INV(TYPE)\t\t\t\t\t\\\n  template Array<2,TYPE,false>\t\t\t\t\t\t\\\n  inv(const Array<2,TYPE,false>& A);\t\t\t\t\t\\\n  template SpecialMatrix<TYPE,SymmEngine<ROW_LOWER_COL_UPPER>,false>\t\\\n  inv(const SpecialMatrix<TYPE,SymmEngine<ROW_LOWER_COL_UPPER>,false>&); \\\n  template SpecialMatrix<TYPE,SymmEngine<ROW_UPPER_COL_LOWER>,false>\t\\\n  inv(const SpecialMatrix<TYPE,SymmEngine<ROW_UPPER_COL_LOWER>,false>&)\n\n  ADEPT_EXPLICIT_INV(float);\n  ADEPT_EXPLICIT_INV(double);\n\n#undef ADEPT_EXPLICIT_INV\n  \n}\n\n\n\n\n// =================================================================\n// Contents of jacobian.cpp\n// =================================================================\n\n/* jacobian.cpp -- Computation of Jacobian matrix\n\n    Copyright (C) 2012-2014 University of Reading\n    Copyright (C) 2015-2016 European Centre for Medium-Range Weather Forecasts\n\n    Author: Robin Hogan <r.j.hogan@ecmwf.int>\n\n    This file is part of the Adept library.\n\n*/\n\n#ifdef _OPENMP\n#include <omp.h>\n#endif\n\n#include \"adept/Stack.h\"\n#include \"adept/Packet.h\"\n#include \"adept/traits.h\"\n\nnamespace adept {\n\n  namespace internal {\n    static const int MULTIPASS_SIZE = ADEPT_REAL_PACKET_SIZE == 1 ? ADEPT_MULTIPASS_SIZE : ADEPT_REAL_PACKET_SIZE;\n  }\n\n  using namespace internal;\n\n  template <typename T>\n  T _check_long_double() {\n    // The user may have requested Real to be of type \"long double\" by\n    // specifying ADEPT_REAL_TYPE_SIZE=16. If the present system can\n    // only support double then sizeof(long double) will be 8, but\n    // Adept will not be emitting the best code for this, so it is\n    // probably better to fail forcing the user to specify\n    // ADEPT_REAL_TYPE_SIZE=8.\n    ADEPT_STATIC_ASSERT(ADEPT_REAL_TYPE_SIZE != 16 || ADEPT_REAL_TYPE_SIZE == sizeof(Real),\n\t\t\tCOMPILER_DOES_NOT_SUPPORT_16_BYTE_LONG_DOUBLE);\n    return 1;\n  }\n\n  /*\n  void\n  Stack::jacobian_forward_kernel(Real* gradient_multipass_b) const\n  {\n    static const int MULTIPASS_SIZE = Packet<Real>::size;\n\n    // Loop forward through the derivative statements\n    for (uIndex ist = 1; ist < n_statements_; ist++) {\n      const Statement& statement = statement_[ist];\n      // We copy the LHS to \"a\" in case it appears on the RHS in any\n      // of the following statements\n      Block<MULTIPASS_SIZE,Real> a; // Initialized to zero automatically\n      \n      // Loop through operations\n      for (uIndex iop = statement_[ist-1].end_plus_one;\n\t   iop < statement.end_plus_one; iop++) {\n\tReal* __restrict grad = gradient_multipass_b+index_[iop]*MULTIPASS_SIZE;\n\t// Loop through columns within this block; we hope the\n\t// compiler can optimize this loop. Note that it is faster\n\t// to always use MULTIPASS_SIZE, always known at\n\t// compile time, than to use block_size, which is not, even\n\t// though in the last iteration this may involve redundant\n\t// computations.\n\tif (multiplier_[iop] == 1.0) {\n\t  //\t    if (__builtin_expect(multiplier_[iop] == 1.0,0)) {\n\t  for (uIndex i = 0; i < MULTIPASS_SIZE; i++) {\n\t    //\t      for (uIndex i = 0; i < block_size; i++) {\n\t    a[i] += grad[i];\n\t  }\n\t}\n\telse {\n\t  for (uIndex i = 0; i < MULTIPASS_SIZE; i++) {\n\t    //\t      for (uIndex i = 0; i < block_size; i++) {\n\t    a[i] += multiplier_[iop]*grad[i];\n\t  }\n\t}\n      }\n      // Copy the results\n      for (uIndex i = 0; i < MULTIPASS_SIZE; i++) {\n\tgradient_multipass_b[statement.index*MULTIPASS_SIZE+i] = a[i];\n      }\n    } // End of loop over statements\n  }    \n  */\n\n#if ADEPT_REAL_PACKET_SIZE > 1\n  void\n  Stack::jacobian_forward_kernel(Real* __restrict gradient_multipass_b) const\n  {\n\n    // Loop forward through the derivative statements\n    for (uIndex ist = 1; ist < n_statements_; ist++) {\n      const Statement& statement = statement_[ist];\n      // We copy the LHS to \"a\" in case it appears on the RHS in any\n      // of the following statements\n      Packet<Real> a; // Zeroed automatically\n      // Loop through operations\n      for (uIndex iop = statement_[ist-1].end_plus_one;\n\t   iop < statement.end_plus_one; iop++) {\n\tPacket<Real> g(gradient_multipass_b+index_[iop]*MULTIPASS_SIZE);\n\tPacket<Real> m(multiplier_[iop]);\n\ta += m * g;\n      }\n      // Copy the results\n      a.put(gradient_multipass_b+statement.index*MULTIPASS_SIZE);\n    } // End of loop over statements\n  }    \n#else\n  void\n  Stack::jacobian_forward_kernel(Real* __restrict gradient_multipass_b) const\n  {\n\n    // Loop forward through the derivative statements\n    for (uIndex ist = 1; ist < n_statements_; ist++) {\n      const Statement& statement = statement_[ist];\n      // We copy the LHS to \"a\" in case it appears on the RHS in any\n      // of the following statements\n      Block<MULTIPASS_SIZE,Real> a; // Zeroed automatically\n      // Loop through operations\n      for (uIndex iop = statement_[ist-1].end_plus_one;\n\t   iop < statement.end_plus_one; iop++) {\n\tfor (uIndex i = 0; i < MULTIPASS_SIZE; i++) {\n\t  a[i] += multiplier_[iop]*gradient_multipass_b[index_[iop]*MULTIPASS_SIZE+i];\n\t}\n      }\n      // Copy the results\n      for (uIndex i = 0; i < MULTIPASS_SIZE; i++) {\n\tgradient_multipass_b[statement.index*MULTIPASS_SIZE+i] = a[i];\n      }\n    } // End of loop over statements\n  }    \n#endif\n\n  void\n  Stack::jacobian_forward_kernel_extra(Real* __restrict gradient_multipass_b,\n\t\t\t\t       uIndex n_extra) const\n  {\n\n    // Loop forward through the derivative statements\n    for (uIndex ist = 1; ist < n_statements_; ist++) {\n      const Statement& statement = statement_[ist];\n      // We copy the LHS to \"a\" in case it appears on the RHS in any\n      // of the following statements\n      Block<MULTIPASS_SIZE,Real> a; // Zeroed automatically\n      // Loop through operations\n      for (uIndex iop = statement_[ist-1].end_plus_one;\n\t   iop < statement.end_plus_one; iop++) {\n\tfor (uIndex i = 0; i < n_extra; i++) {\n\t  a[i] += multiplier_[iop]*gradient_multipass_b[index_[iop]*MULTIPASS_SIZE+i];\n\t}\n      }\n      // Copy the results\n      for (uIndex i = 0; i < n_extra; i++) {\n\tgradient_multipass_b[statement.index*MULTIPASS_SIZE+i] = a[i];\n      }\n    } // End of loop over statements\n  }    \n\n\n\n  // Compute the Jacobian matrix, parallelized using OpenMP. Normally\n  // the user would call the jacobian or jacobian_forward functions,\n  // and the OpenMP version would only be called if OpenMP is\n  // available and the Jacobian matrix is large enough for\n  // parallelization to be worthwhile.  Note that jacobian_out must be\n  // allocated to be of size m*n, where m is the number of dependent\n  // variables and n is the number of independents. The independents\n  // and dependents must have already been identified with the\n  // functions \"independent\" and \"dependent\", otherwise this function\n  // will fail with FAILURE_XXDEPENDENT_NOT_IDENTIFIED. In the\n  // resulting matrix, the \"m\" dimension of the matrix varies\n  // fastest. This is implemented using a forward pass, appropriate\n  // for m>=n.\n  void\n  Stack::jacobian_forward_openmp(Real* jacobian_out) const\n  {\n\n    // Number of blocks to cycle through, including a possible last\n    // block containing fewer than MULTIPASS_SIZE variables\n    int n_block = (n_independent() + MULTIPASS_SIZE - 1)\n      / MULTIPASS_SIZE;\n    uIndex n_extra = n_independent() % MULTIPASS_SIZE;\n    \n    int iblock;\n    \n#pragma omp parallel\n    {\n      //      std::vector<Block<MULTIPASS_SIZE,Real> > \n      //\tgradient_multipass_b(max_gradient_);\n      uIndex gradient_multipass_size = max_gradient_*MULTIPASS_SIZE;\n      Real* __restrict gradient_multipass_b \n\t= alloc_aligned<Real>(gradient_multipass_size);\n      \n#pragma omp for schedule(static)\n      for (iblock = 0; iblock < n_block; iblock++) {\n\t// Set the index to the dependent variables for this block\n\tuIndex i_independent =  MULTIPASS_SIZE * iblock;\n\t\n\tuIndex block_size = MULTIPASS_SIZE;\n\t// If this is the last iteration and the number of extra\n\t// elements is non-zero, then set the block size to the number\n\t// of extra elements. If the number of extra elements is zero,\n\t// then the number of independent variables is exactly divisible\n\t// by MULTIPASS_SIZE, so the last iteration will be the\n\t// same as all the rest.\n\tif (iblock == n_block-1 && n_extra > 0) {\n\t  block_size = n_extra;\n\t}\n\t\n\t// Set the initial gradients all to zero\n\tfor (std::size_t i = 0; i < gradient_multipass_size; i++) {\n\t  gradient_multipass_b[i] = 0.0;\n\t}\n\t// Each seed vector has one non-zero entry of 1.0\n\tfor (uIndex i = 0; i < block_size; i++) {\n\t  gradient_multipass_b[independent_index_[i_independent+i]*MULTIPASS_SIZE+i] = 1.0;\n\t}\n\n\tjacobian_forward_kernel(gradient_multipass_b);\n\n\t// Copy the gradients corresponding to the dependent variables\n\t// into the Jacobian matrix\n\tfor (uIndex idep = 0; idep < n_dependent(); idep++) {\n\t  for (uIndex i = 0; i < block_size; i++) {\n\t    jacobian_out[(i_independent+i)*n_dependent()+idep]\n\t      = gradient_multipass_b[dependent_index_[idep]*MULTIPASS_SIZE+i];\n\t  }\n\t}\n      } // End of loop over blocks\n      free_aligned(gradient_multipass_b);\n    } // End of parallel section\n  } // End of jacobian function\n\n\n  // Compute the Jacobian matrix; note that jacobian_out must be\n  // allocated to be of size m*n, where m is the number of dependent\n  // variables and n is the number of independents. The independents\n  // and dependents must have already been identified with the\n  // functions \"independent\" and \"dependent\", otherwise this function\n  // will fail with FAILURE_XXDEPENDENT_NOT_IDENTIFIED. In the\n  // resulting matrix, the \"m\" dimension of the matrix varies\n  // fastest. This is implemented using a forward pass, appropriate\n  // for m>=n.\n  void\n  Stack::jacobian_forward(Real* jacobian_out)\n  {\n    if (independent_index_.empty() || dependent_index_.empty()) {\n      //throw(dependents_or_independents_not_identified());\n      printf(\"dependents or independents not identified\\n\");\n      assert(false);\n    }\n#ifdef _OPENMP\n    if (have_openmp_ \n\t&& !openmp_manually_disabled_\n\t&& n_independent() > MULTIPASS_SIZE\n\t&& omp_get_max_threads() > 1) {\n      // Call the parallel version\n      jacobian_forward_openmp(jacobian_out);\n      return;\n    }\n#endif\n\n    // For optimization reasons, we process a block of\n    // MULTIPASS_SIZE columns of the Jacobian at once; calculate\n    // how many blocks are needed and how many extras will remain\n    uIndex n_block = n_independent() / MULTIPASS_SIZE;\n    uIndex n_extra = n_independent() % MULTIPASS_SIZE;\n\n    ///gradient_multipass_.resize(max_gradient_);\n    uIndex gradient_multipass_size = max_gradient_*MULTIPASS_SIZE;\n    Real* __restrict gradient_multipass_b \n      = alloc_aligned<Real>(gradient_multipass_size);\n\n    // Loop over blocks of MULTIPASS_SIZE columns\n    for (uIndex iblock = 0; iblock < n_block; iblock++) {\n      // Set the index to the dependent variables for this block\n      uIndex i_independent =  MULTIPASS_SIZE * iblock;\n\n      // Set the initial gradients all to zero\n      ///zero_gradient_multipass();\n      for (std::size_t i = 0; i < gradient_multipass_size; i++) {\n\tgradient_multipass_b[i] = 0.0;\n      }\n\n      // Each seed vector has one non-zero entry of 1.0\n      for (uIndex i = 0; i < MULTIPASS_SIZE; i++) {\n\tgradient_multipass_b[independent_index_[i_independent+i]*MULTIPASS_SIZE+i] = 1.0;\n      }\n\n      jacobian_forward_kernel(gradient_multipass_b);\n\n      // Copy the gradients corresponding to the dependent variables\n      // into the Jacobian matrix\n      for (uIndex idep = 0; idep < n_dependent(); idep++) {\n\tfor (uIndex i = 0; i < MULTIPASS_SIZE; i++) {\n\t  jacobian_out[(i_independent+i)*n_dependent()+idep] \n\t    = gradient_multipass_b[dependent_index_[idep]*MULTIPASS_SIZE+i];\n\t}\n      }\n      i_independent += MULTIPASS_SIZE;\n    } // End of loop over blocks\n    \n    // Now do the same but for the remaining few columns in the matrix\n    if (n_extra > 0) {\n      uIndex i_independent =  MULTIPASS_SIZE * n_block;\n      ///zero_gradient_multipass();\n      for (std::size_t i = 0; i < gradient_multipass_size; i++) {\n\tgradient_multipass_b[i] = 0.0;\n      }\n\n      for (uIndex i = 0; i < n_extra; i++) {\n\tgradient_multipass_b[independent_index_[i_independent+i]*MULTIPASS_SIZE+i] = 1.0;\n      }\n\n      jacobian_forward_kernel_extra(gradient_multipass_b, n_extra);\n\n      for (uIndex idep = 0; idep < n_dependent(); idep++) {\n\tfor (uIndex i = 0; i < n_extra; i++) {\n\t  jacobian_out[(i_independent+i)*n_dependent()+idep] \n\t    = gradient_multipass_b[dependent_index_[idep]*MULTIPASS_SIZE+i];\n\t}\n      }\n    }\n\n    free_aligned(gradient_multipass_b);\n  }\n\n\n  // Compute the Jacobian matrix, parallelized using OpenMP.  Normally\n  // the user would call the jacobian or jacobian_reverse functions,\n  // and the OpenMP version would only be called if OpenMP is\n  // available and the Jacobian matrix is large enough for\n  // parallelization to be worthwhile.  Note that jacobian_out must be\n  // allocated to be of size m*n, where m is the number of dependent\n  // variables and n is the number of independents. The independents\n  // and dependents must have already been identified with the\n  // functions \"independent\" and \"dependent\", otherwise this function\n  // will fail with FAILURE_XXDEPENDENT_NOT_IDENTIFIED. In the\n  // resulting matrix, the \"m\" dimension of the matrix varies\n  // fastest. This is implemented using a reverse pass, appropriate\n  // for m<n.\n  void\n  Stack::jacobian_reverse_openmp(Real* jacobian_out) const\n  {\n\n    // Number of blocks to cycle through, including a possible last\n    // block containing fewer than MULTIPASS_SIZE variables\n    int n_block = (n_dependent() + MULTIPASS_SIZE - 1)\n      / MULTIPASS_SIZE;\n    uIndex n_extra = n_dependent() % MULTIPASS_SIZE;\n    \n    int iblock;\n\n    // Inside the OpenMP loop, the \"this\" pointer may be NULL if the\n    // adept::Stack pointer is declared as thread-local and if the\n    // OpenMP memory model uses thread-local storage for private\n    // data. If this is the case then local pointers to or copies of\n    // the following members of the adept::Stack object may need to be\n    // made: dependent_index_ n_statements_ statement_ multiplier_\n    // index_ independent_index_ n_dependent() n_independent().\n    // Limited testing implies this is OK though.\n\n#pragma omp parallel\n    {\n      std::vector<Block<MULTIPASS_SIZE,Real> > \n\tgradient_multipass_b(max_gradient_);\n      \n#pragma omp for schedule(static)\n      for (iblock = 0; iblock < n_block; iblock++) {\n\t// Set the index to the dependent variables for this block\n\tuIndex i_dependent =  MULTIPASS_SIZE * iblock;\n\t\n\tuIndex block_size = MULTIPASS_SIZE;\n\t// If this is the last iteration and the number of extra\n\t// elements is non-zero, then set the block size to the number\n\t// of extra elements. If the number of extra elements is zero,\n\t// then the number of independent variables is exactly divisible\n\t// by MULTIPASS_SIZE, so the last iteration will be the\n\t// same as all the rest.\n\tif (iblock == n_block-1 && n_extra > 0) {\n\t  block_size = n_extra;\n\t}\n\n\t// Set the initial gradients all to zero\n\tfor (std::size_t i = 0; i < gradient_multipass_b.size(); i++) {\n\t  gradient_multipass_b[i].zero();\n\t}\n\t// Each seed vector has one non-zero entry of 1.0\n\tfor (uIndex i = 0; i < block_size; i++) {\n\t  gradient_multipass_b[dependent_index_[i_dependent+i]][i] = 1.0;\n\t}\n\n\t// Loop backward through the derivative statements\n\tfor (uIndex ist = n_statements_-1; ist > 0; ist--) {\n\t  const Statement& statement = statement_[ist];\n\t  // We copy the RHS to \"a\" in case it appears on the LHS in any\n\t  // of the following statements\n\t  Real a[MULTIPASS_SIZE];\n#if MULTIPASS_SIZE > MULTIPASS_SIZE_ZERO_CHECK\n\t  // For large blocks, we only process the ones where a[i] is\n\t  // non-zero\n\t  uIndex i_non_zero[MULTIPASS_SIZE];\n#endif\n\t  uIndex n_non_zero = 0;\n\t  for (uIndex i = 0; i < block_size; i++) {\n\t    a[i] = gradient_multipass_b[statement.index][i];\n\t    gradient_multipass_b[statement.index][i] = 0.0;\n\t    if (a[i] != 0.0) {\n#if MULTIPASS_SIZE > MULTIPASS_SIZE_ZERO_CHECK\n\t      i_non_zero[n_non_zero++] = i;\n#else\n\t      n_non_zero = 1;\n#endif\n\t    }\n\t  }\n\n\t  // Only do anything for this statement if any of the a values\n\t  // are non-zero\n\t  if (n_non_zero) {\n\t    // Loop through the operations\n\t    for (uIndex iop = statement_[ist-1].end_plus_one;\n\t\t iop < statement.end_plus_one; iop++) {\n\t      // Try to minimize pointer dereferencing by making local\n\t      // copies\n\t      Real multiplier = multiplier_[iop];\n\t      Real* __restrict gradient_multipass \n\t\t= &(gradient_multipass_b[index_[iop]][0]);\n#if MULTIPASS_SIZE > MULTIPASS_SIZE_ZERO_CHECK\n\t      // For large blocks, loop over only the indices\n\t      // corresponding to non-zero a\n\t      for (uIndex i = 0; i < n_non_zero; i++) {\n\t\tgradient_multipass[i_non_zero[i]] += multiplier*a[i_non_zero[i]];\n\t      }\n#else\n\t      // For small blocks, do all indices\n\t      for (uIndex i = 0; i < block_size; i++) {\n\t      //\t      for (uIndex i = 0; i < MULTIPASS_SIZE; i++) {\n\t\tgradient_multipass[i] += multiplier*a[i];\n\t      }\n#endif\n\t    }\n\t  }\n\t} // End of loop over statement\n\t// Copy the gradients corresponding to the independent\n\t// variables into the Jacobian matrix\n\tfor (uIndex iindep = 0; iindep < n_independent(); iindep++) {\n\t  for (uIndex i = 0; i < block_size; i++) {\n\t    jacobian_out[iindep*n_dependent()+i_dependent+i] \n\t      = gradient_multipass_b[independent_index_[iindep]][i];\n\t  }\n\t}\n      } // End of loop over blocks\n    } // end #pragma omp parallel\n  } // end jacobian_reverse_openmp\n\n\n  // Compute the Jacobian matrix; note that jacobian_out must be\n  // allocated to be of size m*n, where m is the number of dependent\n  // variables and n is the number of independents. The independents\n  // and dependents must have already been identified with the\n  // functions \"independent\" and \"dependent\", otherwise this function\n  // will fail with FAILURE_XXDEPENDENT_NOT_IDENTIFIED. In the\n  // resulting matrix, the \"m\" dimension of the matrix varies\n  // fastest. This is implemented using a reverse pass, appropriate\n  // for m<n.\n  void\n  Stack::jacobian_reverse(Real* jacobian_out)\n  {\n    if (independent_index_.empty() || dependent_index_.empty()) {\n      //throw(dependents_or_independents_not_identified());\n      printf(\"dependents or independents not identified\\n\");\n      assert(false);\n    }\n#ifdef _OPENMP\n    if (have_openmp_ \n\t&& !openmp_manually_disabled_\n\t&& n_dependent() > MULTIPASS_SIZE\n\t&& omp_get_max_threads() > 1) {\n      // Call the parallel version\n      jacobian_reverse_openmp(jacobian_out);\n      return;\n    }\n#endif\n\n    //    gradient_multipass_.resize(max_gradient_);\n    std::vector<Block<MULTIPASS_SIZE,Real> > \n      gradient_multipass_b(max_gradient_);\n\n    // For optimization reasons, we process a block of\n    // MULTIPASS_SIZE rows of the Jacobian at once; calculate\n    // how many blocks are needed and how many extras will remain\n    uIndex n_block = n_dependent() / MULTIPASS_SIZE;\n    uIndex n_extra = n_dependent() % MULTIPASS_SIZE;\n    uIndex i_dependent = 0; // uIndex of first row in the block we are\n\t\t\t    // currently computing\n    // Loop over the of MULTIPASS_SIZE rows\n    for (uIndex iblock = 0; iblock < n_block; iblock++) {\n      // Set the initial gradients all to zero\n      //      zero_gradient_multipass();\n      for (std::size_t i = 0; i < gradient_multipass_b.size(); i++) {\n\tgradient_multipass_b[i].zero();\n      }\n\n      // Each seed vector has one non-zero entry of 1.0\n      for (uIndex i = 0; i < MULTIPASS_SIZE; i++) {\n\tgradient_multipass_b[dependent_index_[i_dependent+i]][i] = 1.0;\n      }\n      // Loop backward through the derivative statements\n      for (uIndex ist = n_statements_-1; ist > 0; ist--) {\n\tconst Statement& statement = statement_[ist];\n\t// We copy the RHS to \"a\" in case it appears on the LHS in any\n\t// of the following statements\n\tReal a[MULTIPASS_SIZE];\n#if MULTIPASS_SIZE > MULTIPASS_SIZE_ZERO_CHECK\n\t// For large blocks, we only process the ones where a[i] is\n\t// non-zero\n\tuIndex i_non_zero[MULTIPASS_SIZE];\n#endif\n\tuIndex n_non_zero = 0;\n\tfor (uIndex i = 0; i < MULTIPASS_SIZE; i++) {\n\t  a[i] = gradient_multipass_b[statement.index][i];\n\t  gradient_multipass_b[statement.index][i] = 0.0;\n\t  if (a[i] != 0.0) {\n#if MULTIPASS_SIZE > MULTIPASS_SIZE_ZERO_CHECK\n\t    i_non_zero[n_non_zero++] = i;\n#else\n\t    n_non_zero = 1;\n#endif\n\t  }\n\t}\n\t// Only do anything for this statement if any of the a values\n\t// are non-zero\n\tif (n_non_zero) {\n\t  // Loop through the operations\n\t  for (uIndex iop = statement_[ist-1].end_plus_one;\n\t       iop < statement.end_plus_one; iop++) {\n\t    // Try to minimize pointer dereferencing by making local\n\t    // copies\n\t    Real multiplier = multiplier_[iop];\n\t    Real* __restrict gradient_multipass \n\t      = &(gradient_multipass_b[index_[iop]][0]);\n#if MULTIPASS_SIZE > MULTIPASS_SIZE_ZERO_CHECK\n\t    // For large blocks, loop over only the indices\n\t    // corresponding to non-zero a\n\t    for (uIndex i = 0; i < n_non_zero; i++) {\n\t      gradient_multipass[i_non_zero[i]] += multiplier*a[i_non_zero[i]];\n\t    }\n#else\n\t    // For small blocks, do all indices\n\t    for (uIndex i = 0; i < MULTIPASS_SIZE; i++) {\n\t      gradient_multipass[i] += multiplier*a[i];\n\t    }\n#endif\n\t  }\n\t}\n      } // End of loop over statement\n      // Copy the gradients corresponding to the independent variables\n      // into the Jacobian matrix\n      for (uIndex iindep = 0; iindep < n_independent(); iindep++) {\n\tfor (uIndex i = 0; i < MULTIPASS_SIZE; i++) {\n\t  jacobian_out[iindep*n_dependent()+i_dependent+i] \n\t    = gradient_multipass_b[independent_index_[iindep]][i];\n\t}\n      }\n      i_dependent += MULTIPASS_SIZE;\n    } // End of loop over blocks\n    \n    // Now do the same but for the remaining few rows in the matrix\n    if (n_extra > 0) {\n      for (std::size_t i = 0; i < gradient_multipass_b.size(); i++) {\n\tgradient_multipass_b[i].zero();\n      }\n      //      zero_gradient_multipass();\n      for (uIndex i = 0; i < n_extra; i++) {\n\tgradient_multipass_b[dependent_index_[i_dependent+i]][i] = 1.0;\n      }\n      for (uIndex ist = n_statements_-1; ist > 0; ist--) {\n\tconst Statement& statement = statement_[ist];\n\tReal a[MULTIPASS_SIZE];\n#if MULTIPASS_SIZE > MULTIPASS_SIZE_ZERO_CHECK\n\tuIndex i_non_zero[MULTIPASS_SIZE];\n#endif\n\tuIndex n_non_zero = 0;\n\tfor (uIndex i = 0; i < n_extra; i++) {\n\t  a[i] = gradient_multipass_b[statement.index][i];\n\t  gradient_multipass_b[statement.index][i] = 0.0;\n\t  if (a[i] != 0.0) {\n#if MULTIPASS_SIZE > MULTIPASS_SIZE_ZERO_CHECK\n\t    i_non_zero[n_non_zero++] = i;\n#else\n\t    n_non_zero = 1;\n#endif\n\t  }\n\t}\n\tif (n_non_zero) {\n\t  for (uIndex iop = statement_[ist-1].end_plus_one;\n\t       iop < statement.end_plus_one; iop++) {\n\t    Real multiplier = multiplier_[iop];\n\t    Real* __restrict gradient_multipass \n\t      = &(gradient_multipass_b[index_[iop]][0]);\n\t    //\t    if (index_[iop] > max_gradient_-1\n\t    //\t\t|| index_[iop] < 0) {\n\t    //\t    std::cerr << \"AAAAAA: iop=\" << iop << \" index_[iop]=\" << index_[iop] << \" max_gradient_=\" << max_gradient_ << \" ist=\" << ist << \"\\n\";\n\t      //\t    }\n#if MULTIPASS_SIZE > MULTIPASS_SIZE_ZERO_CHECK\n\t    for (uIndex i = 0; i < n_non_zero; i++) {\n\t      gradient_multipass[i_non_zero[i]] += multiplier*a[i_non_zero[i]];\n\t    }\n#else\n\t    for (uIndex i = 0; i < n_extra; i++) {\n\t      //\t      std::cerr << \"BBBBB: i=\" << i << \" gradient_multipass[i]=\" << gradient_multipass[i] << \" multiplier=\" << multiplier << \" a[i]=\" << a[i] << \"\\n\";\n\t      gradient_multipass[i] += multiplier*a[i];\n\t    }\n#endif\n\t  }\n\t}\n      }\n      for (uIndex iindep = 0; iindep < n_independent(); iindep++) {\n\tfor (uIndex i = 0; i < n_extra; i++) {\n\t  jacobian_out[iindep*n_dependent()+i_dependent+i] \n\t    = gradient_multipass_b[independent_index_[iindep]][i];\n\t}\n      }\n    }\n  }\n\n  // Compute the Jacobian matrix; note that jacobian_out must be\n  // allocated to be of size m*n, where m is the number of dependent\n  // variables and n is the number of independents. In the resulting\n  // matrix, the \"m\" dimension of the matrix varies fastest. This is\n  // implemented by calling one of jacobian_forward and\n  // jacobian_reverse, whichever would be faster.\n  void\n  Stack::jacobian(Real* jacobian_out)\n  {\n    //    std::cout << \">>> Computing \" << n_dependent() << \"x\" << n_independent()\n    //\t      << \" Jacobian from \" << n_statements_ << \" statements, \"\n    //\t      << n_operations() << \" operations and \" << max_gradient_ << \" gradients\\n\";\n\n    if (n_independent() <= n_dependent()) {\n      jacobian_forward(jacobian_out);\n    }\n    else {\n      jacobian_reverse(jacobian_out);\n    }\n  }\n  \n} // End namespace adept\n\n\n// =================================================================\n// Contents of settings.cpp\n// =================================================================\n\n/* settings.cpp -- View/change the overall Adept settings\n\n    Copyright (C) 2016 European Centre for Medium-Range Weather Forecasts\n\n    Author: Robin Hogan <r.j.hogan@ecmwf.int>\n\n    This file is part of the Adept library.\n\n*/\n\n#include <sstream>\n#include <cstring>\n\n#include <adept/base.h>\n#include <adept/settings.h>\n\n#ifdef HAVE_CONFIG_H\n#include \"config.h\"\n#endif\n\n#ifdef HAVE_OPENBLAS_CBLAS_HEADER\n#include <cblas.h>\n#endif\n\nnamespace adept {\n\n  // -------------------------------------------------------------------\n  // Get compile-time settings\n  // -------------------------------------------------------------------\n\n  // Return the version of Adept at compile time\n  std::string\n  version()\n  {\n    return ADEPT_VERSION_STR;\n  }\n\n  // Return the compiler used to compile the Adept library (e.g. \"g++\n  // [4.3.2]\" or \"Microsoft Visual C++ [1800]\")\n  std::string\n  compiler_version()\n  {\n#ifdef CXX\n    std::string cv = CXX; // Defined in config.h\n#elif defined(_MSC_VER)\n    std::string cv = \"Microsoft Visual C++\";\n#else\n    std::string cv = \"unknown\";\n#endif\n\n#ifdef __GNUC__\n\n#define STRINGIFY3(A,B,C) STRINGIFY(A) \".\" STRINGIFY(B) \".\" STRINGIFY(C)\n#define STRINGIFY(A) #A\n    cv += \" [\" STRINGIFY3(__GNUC__,__GNUC_MINOR__,__GNUC_PATCHLEVEL__) \"]\";\n#undef STRINGIFY\n#undef STRINGIFY3\n\n#elif defined(_MSC_VER)\n\n#define STRINGIFY1(A) STRINGIFY(A)\n#define STRINGIFY(A) #A\n    cv += \" [\" STRINGIFY1(_MSC_VER) \"]\";\n#undef STRINGIFY\n#undef STRINGIFY1\n\n#endif\n    return cv;\n  }\n\n  // Return the compiler flags used when compiling the Adept library\n  // (e.g. \"-Wall -g -O3\")\n  std::string\n  compiler_flags()\n  {\n#ifdef CXXFLAGS\n    return CXXFLAGS; // Defined in config.h\n#else\n    return \"unknown\";\n#endif\n  }\n\n  // Return a multi-line string listing numerous aspects of the way\n  // Adept has been configured.\n  std::string\n  configuration()\n  {\n    std::stringstream s;\n    s << \"Adept version \" << adept::version() << \":\\n\";\n    s << \"  Compiled with \" << adept::compiler_version() << \"\\n\";\n    s << \"  Compiler flags \\\"\" << adept::compiler_flags() << \"\\\"\\n\";\n#ifdef BLAS_LIBS\n    if (std::strlen(BLAS_LIBS) > 2) {\n      const char* blas_libs = BLAS_LIBS + 2;\n      s << \"  BLAS support from \" << blas_libs << \" library\\n\";\n    }\n    else {\n      s << \"  BLAS support from built-in library\\n\";\n    }\n#endif\n#ifdef HAVE_OPENBLAS_CBLAS_HEADER\n    s << \"  Number of BLAS threads may be specified up to maximum of \"\n      << max_blas_threads() << \"\\n\";\n#endif\n    s << \"  Jacobians processed in blocks of size \" \n      << ADEPT_MULTIPASS_SIZE << \"\\n\";\n    return s.str();\n  }\n\n\n  // -------------------------------------------------------------------\n  // Get/set number of threads for array operations\n  // -------------------------------------------------------------------\n\n  // Get the maximum number of threads available for BLAS operations\n  int\n  max_blas_threads()\n  {\n#ifdef HAVE_OPENBLAS_CBLAS_HEADER\n    return openblas_get_num_threads();\n#else\n    return 1;\n#endif\n  }\n\n  // Set the maximum number of threads available for BLAS operations\n  // (zero means use the maximum sensible number on the current\n  // system), and return the number actually set. Note that OpenBLAS\n  // uses pthreads and the Jacobian calculation uses OpenMP - this can\n  // lead to inefficient behaviour so if you are computing Jacobians\n  // then you may get better performance by setting the number of\n  // array threads to one.\n  int\n  set_max_blas_threads(int n)\n  {\n#ifdef HAVE_OPENBLAS_CBLAS_HEADER\n    openblas_set_num_threads(n);\n    return openblas_get_num_threads();\n#else\n    return 1;\n#endif\n  }\n\n  // Was the library compiled with matrix multiplication support (from\n  // BLAS)?\n  bool\n  have_matrix_multiplication() {\n#ifdef HAVE_BLAS\n    return true;\n#else\n    return false;\n#endif\n  }\n\n  // Was the library compiled with linear algebra support (e.g. inv\n  // and solve from LAPACK)\n  bool\n  have_linear_algebra() {\n#ifdef HAVE_LAPACK\n    return true;\n#else\n    return false;\n#endif\n  }\n\n} // End namespace adept\n\n\n// =================================================================\n// Contents of solve.cpp\n// =================================================================\n\n/* solve.cpp -- Solve systems of linear equations using LAPACK\n\n    Copyright (C) 2015-2016 European Centre for Medium-Range Weather Forecasts\n\n    Author: Robin Hogan <r.j.hogan@ecmwf.int>\n\n    This file is part of the Adept library.\n*/\n                             \n\n#include <vector>\n\n\n#include <adept/solve.h>\n#include <adept/Array.h>\n#include <adept/SpecialMatrix.h>\n\n// If ADEPT_SOURCE_H is defined then we are in a header file generated\n// from all the source files, so cpplapack.h will already have been\n// included\n#ifndef AdeptSource_H\n#include \"cpplapack.h\"\n#endif\n\n#ifdef HAVE_LAPACK\n\nnamespace adept {\n\n  // -------------------------------------------------------------------\n  // Solve Ax = b for general square matrix A\n  // -------------------------------------------------------------------\n  template <typename T>\n  Array<1,T,false> \n  solve(const Array<2,T,false>& A, const Array<1,T,false>& b) {\n    Array<2,T,false> A_;\n    Array<1,T,false> b_;\n\n    // LAPACKE is more efficient with column-major input\n    // if (A.is_row_contiguous()) {\n      A_.resize_column_major(A.dimensions());\n      A_ = A;\n    // }\n    // else {\n    //   A_.link(A);\n    // }\n\n    // if (b_.offset(0) != 0) {\n      b_ = b;\n    // }\n    // else {\n    //   b_.link(b);\n    // }\n\n    std::vector<lapack_int> ipiv(A_.dimension(0));\n\n    //    lapack_int status = LAPACKE_dgesv(LAPACK_COL_MAJOR, A_.dimension(0), 1,\n    //\t\t\t\t      A_.data(), A_.offset(1), &ipiv[0],\n    //\t\t\t\t      b_.data(), b_.dimension(0));\n    lapack_int status = cpplapack_gesv(A_.dimension(0), 1,\n\t\t\t\t       A_.data(), A_.offset(1), &ipiv[0],\n\t\t\t\t       b_.data(), b_.dimension(0));\n\n    if (status != 0) {\n      std::stringstream s;\n      s << \"Failed to solve general system of equations: LAPACK ?gesv returned code \" << status;\n      //throw(matrix_ill_conditioned(s.str() ADEPT_EXCEPTION_LOCATION));\n      printf(\"matrix ill conditioned\\n\");\n      assert(false);\n    }\n    return b_;    \n  }\n\n  // -------------------------------------------------------------------\n  // Solve AX = B for general square matrix A and rectangular matrix B\n  // -------------------------------------------------------------------\n  template <typename T>\n  Array<2,T,false> \n  solve(const Array<2,T,false>& A, const Array<2,T,false>& B) {\n    Array<2,T,false> A_;\n    Array<2,T,false> B_;\n    \n    // LAPACKE is more efficient with column-major input\n    // if (A.is_row_contiguous()) {\n      A_.resize_column_major(A.dimensions());\n      A_ = A;\n    // }\n    // else {\n    //   A_.link(A);\n    // }\n\n    // if (B.is_row_contiguous()) {\n      B_.resize_column_major(B.dimensions());\n      B_ = B;\n    // }\n    // else {\n    //   B_.link(B);\n    // }\n\n    std::vector<lapack_int> ipiv(A_.dimension(0));\n\n    //    lapack_int status = LAPACKE_dgesv(LAPACK_COL_MAJOR, A_.dimension(0), B.dimension(1),\n    //\t\t\t\t      A_.data(), A_.offset(1), &ipiv[0],\n    //\t\t\t\t      B_.data(), B_.offset(1));\n    lapack_int status = cpplapack_gesv(A_.dimension(0), B.dimension(1),\n\t\t\t\t       A_.data(), A_.offset(1), &ipiv[0],\n\t\t\t\t       B_.data(), B_.offset(1));\n    if (status != 0) {\n      std::stringstream s;\n      s << \"Failed to solve general system of equations for matrix RHS: LAPACK ?gesv returned code \" << status;\n      //throw(matrix_ill_conditioned(s.str() ADEPT_EXCEPTION_LOCATION));\n      printf(\"matrix ill conditioned\\n\");\n      assert(false);\n    }\n    return B_;    \n  }\n\n\n  // -------------------------------------------------------------------\n  // Solve Ax = b for symmetric square matrix A\n  // -------------------------------------------------------------------\n  template <typename T, SymmMatrixOrientation Orient>\n  Array<1,T,false>\n  solve(const SpecialMatrix<T,SymmEngine<Orient>,false>& A,\n\tconst Array<1,T,false>& b) {\n    SpecialMatrix<T,SymmEngine<Orient>,false> A_;\n    Array<1,T,false> b_;\n\n    // Not sure why the original code copies A...\n    A_.resize(A.dimension());\n    A_ = A;\n    // A_.link(A);\n\n    // if (b.offset(0) != 1) {\n      b_ = b;\n    // }\n    // else {\n    //   b_.link(b);\n    // }\n\n    // Treat symmetric matrix as column-major\n    char uplo;\n    if (Orient == ROW_LOWER_COL_UPPER) {\n      uplo = 'U';\n    }\n    else {\n      uplo = 'L';\n    }\n\n    std::vector<lapack_int> ipiv(A_.dimension());\n\n    //    lapack_int status = LAPACKE_dsysv(LAPACK_COL_MAJOR, uplo, A_.dimension(0), 1,\n    //\t\t\t\t      A_.data(), A_.offset(), &ipiv[0],\n    //\t\t\t\t      b_.data(), b_.dimension(0));\n    lapack_int status = cpplapack_sysv(uplo, A_.dimension(0), 1,\n\t\t\t\t       A_.data(), A_.offset(), &ipiv[0],\n\t\t\t\t       b_.data(), b_.dimension(0));\n\n    if (status != 0) {\n      //      std::stringstream s;\n      //      s << \"Failed to solve symmetric system of equations: LAPACK ?sysv returned code \" << status;\n      //      throw(matrix_ill_conditioned(s.str() ADEPT_EXCEPTION_LOCATION));\n      std::cerr << \"Warning: LAPACK solve symmetric system failed (?sysv): trying general (?gesv)\\n\";\n      return solve(Array<2,T,false>(A_),b_);\n    }\n    return b_;    \n  }\n\n\n  // -------------------------------------------------------------------\n  // Solve AX = B for symmetric square matrix A\n  // -------------------------------------------------------------------\n  template <typename T, SymmMatrixOrientation Orient>\n  Array<2,T,false>\n  solve(const SpecialMatrix<T,SymmEngine<Orient>,false>& A,\n\tconst Array<2,T,false>& B) {\n    SpecialMatrix<T,SymmEngine<Orient>,false> A_;\n    Array<2,T,false> B_;\n\n    A_.resize(A.dimension());\n    A_ = A;\n    // A_.link(A);\n\n    // if (B.is_row_contiguous()) {\n      B_.resize_column_major(B.dimensions());\n      B_ = B;\n    // }\n    // else {\n    //   B_.link(B);\n    // }\n\n    // Treat symmetric matrix as column-major\n    char uplo;\n    if (Orient == ROW_LOWER_COL_UPPER) {\n      uplo = 'U';\n    }\n    else {\n      uplo = 'L';\n    }\n\n    std::vector<lapack_int> ipiv(A_.dimension());\n\n    //    lapack_int status = LAPACKE_dsysv(LAPACK_COL_MAJOR, uplo, A_.dimension(0), B.dimension(1),\n    //\t\t\t\t      A_.data(), A_.offset(), &ipiv[0],\n    //\t\t\t\t      B_.data(), B_.offset(1));\n    lapack_int status = cpplapack_sysv(uplo, A_.dimension(0), B.dimension(1),\n\t\t\t\t       A_.data(), A_.offset(), &ipiv[0],\n\t\t\t\t       B_.data(), B_.offset(1));\n\n    if (status != 0) {\n      std::stringstream s;\n      s << \"Failed to solve symmetric system of equations with matrix RHS: LAPACK ?sysv returned code \" << status;\n      //throw(matrix_ill_conditioned(s.str() ADEPT_EXCEPTION_LOCATION));\n      printf(\"matrix ill conditioned\\n\");\n      assert(false);\n    }\n    return B_;\n  }\n\n}\n\n#else\n\nnamespace adept {\n  \n  // -------------------------------------------------------------------\n  // Solve Ax = b for general square matrix A\n  // -------------------------------------------------------------------\n  template <typename T>\n  Array<1,T,false> \n  solve(const Array<2,T,false>& A, const Array<1,T,false>& b) {\n    //throw feature_not_available(\"Cannot solve linear equations because compiled without LAPACK\");\n    printf(\"feature not available\\n\");\n    assert(false);\n  }\n\n  // -------------------------------------------------------------------\n  // Solve AX = B for general square matrix A and rectangular matrix B\n  // -------------------------------------------------------------------\n  template <typename T>\n  Array<2,T,false> \n  solve(const Array<2,T,false>& A, const Array<2,T,false>& B) {\n    //throw feature_not_available(\"Cannot solve linear equations because compiled without LAPACK\");\n    printf(\"feature not available\\n\");\n    assert(false);\n  }\n\n  // -------------------------------------------------------------------\n  // Solve Ax = b for symmetric square matrix A\n  // -------------------------------------------------------------------\n  template <typename T, SymmMatrixOrientation Orient>\n  Array<1,T,false>\n  solve(const SpecialMatrix<T,SymmEngine<Orient>,false>& A,\n\tconst Array<1,T,false>& b) {\n    //throw feature_not_available(\"Cannot solve linear equations because compiled without LAPACK\");\n    printf(\"feature not available\\n\");\n    assert(false);\n  }\n\n  // -------------------------------------------------------------------\n  // Solve AX = B for symmetric square matrix A\n  // -------------------------------------------------------------------\n  template <typename T, SymmMatrixOrientation Orient>\n  Array<2,T,false>\n  solve(const SpecialMatrix<T,SymmEngine<Orient>,false>& A,\n\tconst Array<2,T,false>& B) {\n    //throw feature_not_available(\"Cannot solve linear equations because compiled without LAPACK\");\n    printf(\"feature not available\\n\");\n    assert(false);\n  }\n\n}\n\n#endif\n\n\nnamespace adept {\n\n  // -------------------------------------------------------------------\n  // Explicit instantiations\n  // -------------------------------------------------------------------\n#define ADEPT_EXPLICIT_SOLVE(TYPE,RRANK)\t\t\t\t\\\n  template Array<RRANK,TYPE,false>\t\t\t\t\t\\\n  solve(const Array<2,TYPE,false>& A, const Array<RRANK,TYPE,false>& b); \\\n  template Array<RRANK,TYPE,false>\t\t\t\t\t\\\n  solve(const SpecialMatrix<TYPE,SymmEngine<ROW_LOWER_COL_UPPER>,false>& A, \\\n\tconst Array<RRANK,TYPE,false>& b);\t\t\t\t\t\\\n  template Array<RRANK,TYPE,false>\t\t\t\t\t\\\n  solve(const SpecialMatrix<TYPE,SymmEngine<ROW_UPPER_COL_LOWER>,false>& A, \\\n\tconst Array<RRANK,TYPE,false>& b);\n\n  ADEPT_EXPLICIT_SOLVE(float,1)\n  ADEPT_EXPLICIT_SOLVE(float,2)\n  ADEPT_EXPLICIT_SOLVE(double,1)\n  ADEPT_EXPLICIT_SOLVE(double,2)\n#undef ADEPT_EXPLICIT_SOLVE\n\n}\n\n\n\n// =================================================================\n// Contents of vector_utilities.cpp\n// =================================================================\n\n/* vector_utilities.cpp -- Vector utility functions\n\n    Copyright (C) 2016 European Centre for Medium-Range Weather Forecasts\n\n    Author: Robin Hogan <r.j.hogan@ecmwf.int>\n\n    This file is part of the Adept library.\n\n*/\n\n#include <adept/vector_utilities.h>\n\nnamespace adept {\n\n  Array<1,Real,false>\n  linspace(Real x1, Real x2, Index n) {\n    Array<1,Real,false> ans(n);\n    if (n > 1) {\n      for (Index i = 0; i < n; ++i) {\n\tans(i) = x1 + (x2-x1)*i / static_cast<Real>(n-1);\n      }\n    }\n    else if (n == 1 && x1 == x2) {\n      ans(0) = x1;\n      return ans;\n    }\n    else if (n == 1) {\n      //throw(invalid_operation(\"linspace(x1,x2,n) with n=1 only valid if x1=x2\"));\n      printf(\"invalid operation\\n\");\n      assert(false);\n    }\n    return ans;\n  }\n\n}\n\n\n\n#endif\n\n", "meta": {"hexsha": "e1abf1a0e86440a7c68f2f19aa860a19d1862d57", "size": 91668, "ext": "h", "lang": "C", "max_stars_repo_path": "apps_enzymetest/adept-serial/include/adept_source.h", "max_stars_repo_name": "timkaler/ligra-gcn", "max_stars_repo_head_hexsha": "f6c4312dfec9a014c9db2e8d1c875476880dc363", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "apps_enzymetest/adept-serial/include/adept_source.h", "max_issues_repo_name": "timkaler/ligra-gcn", "max_issues_repo_head_hexsha": "f6c4312dfec9a014c9db2e8d1c875476880dc363", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "apps_enzymetest/adept-serial/include/adept_source.h", "max_forks_repo_name": "timkaler/ligra-gcn", "max_forks_repo_head_hexsha": "f6c4312dfec9a014c9db2e8d1c875476880dc363", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.5294535131, "max_line_length": 161, "alphanum_fraction": 0.6181001004, "num_tokens": 24474, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.33458942798284697, "lm_q2_score": 0.02843603253025177, "lm_q1q2_score": 0.009514395858398568}}
{"text": "/*\t$Id$ */\n/*\n * Copyright (c) 2014, 2015 Kristaps Dzonsons <kristaps@kcons.eu>\n *\n * Permission to use, copy, modify, and distribute this software for any\n * purpose with or without fee is hereby granted, provided that the above\n * copyright notice and this permission notice appear in all copies.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\n * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\n * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\n * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\n * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\n * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF\n * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n */\n#include <assert.h>\n#include <stdint.h>\n#include <stdlib.h>\n#include <string.h>\n\n#ifdef MAC_INTEGRATION\n#include <gtkosxapplication.h>\n#endif\n#include <gtk/gtk.h>\n#include <gdk/gdk.h>\n#include <gsl/gsl_rng.h>\n#include <gsl/gsl_multifit.h>\n#include <gsl/gsl_histogram.h>\n#include <kplot.h>\n\n#include \"extern.h\"\n\n/*\n * Brute-force scan all possible pi values (and Poisson means) by\n * scanning through the strategy space.\n */\nint\nrangefind(struct bmigrate *b)\n{\n\tsize_t\t\t mutants;\n\tdouble\t\t mstrat, istrat, v;\n\tgchar\t\t buf[22];\n\n\tg_assert(b->rangeid);\n\n\t/*\n\t * Set the number of mutants on a given island, then see what\n\t * the utility function would yield given that number of mutants\n\t * and incumbents, setting the current player to be one or the\n\t * other..\n\t */\n\tmstrat = istrat = 0.0;\n\tfor (mutants = 0; mutants <= b->range.n; mutants++) {\n\t\tmstrat = b->range.ymin + \n\t\t\t(b->range.slicey / (double)b->range.slices) * \n\t\t\t(b->range.ymax - b->range.ymin);\n\t\tistrat = b->range.xmin + \n\t\t\t(b->range.slicex / (double)b->range.slices) * \n\t\t\t(b->range.xmax - b->range.xmin);\n\t\t/*\n\t\t * Only check for a given mutant/incumbent individual's\n\t\t * strategy if the population is going to support the\n\t\t * existence of that individual.\n\t\t */\n\t\tif (mutants > 0) {\n\t\t\tv = hnode_exec\n\t\t\t\t((const struct hnode *const *) \n\t\t\t\t b->range.exp, \n\t\t\t\t istrat, mstrat * mutants + istrat * \n\t\t\t\t (b->range.n - mutants), b->range.n);\n\t\t\tif (0.0 != v && ! isnormal(v))\n\t\t\t\tbreak;\n\t\t\tif (v < b->range.pimin)\n\t\t\t\tb->range.pimin = v;\n\t\t\tif (v > b->range.pimax)\n\t\t\t\tb->range.pimax = v;\n\t\t\tb->range.piaggr += v;\n\t\t\tb->range.picount++;\n\t\t}\n\t\tif (mutants != b->range.n) {\n\t\t\tv = hnode_exec\n\t\t\t\t((const struct hnode *const *) \n\t\t\t\t b->range.exp, \n\t\t\t\t mstrat, mstrat * mutants + istrat * \n\t\t\t\t (b->range.n - mutants), b->range.n);\n\t\t\tif (0.0 != v && ! isnormal(v))\n\t\t\t\tbreak;\n\t\t\tif (v < b->range.pimin)\n\t\t\t\tb->range.pimin = v;\n\t\t\tif (v > b->range.pimax)\n\t\t\t\tb->range.pimax = v;\n\t\t\tb->range.piaggr += v;\n\t\t\tb->range.picount++;\n\t\t}\n\t}\n\n\t/*\n\t * We might have hit a discontinuous number.\n\t * If we did, then print out an error and don't continue.\n\t * If not, update to the next mutant and incumbent.\n\t */\n\tif (mutants <= b->range.n) {\n\t\tg_snprintf(buf, sizeof(buf), \n\t\t\t\"%zu mutants, mutant=%g, incumbent=%g\",\n\t\t\tmutants, mstrat, istrat);\n\t\tgtk_label_set_text(b->wins.rangeerror, buf);\n\t\tgtk_widget_show_all(GTK_WIDGET(b->wins.rangeerrorbox));\n\t\tg_debug(\"Range-finder idle event complete (error)\");\n\t\tb->rangeid = 0;\n\t} else {\n\t\tif (++b->range.slicey == b->range.slices) {\n\t\t\tb->range.slicey = 0;\n\t\t\tb->range.slicex++;\n\t\t}\n\t\tif (b->range.slicex == b->range.slices) {\n\t\t\tg_debug(\"Range-finder idle event complete\");\n\t\t\tb->rangeid = 0;\n\t\t}\n\t}\n\n\t/*\n\t * Set our current extrema.\n\t */\n\tg_snprintf(buf, sizeof(buf), \"%g\", b->range.pimin);\n\tgtk_label_set_text(b->wins.rangemin, buf);\n\tg_snprintf(buf, sizeof(buf), \"%g\", b->range.alpha * \n\t\t(1.0 + b->range.delta * b->range.pimin));\n\tgtk_label_set_text(b->wins.rangeminlambda, buf);\n\n\tg_snprintf(buf, sizeof(buf), \"%g\", b->range.pimax);\n\tgtk_label_set_text(b->wins.rangemax, buf);\n\tg_snprintf(buf, sizeof(buf), \"%g\", b->range.alpha * \n\t\t(1.0 + b->range.delta * b->range.pimax));\n\tgtk_label_set_text(b->wins.rangemaxlambda, buf);\n\n\tv = b->range.piaggr / (double)b->range.picount;\n\tg_snprintf(buf, sizeof(buf), \"%g\", v);\n\tgtk_label_set_text(b->wins.rangemean, buf);\n\tg_snprintf(buf, sizeof(buf), \"%g\", b->range.alpha * \n\t\t(1.0 + b->range.delta * v));\n\tgtk_label_set_text(b->wins.rangemeanlambda, buf);\n\n\tv = (b->range.slicex * b->range.slices + b->range.slicey) /\n\t\t(double)(b->range.slices * b->range.slices);\n\tg_snprintf(buf, sizeof(buf), \"%.1f%%\", v * 100.0);\n\tgtk_label_set_text(b->wins.rangestatus, buf);\n\n\treturn(0 != b->rangeid);\n}\n\n", "meta": {"hexsha": "216d845ef5261b6bdfb7f969287419991d72ff8e", "size": 4557, "ext": "c", "lang": "C", "max_stars_repo_path": "rangefind.c", "max_stars_repo_name": "kristapsdz/bmigrate", "max_stars_repo_head_hexsha": "0280a899564031a5a14af87d9264cd239a89851f", "max_stars_repo_licenses": ["0BSD"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2018-03-03T17:13:19.000Z", "max_stars_repo_stars_event_max_datetime": "2018-03-03T17:13:19.000Z", "max_issues_repo_path": "rangefind.c", "max_issues_repo_name": "kristapsdz/bmigrate", "max_issues_repo_head_hexsha": "0280a899564031a5a14af87d9264cd239a89851f", "max_issues_repo_licenses": ["0BSD"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "rangefind.c", "max_forks_repo_name": "kristapsdz/bmigrate", "max_forks_repo_head_hexsha": "0280a899564031a5a14af87d9264cd239a89851f", "max_forks_repo_licenses": ["0BSD"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.9802631579, "max_line_length": 75, "alphanum_fraction": 0.6530612245, "num_tokens": 1410, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4073334000459302, "lm_q2_score": 0.022977370662700763, "lm_q1q2_score": 0.00935945051615351}}
{"text": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <stdbool.h>\n#include <limits.h>\n#include <getopt.h>\n#include <mpi.h>\n#include \"compearth.h\"\n#include \"parmt_utils.h\"\n#ifdef PARMT_USE_INTEL\n#include <mkl_cblas.h>\n#else\n#include <cblas.h>\n#endif\n#include \"parmt_polarity.h\"\n#include \"parmt_postProcess.h\"\n#include \"parmt_mtsearch.h\"\n#include \"iscl/array/array.h\"\n#include \"iscl/memory/memory.h\"\n#include \"iscl/os/os.h\"\n\n#define PROGRAM_NAME \"postmt\"\n#define OUTDIR \"postprocess\"\n#define WAVOUT_DIR \"obsest\"\n\nstatic int parseArguments(int argc, char *argv[], char iniFile[PATH_MAX]);\nstatic void printUsage(void);\nint parmt_freeData(struct parmtData_struct *data);\n\nint main(int argc, char *argv[])\n{\n    struct parmtGeneralParms_struct parms;\n    struct parmtData_struct data;\n    struct parmtPolarityParms_struct polarityParms;\n    struct polarityData_struct polarityData;\n    FILE *ofl;\n    char fname[PATH_MAX];\n    char iniFile[PATH_MAX];\n    char programNameIn[256];\n    bool lpol;\n    double U[9], Muse[6], Mned[6], lam[3], *betas, *deps, *depMPDF, *depMagMPDF,\n           *G, *gammas, *kappas,\n           *sigmas, *thetas, *M0s, *phi, *var, dip, epoch,\n           lagTime, Mw, phiLoc, xnorm, xsum;\n    int ierr, iobs, imtopt, jb, jg, jk, jloc, jm, joptLoc, \n        js, jt, k, lag, myid, nb, ng, nk, nlags, nlocs,\n        nm, nmt, npmax, npts, nprocs, ns, nt,\n        provided;\n    bool ldefault;\n    // Start MPI\n    MPI_Init_thread(&argc, &argv, MPI_THREAD_FUNNELED, &provided);\n    MPI_Comm_rank(MPI_COMM_WORLD, &myid);\n    MPI_Comm_size(MPI_COMM_WORLD, &nprocs);\n    // Initialize\n    depMPDF = NULL; \n    depMagMPDF = NULL;\n    betas = NULL;\n    deps = NULL;\n    gammas = NULL;\n    kappas = NULL;\n    sigmas = NULL;\n    thetas = NULL;\n    M0s = NULL;\n    phi = NULL;\n    memset(&parms, 0, sizeof(struct parmtGeneralParms_struct));\n    memset(&data, 0, sizeof(struct parmtData_struct));\n    memset(&polarityParms, 0, sizeof(struct parmtPolarityParms_struct));\n    memset(&polarityData, 0, sizeof(struct polarityData_struct));\n    // Parse the input arguments \n    ierr = parseArguments(argc, argv, iniFile);\n    if (ierr != 0)\n    {\n        if (ierr ==-2){return 0;}\n        printf(\"%s: Error parsing arguments\\n\", PROGRAM_NAME);\n        return EXIT_FAILURE;\n    }\n    // Load the ini file - from this we should be able to deduce the archive\n    ierr = parmt_utils_readGeneralParms(iniFile, &parms);\n    if (ierr != 0)\n    {\n        printf(\"%s: Error reading general parameters\\n\", PROGRAM_NAME);\n        return EXIT_FAILURE;\n    }\n    if (!os_path_isfile(parms.postmtFile))\n    {\n        printf(\"%s: Archive file %s doesn't exist\\n\",\n               PROGRAM_NAME, parms.postmtFile);\n        return EXIT_FAILURE;\n    }\n    ierr += parmt_utils_readPolarityParms(iniFile, &polarityParms);\n\n    // TODO make this a config\n    if (!os_path_isdir(OUTDIR))\n    {\n        os_makedirs(OUTDIR);\n    }\n    if (!os_path_isdir(WAVOUT_DIR))\n    {\n        os_makedirs(WAVOUT_DIR);\n    }\n    // Load the data\n    printf(\"%s: Reading data...\\n\", PROGRAM_NAME);\n    ierr = utils_dataArchive_readAllWaveforms(parms.dataFile, &data);\n    if (ierr != 0)\n    {\n        printf(\"%s: Error reading data\\n\", PROGRAM_NAME);\n        goto ERROR;\n    }\n    data.est = (struct sacData_struct *)\n               calloc((size_t) data.nobs, sizeof(struct sacData_struct));\n    // Read the archive\n    printf(\"%s: Reading archive %s...\\n\", PROGRAM_NAME, parms.postmtFile); \nprintf(\"%s %s %s\\n\", parms.resultsDir, parms.projnm, parms.resultsFileSuffix);\n    ierr = parmt_io_readObjfnArchive64f(\n                   //parms.resultsDir, parms.projnm, parms.resultsFileSuffix,\n                   parms.postmtFile, //parms.parmtArchive,\n                   programNameIn,\n                   &nlocs, &deps,\n                   &nm, &M0s,\n                   &nb, &betas,\n                   &ng, &gammas,\n                   &nk, &kappas,\n                   &ns, &sigmas,\n                   &nt, &thetas,\n                   &nmt, &phi);\n    if (ierr != 0)\n    {\n        printf(\"%s: Error loading archive\\n\", PROGRAM_NAME);\n        goto ERROR;\n    }\n/*\ndouble *phi1; \n    ierr = parmt_io_readObjfnArchive64f(\n                   \"bw\", parms.projnm, \"bodyWaves\",\n                   &nlocs, &deps,\n                   &nm, &M0s,\n                   &nb, &betas,\n                   &ng, &gammas,\n                   &nk, &kappas,\n                   &ns, &sigmas,\n                   &nt, &thetas,\n                   &nmt, &phi1);\nfor (int imt=0; imt<nmt; imt++)\n{\n  phi[imt] = (12.0*phi1[imt] + 11*phi[imt]);\n}\n        ierr = parmt_io_createObjfnArchive64f(\"joint\", parms.projnm,\n                                              \"joint\",\n                                              25, //data.nobs,\n                                              nlocs, deps,\n                                              nm, M0s,\n                                              nb, betas,\n                                              ng, gammas,\n                                              nk, kappas,\n                                              ns, sigmas,\n                                              nt, thetas);\n        ierr = parmt_io_writeObjectiveFunction64f(\n                   \"joint\", parms.projnm, \"joint\",\n                   nmt, phi);\nreturn 0;\n*/\n    // Get the optimum moment tensor for the waveforms\n    ierr = marginal_getOptimum(nlocs, nm, nb,\n                               ng, nk, ns, nt,\n                               phi,\n                               &jloc, &jm, &jb, &jg,\n                               &jk, &js, &jt);\n    if (ierr != 0)\n    {\n        printf(\"%s: Failed to get optimum\\n\", PROGRAM_NAME);\n        goto ERROR;\n    }\n    imtopt = jloc*nm*nb*ng*nk*ns*nt\n           +      jm*nb*ng*nk*ns*nt\n           +         jb*ng*nk*ns*nt\n           +            jg*nk*ns*nt\n           +               jk*ns*nt\n           +                  js*nt\n           +                     jt;\n//printf(\"%d %e\\n\", jm, M0s[jm]);\n//getchar();\n    compearth_m02mw(1, CE_KANAMORI_1978, &M0s[jm], &Mw);\n    joptLoc = jloc;\n//printf(\"%d %d %d %d %d %d %d\\n\", jloc, jm, jg, jb, jk, js, jt);\n//jloc =4; jm = 5; jg =1; jb=0; jk=11; js=2; jt=4;\n\n    printf(\"%s: Optimum information:\\n\", PROGRAM_NAME);\n    printf(\"        Value: %f\\n\", phi[imtopt]);\n    printf(\"        Depth: %f (km)\\n\", deps[jloc]);\n    printf(\"        Magnitude: %f\\n\", Mw);\n    printf(\"        Lune longitude: %f (deg)\\n\", gammas[jg]*180.0/M_PI);\n    printf(\"        Lune latitude: %f (deg)\\n\", (M_PI_2 - betas[jb])*180.0/M_PI);\n    printf(\"        Strike: %f (deg)\\n\", kappas[jk]*180.0/M_PI);\n    printf(\"        Slip: %f (deg)\\n\", sigmas[js]*180.0/M_PI); \n    printf(\"        Dip: %f (deg)\\n\", thetas[jt]*180.0/M_PI);\n    // Display the moment tensor in USE format which is useful for obspy and gmt\n        double gammaOpt = gammas[jg]*180.0/M_PI;\n        double deltaOpt = 90.0-betas[jb]*180.0/M_PI;\n        double kappaOpt = kappas[jk]*180.0/M_PI;\n        double thetaOpt = thetas[jt]*180.0/M_PI;\n        double sigmaOpt = sigmas[js]*180.0/M_PI; \n        compearth_TT2CMT(1, &gammaOpt,\n                         &deltaOpt,\n                         &M0s[jm],\n                         &kappaOpt,\n                         &thetaOpt,\n                         &sigmaOpt,\n                         Muse, lam, U);\n\n/*\n    compearth_tt2cmt(gammas[jg]*180.0/M_PI,\n                     (M_PI/2.0 - betas[jb])*180.0/M_PI,\n                     M0s[jm],\n                     kappas[jk]*180.0/M_PI,\n                     thetas[jt]*180.0/M_PI,\n                     sigmas[js]*180.0/M_PI,\n                     Muse, lam, U);\n*/\n/*\nMuse[0] = 28200000000000000.;  // mrr\nMuse[1] = 283100000000000000.; // mtt\nMuse[2] =-311300000000000000.; // mpp\nMuse[3] =-243300000000000000.; // mrt\nMuse[4] =-149900000000000000.; // mrp\nMuse[5] = 467500000000000000.; // mtp\ncompearth_convertMT(1, CE_USE,  CE_NED, Muse, Mned);\n*/\n    ierr = parmt_discretizeMT64f(1, &gammas[jg],\n                                 1, &betas[jb],\n                                 1, &M0s[jm],\n                                 1, &kappas[jk],\n                                 1, &thetas[jt],\n                                 1, &sigmas[js],\n                                 6, 1, Mned);\n\n    printf(\"mtUSE =[%.6e,%.6e,%.6e,%.6e,%.6e,%.6e]\\n\",\n           Muse[0], Muse[1], Muse[2], Muse[3], Muse[4], Muse[5]);\n    printf(\"mtNED =[%.6e,%.6e,%.6e,%.6e,%.6e,%.6e]\\n\",\n           Mned[0], Mned[1], Mned[2], Mned[3], Mned[4], Mned[5]);\n//printf(\"%e\\n\", M0s[jm]);\n//compearth_CMT2m0(1, 1, Mned, &M0s[jm]);\n//printf(\"%e\\n\", M0s[jm]);\n//getchar();\n    // Compute the polarities\n    lpol = true;\n    ierr = parmt_polarity_computeTTimesGreens(MPI_COMM_WORLD, polarityParms,\n                                              data, &polarityData);\n    if (ierr != 0)\n    {   \n        printf(\"%s: Error computing polarity Green's functions\\n\",\n               PROGRAM_NAME);\n        ierr = 1;\n        lpol = false;\n    }\n    if (lpol && polarityData.nPolarity > 0)\n    {\n        double *Gpol = memory_calloc64f(6*polarityData.nPolarity);\n        double *est = memory_calloc64f(polarityData.nPolarity);\n        double phiPol;\n        int ipol, kt;\n        kt = jloc*polarityData.nPolarity;\nprintf(\"G\\n\");\n        for (ipol=0; ipol<polarityData.nPolarity; ipol++)\n        {\n            Gpol[6*ipol+0] = polarityData.Gxx[kt+ipol];\n            Gpol[6*ipol+1] = polarityData.Gyy[kt+ipol];\n            Gpol[6*ipol+2] = polarityData.Gzz[kt+ipol];\n            Gpol[6*ipol+3] = polarityData.Gxy[kt+ipol];\n            Gpol[6*ipol+4] = polarityData.Gxz[kt+ipol];\n            Gpol[6*ipol+5] = polarityData.Gyz[kt+ipol];\nprintf(\"%f %f %f %f %f %f\\n\", Gpol[6*ipol+0], Gpol[6*ipol+1], Gpol[6*ipol+2],\n                     Gpol[6*ipol+3], Gpol[6*ipol+4], Gpol[6*ipol+5]);\n        }\n        cblas_dgemv(CblasRowMajor, CblasNoTrans,\n                    polarityData.nPolarity, 6, 1.0, Gpol, 6,\n                    Mned, 1, 0.0, est, 1);\n        for (ipol=0; ipol<polarityData.nPolarity; ipol++)\n        {\n            est[ipol] = copysign(1.0, est[ipol]);\n            printf(\"Polarity: obs %f; est %f\\n\",\n                   polarityData.polarity[ipol], est[ipol]);\n        }\n        \n    }\n    // Write the output file\n\n    struct globalMapOpts_struct globalMap;\n    memset(&globalMap, 0, sizeof(struct globalMapOpts_struct));\n    strcpy(globalMap.outputScript, \"gmtScripts/globalMap.sh\");\n    strcpy(globalMap.psFile, \"globalMap.ps\");\n    array_copy64f_work(6, Muse, globalMap.mts);\n    globalMap.basis = CE_USE;\n    globalMap.evla = data.data[0].header.evla;\n    globalMap.evlo = data.data[0].header.evlo;\n    globalMap.evdp = deps[jloc]; \n    globalMap.lwantMT = true;\n    globalMap.lwantPolarity = true;\nprintf(\"%f %f\\n\", globalMap.mts[0], globalMap.mts[1]);\n    ierr = postmt_gmtHelper_writeGlobalMap(globalMap, data.nobs, data.data);\n/*\nprintf(\"overriding ned and joptloc\\n\");\njoptLoc=5;\nMned[0] = 8.526325e+15;\nMned[1] =-8.707938e+16;\nMned[2] = 2.226786e+17;\nMned[3] =-5.768950e+17;\nMned[4] =-3.469420e+17;\nMned[5] =-2.756277e+17;\n*/\n    // Compute the scaling factor\n    xnorm = marginal_computeNormalization(nlocs, deps,\n                                          nm, M0s,\n                                          nb, betas,\n                                          ng, gammas,\n                                          nk, kappas,\n                                          ns, sigmas,\n                                          nt, thetas,\n                                          phi, &ierr);\n    if (xnorm <= 0.0 || ierr != 0)\n    {\n        printf(\"%s: Failed to compute normalization factor - setting to 1\\n\",\n               PROGRAM_NAME);\n        ierr = 0;\n        xnorm = 1.0;\n    }\n    printf(\"%s: Scaling factor: %e\\n\", PROGRAM_NAME, xnorm);\n    cblas_dscal(nmt, 1.0/xnorm, phi, 1);\n    printf(\"%s: Computing pure histograms\\n\", PROGRAM_NAME);\n\n    double *locHist, *magHist, *betaHist, *gammaHist, *kappaHist, *sigmaHist, *thetaHist;\n    ierr = postmt_gmtHelper_makeRegularHistograms(nlocs, nm,\n                                                  nb, ng, nk, ns, nt, \n                                                  nmt, phi,\n                                                  &locHist, &magHist, &betaHist,\n                                                  &gammaHist, &kappaHist, &sigmaHist,\n                                                  &thetaHist);\n    int i;\n/*\n    printf(\"Depths\\n\");\n    for (i=0; i<nlocs; i++)\n    {\n        printf(\"%f %f\\n\", deps[i], locHist[i]);\n    }\n    printf(\"Magnitudes\\n\");\n    for (i=0; i<nm; i++)\n    {\n        compearth_m02mw(1, CE_KANAMORI_1978, &M0s[i], &Mw);\n        printf(\"%f %f\\n\", Mw, magHist[i]);\n    }\n    printf(\"Gammas\\n\");\n    for (i=0; i<ng; i++)\n    {\n        printf(\"%f %f\\n\", gammas[i]*180.0/M_PI, gammaHist[i]);\n    }\n*/\n    printf(\"Betas\\n\");\n    for (i=0; i<nb; i++)\n    {\n        printf(\"%f %f\\n\", 90.0 - betas[i]*180.0/M_PI, betaHist[i]);\n    }\n/*\n    printf(\"Kappas\\n\");\n    for (i=0; i<nk; i++)\n    {\n        printf(\"%f %f\\n\", kappas[i]*180.0/M_PI, kappaHist[i]);\n    }\n    printf(\"Sigmas\\n\");\n    for (i=0; i<ns; i++)\n    {\n        printf(\"%f %f\\n\", sigmas[i]*180.0/M_PI, sigmaHist[i]);\n    }\n    printf(\"Thetas\\n\");\n    for (i=0; i<nt; i++)\n    {\n        printf(\"%f %f\\n\", thetas[i]*180.0/M_PI, thetaHist[i]);\n    }\n*/\nconst char *scriptFile = \"gmtScripts/boxes.sh\";\nconst char *psFile = \"boxes.ps\";\nierr = postmt_gmtHelper_writeBetaBoxes(false, false, scriptFile, psFile,\n                                       nb, jb, betas, betaHist);\nierr = postmt_gmtHelper_writeGammaBoxes(true, false, scriptFile, psFile,\n                                        ng, jg, gammas, gammaHist);\nierr = postmt_gmtHelper_writeKappaBoxes(true, false, scriptFile, psFile,\n                                        nk, jk, kappas, kappaHist);\nierr = postmt_gmtHelper_writeSigmaBoxes(true, false, scriptFile, psFile,\n                                        ns, js, sigmas, sigmaHist);\nierr = postmt_gmtHelper_writeThetaBoxes(true, false, scriptFile, psFile,\n                                        nt, jt, thetas, thetaHist);\nierr = postmt_gmtHelper_writeMagnitudeBoxes(true, false, scriptFile, psFile,\n                                            nm, jm, M0s, magHist);\nierr = postmt_gmtHelper_writeDepthBoxes(true, true, scriptFile, psFile,\n                                        nlocs, joptLoc, deps, locHist);\n\n    // Start the post-processing - compute the depgh magnitude mPDFs\n    printf(\"%s: Computing the depth MPDF's\\n\", PROGRAM_NAME);\n    depMagMPDF = memory_calloc64f(nm*nlocs);\n    depMPDF = memory_calloc64f(nlocs);\n    ierr = marginal_computeDepthMPDF(nlocs,\n                                     nm, M0s,\n                                     nb, betas,\n                                     ng, gammas,\n                                     nk, kappas,\n                                     ns, sigmas,\n                                     nt, thetas,\n                                     phi, depMagMPDF, depMPDF);\n    if (ierr != 0)\n    {\n        printf(\"%s: Error computing depthMPDF\\n\", PROGRAM_NAME);\n        goto ERROR;\n    }\n    // Print the station list for my edification\n    for (k=0; k<data.nobs; k++)\n    {\n        printf(\"%8.3f %8.3f %6s\\n\", data.data[k].header.stlo,\n                                    data.data[k].header.stla,\n                                    data.data[k].header.kstnm);\n    }\nint im, iloc;\n    for (im=0; im<nm; im++)\n    {\n        compearth_m02mw(1, CE_KANAMORI_1978, &M0s[im], &Mw);\n        printf(\"Writing magnitude: %f\\n\", Mw);\n        memset(fname, 0, PATH_MAX*sizeof(char));\n        sprintf(fname, \"%s/%s_dep.%d.txt\", OUTDIR, parms.projnm, im+1);\n        ofl = fopen(fname, \"w\");\n        for (iloc=0; iloc<nlocs; iloc++)\n        {\n            jloc = im*nlocs + iloc;\n            fprintf(ofl, \"%e %e\\n\", deps[iloc], depMagMPDF[jloc]);\n        }\n        fclose(ofl);\n    }\n    memset(fname, 0, PATH_MAX*sizeof(char));\n    sprintf(fname, \"%s/%s_dep.txt\", OUTDIR, parms.projnm);\n    ofl = fopen(fname, \"w\");\n    for (iloc=0; iloc<nlocs; iloc++)\n    {\n        fprintf(ofl, \"%e %e\\n\", deps[iloc], depMPDF[iloc]);\n    }\n    fclose(ofl);\n    // Compute the optimal synthetics\n    xsum = 0.0;\n    for (iobs=0; iobs<data.nobs; iobs++)\n    {\n        // Extract the depth waveform\n        npts = data.data[iobs].npts;\n        npmax = npts;\n        G = memory_calloc64f(6*npmax);\n        var = memory_calloc64f(npmax);\n        ierr = parmt_utils_setDataOnG(iobs, joptLoc, npmax, data, G);\n        if (ierr != 0)\n        {\n            printf(\"%s: Failed to set data on G\\n\", PROGRAM_NAME);\n            goto ERROR;\n        }\n        // Compute the lag time\n        nlags = 0;\n        lag = 0;\n        if (parms.lwantLags)\n        {\n            //lagTime = data.data[iobs].header.user0;\n            //if (lagTime < 0.0){lagTime = parms.defaultMaxLagTime;}\n            lagTime = parmt_utils_getLagTime(data.data[iobs], \n                                             parms.defaultMaxLagTime,\n                                             &ldefault);\n            nlags = (int) (lagTime/data.data[iobs].header.delta + 0.5);\n        }\n        ierr = parmt_mtSearchL164f(6, 1,\n                                   npts, 1,\n                                   nlags, parms.lwantLags,\n                                   parms.lrescale,\n                                   &G[0*npmax], &G[1*npmax], &G[2*npmax],\n                                   &G[3*npmax], &G[4*npmax], &G[5*npmax],\n                                   NULL, Mned, data.data[iobs].data,\n                                   &phiLoc, var, &lag);\n        if (ierr != 0)\n        {\n            printf(\"%s: Error computing lags for waveform %d\\n\",\n                   PROGRAM_NAME, iobs);\n            goto ERROR;\n        }\n        // Compute the synthetic\n        k = iobs*data.nlocs + joptLoc;\n        parmt_utils_sacGrnsToEst(data.data[iobs],\n                                 data.sacGxx[k], data.sacGyy[k],\n                                 data.sacGzz[k], data.sacGxy[k],\n                                 data.sacGxz[k], data.sacGyz[k],\n                                 Mned,\n                                 parms.lrescale,\n                                 &data.est[iobs]);\n        // Fix the timing\n        ierr = sacio_getEpochalStartTime(data.est[iobs].header, &epoch);\n        epoch = epoch + (double) lag*data.data[iobs].header.delta;\n        sacio_setEpochalStartTime(epoch, &data.est[iobs].header);\n        // Write the file\n        memset(fname, 0, PATH_MAX*sizeof(char));\n        sprintf(fname, \"%s/%s.%s.%s.%s.SAC\",\n                WAVOUT_DIR,\n                data.data[iobs].header.knetwk,\n                data.data[iobs].header.kstnm,\n                data.data[iobs].header.kcmpnm,\n                data.data[iobs].header.khole);\n        sacio_writeTimeSeriesFile(fname, data.data[iobs]);\n        memset(fname, 0, PATH_MAX*sizeof(char));\n        sprintf(fname, \"%s/%s.%s.%s.%s.EST.SAC\",\n                WAVOUT_DIR,\n                data.data[iobs].header.knetwk,\n                data.data[iobs].header.kstnm,\n                data.data[iobs].header.kcmpnm,\n                data.data[iobs].header.khole);\n        sacio_writeTimeSeriesFile(fname, data.est[iobs]);\n        printf(\"Waveform %6s has lag %+4d=%+8.3e (s) and a fit of %f\\n\",\n               data.data[iobs].header.kstnm,\n               lag, lag*data.data[iobs].header.delta, phiLoc);\n        memory_free64f(&G); \n        memory_free64f(&var);\n        xsum = xsum + phiLoc;\n    } \n    printf(\"Average %f\\n\", xsum/(double) data.nobs );\n/*\ndouble *db = memory_calloc64f(nb);\ndouble *dg = memory_calloc64f(ng);\ndouble *dt = memory_calloc64f(nt);\npostprocess_computeBetaCellSpacing(nb, betas, db); \n printf(\"\\n\");\npostprocess_computeGammaCellSpacing(ng, gammas, dg);\nprintf(\"\\n\");\npostprocess_computeThetaCellSpacing(nt, thetas, dt);\n*/\n    // Free memory\nERROR:;\n    parmt_freeData(&data);\n    memory_free64f(&depMagMPDF);\n    memory_free64f(&depMPDF);\n    memory_free64f(&deps);\n    memory_free64f(&M0s); \n    memory_free64f(&betas);\n    memory_free64f(&gammas);\n    memory_free64f(&kappas);\n    memory_free64f(&sigmas);\n    memory_free64f(&thetas);\n    memory_free64f(&phi);\n    iscl_finalize();\n    MPI_Finalize();\n    return ierr;\n}\n//============================================================================//\n/*!\n * @brief Parses the input arguments to get the ini file anme\n */\nstatic int parseArguments(int argc, char *argv[], char iniFile[PATH_MAX])\n{\n    bool linFile;\n    memset(iniFile, 0, PATH_MAX*sizeof(char));\n    while (true)\n    {\n        static struct option longOptions[] =\n        {\n            {\"help\", no_argument, 0, '?'},\n            {\"help\", no_argument, 0, 'h'},\n            {\"ini_file\", required_argument, 0, 'i'},\n            {0, 0, 0, 0}\n        };  \n        int c, optionIndex;\n        c = getopt_long(argc, argv, \"?hi:\",\n                        longOptions, &optionIndex);\n        if (c ==-1){break;}\n        if (c == 'i')\n        {   \n            strcpy(iniFile, (const char *) optarg);\n            linFile = true; \n        }\n        else if (c == 'h' || c == '?')\n        {\n            printUsage();\n            return -2;\n        }   \n        else\n        {\n            printf(\"%s: Unknown options: %s\\n\",\n                   PROGRAM_NAME, argv[optionIndex]);\n        }\n    }\n    if (!linFile)\n    {\n        printf(\"%s: Error must specify ini file\\n\\n\", PROGRAM_NAME);\n        printUsage();\n        return -1;\n    }\n    return 0;\n}\n\nstatic void printUsage(void)\n{\n    printf(\"Usage:\\n   postmt -i input_file\\n\\n\");\n    printf(\"Required arguments:\\n\");\n    printf(\"   -i input_file specifies the initialization file\\n\");\n    printf(\"\\n\");\n    printf(\"Optional arguments:\\n\");\n    printf(\"   -h displays this message\\n\");\n    return;\n}\n\n\nint parmt_freeData(struct parmtData_struct *data)\n{\n    int i;\n    if (data->nobs > 0 && data->nlocs > 0 &&\n        data->sacGxx != NULL && data->sacGyy != NULL && data->sacGzz != NULL &&\n        data->sacGxy != NULL && data->sacGxz != NULL && data->sacGyz != NULL)\n    {\n        for (i=0; i<data->nobs*data->nlocs; i++)\n        {\n            sacio_freeData(&data->sacGxx[i]);\n            sacio_freeData(&data->sacGyy[i]);\n            sacio_freeData(&data->sacGzz[i]);\n            sacio_freeData(&data->sacGxy[i]);\n            sacio_freeData(&data->sacGxz[i]);\n            sacio_freeData(&data->sacGyz[i]);\n        }\n        free(data->sacGxx);\n        free(data->sacGyy);\n        free(data->sacGzz);\n        free(data->sacGxy);\n        free(data->sacGxz);\n        free(data->sacGyz);\n    }\n    if (data->nobs > 0 && data->data != NULL)\n    {\n        for (i=0; i<data->nobs; i++)\n        {\n            sacio_freeData(&data->data[i]);\n        }\n        free(data->data);\n    }\n    if (data->nobs > 0 && data->est != NULL)\n    {\n        free(data->est);\n    }\n    memset(data, 0, sizeof(struct parmtData_struct));\n    return 0;\n}\n", "meta": {"hexsha": "acf976e353614f8f9e920165766ccfb3a8a3b170", "size": 22959, "ext": "c", "lang": "C", "max_stars_repo_path": "postprocess/postmt.c", "max_stars_repo_name": "bakerb845/parmt", "max_stars_repo_head_hexsha": "2b4097df02ef5e56407d40e821d5c7155c2e4416", "max_stars_repo_licenses": ["Intel"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "postprocess/postmt.c", "max_issues_repo_name": "bakerb845/parmt", "max_issues_repo_head_hexsha": "2b4097df02ef5e56407d40e821d5c7155c2e4416", "max_issues_repo_licenses": ["Intel"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "postprocess/postmt.c", "max_forks_repo_name": "bakerb845/parmt", "max_forks_repo_head_hexsha": "2b4097df02ef5e56407d40e821d5c7155c2e4416", "max_forks_repo_licenses": ["Intel"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.650621118, "max_line_length": 89, "alphanum_fraction": 0.5020253495, "num_tokens": 6514, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4263215925474903, "lm_q2_score": 0.021287350900896458, "lm_q1q2_score": 0.00907525733718743}}
{"text": "#include <gsl/gsl_matrix.h>\n#include <gsl/gsl_vector.h>\n#include \"cimple_polytope_library.h\"\n\n/**\n * \"Constructor\" Dynamically allocates the space a polytope needs\n */\nstruct polytope *polytope_alloc(size_t k,\n                                size_t n)\n{\n\n    struct polytope *return_polytope = malloc (sizeof (struct polytope));\n\n    return_polytope->H = gsl_matrix_alloc(k, n);\n    if (return_polytope->H == NULL) {\n        free (return_polytope);\n        return NULL;\n    }\n\n    return_polytope->G = gsl_vector_alloc(k);\n    if (return_polytope->H == NULL) {\n        free (return_polytope);\n        return NULL;\n    }\n\n    return_polytope->chebyshev_center = malloc(n* sizeof (double));\n    if (return_polytope->chebyshev_center == NULL) {\n        free (return_polytope);\n        return NULL;\n    }\n\n    return return_polytope;\n};\n\n/**\n * \"Destructor\" Deallocates the dynamically allocated memory of the polytope\n */\nvoid polytope_free(polytope *polytope)\n{\n    gsl_matrix_free(polytope->H);\n    gsl_vector_free(polytope->G);\n    free(polytope->chebyshev_center);\n    free(polytope);\n};\n\n/**\n * \"Constructor\" Dynamically allocates the space a polytope needs\n */\nstruct cell *cell_alloc(size_t k,\n                        size_t n,\n                        int time_horizon)\n{\n\n    struct cell *return_cell = malloc (sizeof (struct cell));\n\n    return_cell->safe_mode = malloc(sizeof(polytope)*time_horizon);\n    if (return_cell->safe_mode == NULL) {\n        free (return_cell);\n        return NULL;\n    }\n\n    return_cell->polytope_description = polytope_alloc(k,n);\n    if (return_cell->polytope_description == NULL) {\n        free (return_cell);\n        return NULL;\n    }\n    return return_cell;\n};\n\n/**\n * \"Destructor\" Deallocates the dynamically allocated memory of the region of polytopes\n */\nvoid cell_free(cell *cell)\n{\n    polytope_free(cell->polytope_description);\n    free(cell->safe_mode);\n    free(cell);\n\n};\n\n/**\n * \"Constructor\" Dynamically allocates the space a region of polytope needs\n */\nstruct abstract_state *abstract_state_alloc(size_t *k,\n                                            size_t k_hull,\n                                            size_t n,\n                                            int transitions_in_count,\n                                            int transitions_out_count,\n                                            int cells_count,\n                                            int time_horizon)\n{\n\n    struct abstract_state *return_abstract_state = malloc (sizeof (struct abstract_state));\n\n    /*\n     * Default values: at initialization safe mode is not yet computed.\n     * Thus it is assumed that the state does not contain an invariant set => invariant_set = NULL\n     * next_state (next state the system has to transition to reach an invariant set) is unknown at initialization.\n     */\n\n    return_abstract_state->next_state = NULL;\n    return_abstract_state->invariant_set = NULL;\n//    return_abstract_state->distance_invariant_set = INFINITY;\n\n    return_abstract_state->cells = malloc(sizeof(cell)*cells_count);\n    if (return_abstract_state->cells == NULL) {\n        free (return_abstract_state);\n        return NULL;\n    }\n\n    for(int i = 0; i < cells_count; i++){\n        return_abstract_state->cells[i] = cell_alloc(*(k+i), n, time_horizon);\n        if (return_abstract_state->cells[i] == NULL) {\n            free (return_abstract_state);\n            return NULL;\n        }\n    }\n\n    return_abstract_state->cells_count = cells_count;\n\n    return_abstract_state->transitions_in = malloc(sizeof(struct abstract_state) * transitions_in_count);\n    if (return_abstract_state->transitions_in == NULL) {\n        free (return_abstract_state);\n        return NULL;\n    }\n\n    return_abstract_state->transitions_in_count = transitions_in_count;\n\n    return_abstract_state->transitions_out = malloc(sizeof(struct abstract_state) * transitions_out_count);\n    if (return_abstract_state->transitions_out == NULL) {\n        free (return_abstract_state);\n        return NULL;\n    }\n\n    return_abstract_state->transitions_out_count = transitions_out_count;\n\n    return_abstract_state->convex_hull = polytope_alloc(k_hull, n);\n    if (return_abstract_state->convex_hull == NULL) {\n        free (return_abstract_state);\n        return NULL;\n    }\n\n    return return_abstract_state;\n};\n\n/**\n * \"Destructor\" Deallocates the dynamically allocated memory of the region of polytopes\n */\nvoid abstract_state_free(abstract_state * abstract_state){\n    polytope_free(abstract_state->convex_hull);\n    for(int i = 0; i< abstract_state->cells_count; i++){\n        cell_free(abstract_state->cells[i]);\n    }\n    free(abstract_state->transitions_out);\n    free(abstract_state->transitions_in);\n    free(abstract_state->cells);\n    free(abstract_state);\n\n};\n\n/**\n * Converts two C arrays to a polytope consistent of a left side matrix (i.e. H) and right side vector (i.e. G)\n */\nvoid polytope_from_arrays(polytope *polytope,\n                          double *left_side,\n                          double *right_side,\n                          double *cheby,\n                          char*name)\n{\n\n    gsl_matrix_from_array(polytope->H, left_side, name);\n    gsl_vector_from_array(polytope->G, right_side, name);\n    for(int i = 0; i < polytope->H->size2; i++){\n        polytope->chebyshev_center[i] = cheby[i];\n    }\n};\n\n/**\n * Converts a polytope in gsl form to cdd constraint form\n */\ndd_PolyhedraPtr polytope_to_cdd(polytope *original,\n                                dd_ErrorType *err)\n{\n    dd_PolyhedraPtr new;\n    dd_MatrixPtr constraints;\n    constraints = dd_CreateMatrix(original->H->size1, (original->H->size2+1));\n    for (size_t k = 0; k < (original->H->size1); k++) {\n        double value = gsl_vector_get(original->G, k);\n        dd_set_d(constraints->matrix[k][0],value);\n    }\n    for(size_t i = 0; i<original->H->size1; i++){\n        for (size_t j = 1; j < (original->H->size2+1); j++) {\n            double value = gsl_matrix_get(original->H, i, j-1);\n            dd_set_d(constraints->matrix[i][j],-1*value);\n        }\n    }\n    constraints->representation=dd_Inequality;\n    new = dd_DDMatrix2Poly(constraints, err);\n    dd_FreeMatrix(constraints);\n    return new;\n};\n\n/**\n * Converts a polytope in cdd constraint form to gsl form\n */\npolytope * cdd_to_polytope(dd_PolyhedraPtr *original)\n{\n\n    dd_MatrixPtr constraints;\n    constraints = dd_CopyInequalities(*original);\n    polytope *new = polytope_alloc(constraints->rowsize, constraints->colsize-1);\n    for (size_t k = 0; k < (constraints->rowsize); k++) {\n        double value = dd_get_d(constraints->matrix[k][0]);\n        gsl_vector_set(new->G, k, value);\n    }\n    for(size_t i = 0; i<constraints->rowsize; i++){\n        for (size_t j = 0; j < (constraints->colsize-1); j++) {\n            double value = dd_get_d(constraints->matrix[i][j+1]);\n            gsl_matrix_set(new->H,i,j,-value);\n        }\n    }\n    dd_FreeMatrix(constraints);\n    return new;\n\n};\n\n/**\n * Generate a polytope representing a scaled unit cube\n */\npolytope * polytope_scaled_unit_cube(double scale,\n                                     int dimensions)\n{\n\n    dd_PolyhedraPtr cube = cdd_scaled_unit_cube(scale, dimensions);\n    polytope * return_cube = cdd_to_polytope(&cube);\n    dd_FreePolyhedra(cube);\n\n    return return_cube;\n};\n\n/**\n * Checks whether a state is in a certain polytope\n */\nbool polytope_check_state(polytope *polytope,\n                         gsl_vector *x)\n{\n    gsl_vector * result = gsl_vector_alloc(polytope->G->size);\n    gsl_blas_dgemv(CblasNoTrans, 1.0, polytope->H, x, 0.0, result);\n    for(size_t i = 0; i< polytope->G->size; i++){\n        if(gsl_vector_get(result, i) > gsl_vector_get(polytope->G, i)){\n            gsl_vector_free(result);\n            return false;\n        }\n    }\n    gsl_vector_free(result);\n    return true;\n};\n\n/**\n * Checks whether polytope P1 \\ issubset P2\n */\nbool polytope_is_subset(polytope *P1,\n                        polytope *P2)\n{\n    dd_ErrorType err = dd_NoError;\n    dd_PolyhedraPtr first = polytope_to_cdd(P1, &err);\n    dd_MatrixPtr verticesFirst = dd_CopyGenerators(first);\n    gsl_vector *vertex = gsl_vector_alloc(P1->H->size2);\n    gsl_vector_set_zero(vertex);\n    int is_included;\n    bool is_subset = true;\n    for(int i = 0; i<verticesFirst->rowsize;i++){\n        double valueFirst0 = dd_get_d(verticesFirst->matrix[i][0]);\n        if(valueFirst0 == 1){\n            for(int j = 0; j<vertex->size; j++){\n                double valueFirstj = dd_get_d(verticesFirst->matrix[i][j+1]);\n                gsl_vector_set(vertex,(size_t)j, valueFirstj);\n            }\n            is_included = polytope_check_state(P2,vertex);\n            if(!is_included){\n                is_subset = false;\n                break;\n            }\n        }\n    }\n    gsl_vector_free(vertex);\n    dd_FreePolyhedra(first);\n    dd_FreeMatrix(verticesFirst);\n    return is_subset;\n};\n\n/**\n * Unite inequalities of P1 and P2 in new polytope and remove redundancies\n */\npolytope * polytope_unite_inequalities(polytope *P1,\n                                       polytope *P2)\n{\n    polytope *united = polytope_alloc(P1->H->size1+P2->H->size1,P1->H->size2);\n    //Unite H\n    gsl_matrix_set_zero(united->H);\n    gsl_matrix_view H_P1 = gsl_matrix_submatrix(united->H, 0, 0, P1->H->size1, P1->H->size2);\n    gsl_matrix_memcpy(&H_P1.matrix, P1->H);\n    gsl_matrix_view H_P2 = gsl_matrix_submatrix(united->H, P1->H->size1, 0, P2->H->size1, P2->H->size2);\n    gsl_matrix_memcpy(&H_P2.matrix, P2->H);\n\n    //Unite G\n    gsl_vector_set_zero(united->G);\n    gsl_vector_view G_P1 = gsl_vector_subvector(united->G, 0, P1->G->size);\n    gsl_vector_memcpy(&G_P1.vector, P1->G);\n    gsl_vector_view G_P2 = gsl_vector_subvector(united->G, P1->G->size,P2->G->size);\n    gsl_vector_memcpy(&G_P2.vector, P2->G);\n    polytope * return_polytope = polytope_minimize(united);\n\n    polytope_free(united);\n\n    return return_polytope;\n\n};\n\n/**\n * Project original polytope (in cdd format) to the first n dimensions\n */\npolytope * polytope_projection(polytope * original,\n                               size_t n)\n{\n\n    dd_ErrorType err;\n    dd_PolyhedraPtr orig_cdd = polytope_to_cdd(original, &err);\n    dd_PolyhedraPtr new_cdd = NULL;\n\n    cdd_projection(&orig_cdd, &new_cdd, n, &err);\n    polytope * new = cdd_to_polytope(&new_cdd);\n    dd_FreePolyhedra(orig_cdd);\n    dd_FreePolyhedra(new_cdd);\n\n    return new;\n\n};\n\npolytope * polytope_linear_transform(polytope *original,\n                                     gsl_matrix *scale){\n\n    dd_ErrorType err = dd_NoError;\n    dd_PolyhedraPtr orig_cdd = polytope_to_cdd(original, &err);\n\n    dd_MatrixPtr vertices = dd_CopyGenerators(orig_cdd);\n\n    dd_MatrixPtr transformed_vertices = dd_CreateMatrix(1, scale->size1+1);\n    dd_MatrixPtr transformed_vertex = dd_CreateMatrix(1, scale->size1+1);\n    bool new_matrix_started = false;\n    gsl_vector *vertex = gsl_vector_alloc((vertices->colsize - 1));\n    gsl_vector *scaled_vertex = gsl_vector_alloc(scale->size1);\n    gsl_vector_set_zero(vertex);\n    gsl_vector_set_zero(scaled_vertex);\n\n    for(int i = 0; i<vertices->rowsize; i++) {\n        //Check whether row represents ray or vertex\n        double is_vertex = dd_get_d(vertices->matrix[i][0]);\n        if (is_vertex == 1) {\n            for (size_t j = 1; j < vertices->colsize; j++) {\n                double value = dd_get_d(vertices->matrix[i][j]);\n                gsl_vector_set(vertex, j-1, value);\n            }\n            gsl_blas_dgemv(CblasNoTrans, 1.0, scale, vertex, 0.0, scaled_vertex);\n\n            if (new_matrix_started) {\n                dd_set_d(transformed_vertex->matrix[0][0], 1);\n                for (size_t j = 0; j < scaled_vertex->size; j++) {\n                    dd_set_d(transformed_vertex->matrix[0][j + 1], gsl_vector_get(scaled_vertex, j));\n                }\n                dd_MatrixAppendTo(&transformed_vertices, transformed_vertex);\n            } else {\n                dd_set_d(transformed_vertices->matrix[0][0], 1);\n                for (size_t j = 0; j < scaled_vertex->size; j++) {\n                    dd_set_d(transformed_vertices->matrix[0][j + 1], gsl_vector_get(scaled_vertex, j));\n                }\n                new_matrix_started = true;\n            }\n\n        }\n    }\n\n    transformed_vertices->representation = dd_Generator;\n    dd_PolyhedraPtr transformed_cdd = dd_DDMatrix2Poly(transformed_vertices, &err);\n    polytope *transformed = cdd_to_polytope(&transformed_cdd);\n\n    //Clean up\n    dd_FreeMatrix(transformed_vertex);\n    dd_FreeMatrix(transformed_vertices);\n    dd_FreePolyhedra(orig_cdd);\n    dd_FreePolyhedra(transformed_cdd);\n    dd_FreeMatrix(vertices);\n    gsl_vector_free(vertex);\n    gsl_vector_free(scaled_vertex);\n\n    return transformed;\n\n};\n/**\n * Remove redundancies from gsl polytope inequalities\n */\npolytope * polytope_minimize(polytope *original)\n{\n\n\n    dd_ErrorType err = dd_NoError;\n    dd_MatrixPtr min_matrix;\n\n    dd_PolyhedraPtr cdd_original = polytope_to_cdd(original, &err);\n\n    dd_PolyhedraPtr cdd_minimized = cdd_minimize(&cdd_original, &err);\n    min_matrix = dd_CopyInequalities(cdd_minimized);\n\n    polytope * minimized = cdd_to_polytope(&cdd_minimized);\n    dd_FreeMatrix(min_matrix);\n    dd_FreePolyhedra(cdd_original);\n    dd_FreePolyhedra(cdd_minimized);\n\n    return minimized;\n\n};\n\n/**\n * Compute Minkowski sum of two polytopes\n */\npolytope * polytope_minkowski(polytope *P1,\n                              polytope *P2)\n{\n    dd_ErrorType err = dd_NoError;\n    dd_PolyhedraPtr A = polytope_to_cdd(P1, &err);\n    dd_PolyhedraPtr B = polytope_to_cdd(P2, &err);\n    dd_PolyhedraPtr C = cdd_minkowski(A,B);\n    polytope * returnPolytope = cdd_to_polytope(&C);\n    dd_FreePolyhedra(A);\n    dd_FreePolyhedra(B);\n    dd_FreePolyhedra(C);\n    return returnPolytope;\n};\n\n/**\n * Compute Pontryagin difference C = A-B s.t.:\n * A-B = {c \\in A-B| c+b \\in A, \\forall b \\in B}\n */\npolytope * polytope_pontryagin(polytope* A,\n                               polytope* B)\n{\n\n    dd_ErrorType err;\n    dd_MatrixPtr verticesA, verticesB;\n    //create cddPoly A,B\n    dd_PolyhedraPtr cddA = polytope_to_cdd(A, &err);\n\n    dd_PolyhedraPtr cddB = polytope_to_cdd(B, &err);\n\n    polytope *C = NULL;\n\n    verticesA = dd_CopyGenerators(cddA);\n    verticesB = dd_CopyGenerators(cddB);\n    for(int i = 0; i<verticesB->rowsize; i++){\n        //Check whether row represents ray or vertex\n        double value_B0 = dd_get_d(verticesB->matrix[i][0]);\n        if(value_B0 == 1){\n            dd_MatrixPtr tempA;\n            //A-b (where b is the vertex)\n            tempA = dd_CreateMatrix(verticesA->rowsize,verticesA->colsize);\n            //each vertex of A displaced by b\n            for(int j = 0; j<verticesA->rowsize; j++){\n                double value_A0 = dd_get_d(verticesA->matrix[j][0]);\n                if(value_A0 == 1){\n                    dd_set_d(tempA->matrix[j][0], 1);\n                    for(int k = 1; k<verticesA->colsize; k++){\n                        double value_Ak = dd_get_d(verticesA->matrix[j][k]);\n                        double value_Bk = dd_get_d(verticesB->matrix[i][k]);\n                        dd_set_d(tempA->matrix[j][k],(value_Ak-value_Bk));\n                    }\n                }else{\n                    dd_set_d(tempA->matrix[j][0], 0);\n                    for(int k = 1; k<verticesA->colsize; k++){\n                        double value_Ak = dd_get_d(verticesA->matrix[j][k]);\n                        dd_set_d(tempA->matrix[j][k],(value_Ak));\n                    }\n                }\n            }\n            dd_PolyhedraPtr cdd_temp;\n            tempA->representation = dd_Generator;\n            cdd_temp = dd_DDMatrix2Poly(tempA, &err);\n            polytope *tempC = cdd_to_polytope(&cdd_temp);\n            dd_FreePolyhedra(cdd_temp);\n            if(C == NULL){\n                C = polytope_alloc(tempC->H->size1,tempC->H->size2);\n                gsl_matrix_memcpy(C->H,tempC->H);\n                gsl_vector_memcpy(C->G,tempC->G);\n                polytope_free(tempC);\n            }else{\n                polytope *copyC = C;\n                C = polytope_unite_inequalities(copyC, tempC);\n                polytope_free(tempC);\n                polytope_free(copyC);\n            }\n            dd_FreeMatrix(tempA);\n        }\n    }\n\n    dd_FreeMatrix(verticesA);\n    dd_FreeMatrix(verticesB);\n    dd_FreePolyhedra(cddA);\n    dd_FreePolyhedra(cddB);\n    return C;\n};\n\n/**\n * Set up constraints in quadratic problem for GUROBI\n */\nint polytope_to_constraints_gurobi(polytope *constraints,\n                                   GRBmodel *model,\n                                   size_t N)\n{\n\n    int error = 0;\n    double constraint_val[N];\n    int ind[N];\n    for(size_t i = 0; i < constraints->H->size1;i++){\n        char constraint_name[5];\n        sprintf(constraint_name, \"c_%d\", (int)i);\n        for(size_t j = 0; j < N;j++){\n            ind[j] = (int)j;\n            constraint_val[j] = gsl_matrix_get(constraints->H,i,j);\n        }\n\n        error = GRBaddconstr(model, (int)N, ind, constraint_val, GRB_LESS_EQUAL, gsl_vector_get(constraints->G,i), constraint_name);\n\n        if(error){\n            return error;\n        }\n    }\n    return error;\n};\n\n/**\n * Generate a polytope representing a scaled unit cube\n */\ndd_PolyhedraPtr cdd_scaled_unit_cube(double scale,\n                                     int dimensions)\n{\n\n    dd_MatrixPtr constraints;\n    dd_PolyhedraPtr cube = NULL;\n    dd_ErrorType err = dd_NoError;\n    constraints = dd_CreateMatrix(dimensions*2,dimensions+1);\n    for(int i = 0; i<(dimensions); i++){\n\n            dd_set_d(constraints->matrix[2*i][0],(scale*0.5));\n            dd_set_d(constraints->matrix[2*i][i+1],-1);\n            dd_set_d(constraints->matrix[2*i+1][0],(scale*0.5));\n            dd_set_d(constraints->matrix[2*i+1][i+1],1);\n    }\n    constraints->representation=dd_Inequality;\n    cube = dd_DDMatrix2Poly(constraints, &err);\n    dd_FreeMatrix(constraints);\n\n    return cube;\n};\n\n\n/**\n * Project original polytope (in cdd format) to the first n dimensions\n */\nvoid cdd_projection(dd_PolyhedraPtr *original,\n                    dd_PolyhedraPtr *new,\n                    size_t n,\n                    dd_ErrorType *err)\n{\n    dd_MatrixPtr full=NULL,projected=NULL;\n    full = dd_CopyInequalities(*original);\n    dd_colrange j,d;\n    dd_rowset redset,impl_linset;\n    dd_colset delset;\n    dd_rowindex newpos;\n\n    d=full->colsize;\n    set_initialize(&delset, d);\n    for (j=n+1; j<d; j++){\n        set_addelem(delset, j+1);\n    }\n\n    projected=dd_BlockElimination(full, delset, err);\n\n    dd_MatrixCanonicalize(&projected,&impl_linset,&redset,&newpos,err);\n\n    dd_FreeMatrix(full);\n    projected->representation = dd_Inequality;\n    *new = dd_DDMatrix2Poly(projected, err);\n    dd_FreeMatrix(projected);\n    set_free(delset);\n    set_free(redset);\n    set_free(impl_linset);\n    free(newpos);\n\n};\n\n/**\n * Remove redundancies from cdd polytope inequalities\n */\ndd_PolyhedraPtr cdd_minimize(dd_PolyhedraPtr *original,\n                             dd_ErrorType *err)\n{\n\n    dd_rowset redset,impl_linset;\n    dd_rowindex newpos;\n    dd_MatrixPtr full=NULL;\n    full = dd_CopyInequalities(*original);\n    dd_MatrixCanonicalize(&full,&impl_linset,&redset,&newpos,err);\n\n    full->representation = dd_Inequality;\n    dd_PolyhedraPtr new = dd_DDMatrix2Poly(full, err);\n    dd_FreeMatrix(full);\n    set_free(redset);\n    set_free(impl_linset);\n    free(newpos);\n    return new;\n\n};", "meta": {"hexsha": "28c77a4f009be1dd20d8f75b66d48391e6b08504", "size": 19466, "ext": "c", "lang": "C", "max_stars_repo_path": "Interface/Cimple/cimple_polytope_library.c", "max_stars_repo_name": "shaesaert/TuLiPXML", "max_stars_repo_head_hexsha": "56cf4d58a9d7e17b6f6aebe6de8d5a1231035671", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-05-28T23:44:28.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-28T23:44:28.000Z", "max_issues_repo_path": "Interface/Cimple/cimple_polytope_library.c", "max_issues_repo_name": "shaesaert/TuLiPXML", "max_issues_repo_head_hexsha": "56cf4d58a9d7e17b6f6aebe6de8d5a1231035671", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2017-10-03T18:54:08.000Z", "max_issues_repo_issues_event_max_datetime": "2018-08-21T09:50:09.000Z", "max_forks_repo_path": "Interface/Cimple/cimple_polytope_library.c", "max_forks_repo_name": "shaesaert/TuLiPXML", "max_forks_repo_head_hexsha": "56cf4d58a9d7e17b6f6aebe6de8d5a1231035671", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2018-10-06T12:58:52.000Z", "max_forks_repo_forks_event_max_datetime": "2018-10-06T12:58:52.000Z", "avg_line_length": 31.2958199357, "max_line_length": 132, "alphanum_fraction": 0.6184629611, "num_tokens": 5106, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3886180408675583, "lm_q2_score": 0.023330769572455574, "lm_q1q2_score": 0.009066757963180126}}
{"text": "#include <assert.h>\n#include <stdlib.h>\n#include <ctype.h>\n#include <string.h>\n\n#include <asf.h>\n#include \"asf_tiff.h\"\n\n#include <gsl/gsl_math.h>\n#include <proj_api.h>\n\n#include \"asf_jpeg.h\"\n#include <png.h>\n#include \"envi.h\"\n\n#include \"dateUtil.h\"\n#include <time.h>\n#include \"matrix.h\"\n#include <asf_nan.h>\n#include <asf_endian.h>\n#include <asf_meta.h>\n#include <asf_export.h>\n#include <asf_raster.h>\n#include <float_image.h>\n#include <spheroids.h>\n#include <typlim.h>\n#include <hdf5.h>\n#include <netcdf.h>\n\n#define RES 16\n#define MAX_PTS 256\n\nvoid nc_meta_double(int group_id, char *name, char *desc, char *units,\n\t\t    double *value)\n{\n  int var_id;\n  char *str = (char *) MALLOC(sizeof(char)*1024);\n  nc_def_var(group_id, name, NC_DOUBLE, 0, 0, &var_id);\n  nc_put_att_text(group_id, var_id, \"long_name\", strlen(desc), desc);\n  if (units && strlen(units) > 0) {\n    strcpy(str, units);\n    nc_put_att_text(group_id, var_id, \"units\", strlen(str), str);\n  }\n  nc_put_var_double(group_id, var_id, value);\n}\n\nvoid nc_meta_float(int group_id, char *name, char *desc, char *units, \n\t\t   float *value)\n{\n  int var_id;\n  char *str = (char *) MALLOC(sizeof(char)*1024);\n  nc_def_var(group_id, name, NC_FLOAT, 0, 0, &var_id);\n  nc_put_att_text(group_id, var_id, \"long_name\", strlen(desc), desc);\n  if (units && strlen(units) > 0) {\n    strcpy(str, units);\n    nc_put_att_text(group_id, var_id, \"units\", strlen(str), str);\n  }\n  nc_put_var_float(group_id, var_id, value);\n}\n\nvoid nc_meta_int(int group_id, char *name, char *desc, char *units,\n\t\t int *value)\n{\n  int var_id;\n  char *str = (char *) MALLOC(sizeof(char)*1024);\n  nc_def_var(group_id, name, NC_INT, 0, 0, &var_id);\n  nc_put_att_text(group_id, var_id, \"long_name\", strlen(desc), desc);\n  if (units && strlen(units) > 0) {\n    strcpy(str, units);\n    nc_put_att_text(group_id, var_id, \"units\", strlen(str), str);\n  }\n  nc_put_var_int(group_id, var_id, value);\n}\n\nvoid nc_meta_str(int group_id, char *name, char *desc, char *units,\n\t\t char *value)\n{\n  int var_id;\n  const char *str_value = (char *) MALLOC(sizeof(char)*strlen(value));\n  strcpy(str_value, value);\n  char *str = (char *) MALLOC(sizeof(char)*1024);\n  nc_def_var(group_id, name, NC_STRING, 0, 0, &var_id);\n  nc_put_att_text(group_id, var_id, \"long_name\", strlen(desc), desc);\n  if (units && strlen(units) > 0) {\n    strcpy(str, units);\n    nc_put_att_text(group_id, var_id, \"units\", strlen(str), str);\n  }\n  nc_put_var_string(group_id, var_id, &str_value);\n}\n\nnetcdf_t *initialize_netcdf_file(const char *output_file, \n\t\t\t\t meta_parameters *meta)\n{\n  int ii, status, ncid, var_id;\n  int dim_xgrid_id, dim_ygrid_id, dim_lat_id, dim_lon_id, dim_time_id;\n  char *spatial_ref=NULL, *datum=NULL, *spheroid=NULL;\n\n  // Convenience variables\n  meta_general *mg = meta->general;\n  meta_sar *ms = meta->sar;\n  meta_state_vectors *mo = meta->state_vectors;\n  meta_projection *mp = meta->projection;\n\n  // Assign parameters\n  int projected = FALSE;\n  int band_count = mg->band_count;\n  int variable_count = band_count + 3;\n  if (mp && mp->type != SCANSAR_PROJECTION) {\n    projected = TRUE;\n    variable_count += 2;\n  }\n  size_t line_count = mg->line_count;\n  size_t sample_count = mg->sample_count;\n\n  // Assign data type\n  nc_type datatype;\n  if (mg->data_type == BYTE)\n    datatype = NC_CHAR;\n  else if (mg->data_type == REAL32)\n    datatype = NC_FLOAT;\n\n  // Initialize the netCDF pointer structure\n  netcdf_t *netcdf = (netcdf_t *) MALLOC(sizeof(netcdf_t));\n  netcdf->var_count = variable_count;\n  netcdf->var_id = (int *) MALLOC(sizeof(int)*variable_count);\n\n  // Create the actual file\n  status = nc_create(output_file, NC_CLOBBER|NC_NETCDF4, &ncid);\n  netcdf->ncid = ncid;\n  if (status != NC_NOERR)\n    asfPrintError(\"Could not open netCDF file (%s).\\n\", nc_strerror(status));\n\n  // Define dimensions\n  if (projected) {\n    nc_def_dim(ncid, \"xgrid\", sample_count, &dim_xgrid_id);\n    nc_def_dim(ncid, \"ygrid\", line_count, &dim_ygrid_id);\n  }\n  else {\n    status = nc_def_dim(ncid, \"longitude\", sample_count, &dim_lon_id);\n    if (status != NC_NOERR)\n      asfPrintError(\"Problem with longitude definition\\n\");\n    status = nc_def_dim(ncid, \"latitude\", line_count, &dim_lat_id);\n    if (status != NC_NOERR)\n      asfPrintError(\"Problem with latitude definition\\n\");\n  }\n  status = nc_def_dim(ncid, \"time\", 1, &dim_time_id);\n  if (status != NC_NOERR)\n    asfPrintError(\"Problem with time definition\\n\");\n\n  // Define projection\n  char *str = (char *) MALLOC(sizeof(char)*1024);\n  double lfValue;\n  if (projected) {\n    nc_def_var(ncid, \"projection\", NC_CHAR, 0, 0, &var_id);\n    if (mp->type == UNIVERSAL_TRANSVERSE_MERCATOR) {\n\n      strcpy(str, \"transverse_mercator\");\n      nc_put_att_text(ncid, var_id, \"grid_mapping_name\", strlen(str), str);\n      nc_put_att_double(ncid, var_id, \"scale_factor_at_central_meridian\", \n\t\t\tNC_DOUBLE, 1, &mp->param.utm.scale_factor);\n      nc_put_att_double(ncid, var_id, \"longitude_of_central_meridian\",\n\t\t\tNC_DOUBLE, 1, &mp->param.utm.lon0);\n      nc_put_att_double(ncid, var_id, \"latitude_of_projection_origin\",\n\t\t\tNC_DOUBLE, 1, &mp->param.utm.lat0);\n      nc_put_att_double(ncid, var_id, \"false_easting\", NC_DOUBLE, 1, \n\t\t\t&mp->param.utm.false_easting);\n      nc_put_att_double(ncid, var_id, \"false_northing\", NC_DOUBLE, 1, \n\t\t\t&mp->param.utm.false_northing);\n      strcpy(str, \"xgrid\");\n      nc_put_att_text(ncid, var_id, \"projection_x_coordinate\", strlen(str), \n\t\t      str);\n      strcpy(str, \"ygrid\");\n      nc_put_att_text(ncid, var_id, \"projection_y_coordinate\", strlen(str), \n\t\t      str);\n      strcpy(str, \"m\");\n      nc_put_att_text(ncid, var_id, \"units\", strlen(str), str); \n      nc_put_att_double(ncid, var_id, \"grid_boundary_top_projected_y\",\n\t\t\tNC_DOUBLE, 1, &mp->startY);\n      lfValue = mp->startY + mg->line_count * mp->perY;\n      nc_put_att_double(ncid, var_id, \"grid_boundary_bottom_projected_y\",\n\t\t\tNC_DOUBLE, 1, &lfValue);\n      lfValue = mp->startX + mg->sample_count * mp->perX;\n      nc_put_att_double(ncid, var_id, \"grid_boundary_right_projected_x\",\n\t\t\tNC_DOUBLE, 1, &lfValue);\n      nc_put_att_double(ncid, var_id, \"grid_boundary_left_projected_x\",\n\t\t\tNC_DOUBLE, 1, &mp->startX);\n      spatial_ref = (char *) MALLOC(sizeof(char)*1024);\n      datum = (char *) datum_toString(mp->datum);\n      spheroid = (char *) spheroid_toString(mp->spheroid);\n      double flat = mp->re_major/(mp->re_major - mp->re_minor);\n      sprintf(spatial_ref, \"PROJCS[\\\"%s_UTM_Zone_%d%c\\\",GEOGCS[\\\"GCS_%s\\\",DATUM[\\\"D_%s\\\",SPHEROID[\\\"%s\\\",%.1lf,%-16.11g]],PRIMEM[\\\"Greenwich\\\",0],UNIT[\\\"Degree\\\",0.017453292519943295]],PROJECTION[\\\"Transverse_Mercator\\\"],PARAMETER[\\\"False_Easting\\\",%.1lf],PARAMETER[\\\"False_Northing\\\",%.1lf],PARAMETER[\\\"Central_Meridian\\\",%.1lf],PARAMETER[\\\"Scale_Factor\\\",%.4lf],PARAMETER[\\\"Latitude_Of_Origin\\\",%.1lf],UNIT[\\\"Meter\\\",1]]\",\n\t      spheroid, mp->param.utm.zone, mp->hem, spheroid, datum, \n\t      spheroid, mp->re_major, flat, mp->param.utm.false_easting, \n\t      mp->param.utm.false_northing, mp->param.utm.lon0, \n\t      mp->param.utm.scale_factor, mp->param.utm.lat0);\n      nc_put_att_text(ncid, var_id, \"spatial_ref\", strlen(spatial_ref), \n\t\t      spatial_ref);\n      sprintf(str, \"+proj=utm +zone=%d\", mp->param.utm.zone);\n      if (meta->general->center_latitude < 0)\n\tstrcat(str, \" +south\");\n      nc_put_att_text(ncid, var_id, \"proj4text\", strlen(str), str);\n      nc_put_att_int(ncid, var_id, \"zone\", NC_INT, 1, &mp->param.utm.zone);\n      nc_put_att_double(ncid, var_id, \"semimajor_radius\", NC_DOUBLE, 1, \n\t\t\t&mp->re_major);\n      nc_put_att_double(ncid, var_id, \"semiminor_radius\", NC_DOUBLE, 1, \n\t\t\t&mp->re_minor);\n      sprintf(str, \"%.6lf %.6lf 0 %.6lf 0 %.6lf\", mp->startX, mp->perX, \n\t      mp->startY, mp->perY); \n      nc_put_att_text(ncid, var_id, \"GeoTransform\", strlen(str), str);\n    }\n    else if (mp->type == POLAR_STEREOGRAPHIC) {\n\n      strcpy(str, \"polar_stereographic\");\n      nc_put_att_text(ncid, var_id, \"grid_mapping_name\", strlen(str), str);\n      lfValue = 90.0;\n      nc_put_att_double(ncid, var_id, \"straight_vertical_longitude_from_pole\", \n\t\t\tNC_DOUBLE, 1, &mp->param.ps.slon);\n      nc_put_att_double(ncid, var_id, \"longitude_of_central_meridian\",\n\t\t\tNC_DOUBLE, 1, &lfValue);\n      nc_put_att_double(ncid, var_id, \"standard_parallel\",\n\t\t\tNC_DOUBLE, 1, &mp->param.ps.slat);\n      nc_put_att_double(ncid, var_id, \"false_easting\", NC_DOUBLE, 1, \n\t\t\t&mp->param.ps.false_easting);\n      nc_put_att_double(ncid, var_id, \"false_northing\", NC_DOUBLE, 1, \n\t\t\t&mp->param.ps.false_northing);\n      strcpy(str, \"xgrid\");\n      nc_put_att_text(ncid, var_id, \"projection_x_coordinate\", strlen(str), \n\t\t      str);\n      strcpy(str, \"ygrid\");\n      nc_put_att_text(ncid, var_id, \"projection_y_coordinate\", strlen(str), \n\t\t      str);\n      strcpy(str, \"m\");\n      nc_put_att_text(ncid, var_id, \"units\", strlen(str), str); \n      nc_put_att_double(ncid, var_id, \"grid_boundary_top_projected_y\",\n\t\t\tNC_DOUBLE, 1, &mp->startY);\n      lfValue = mp->startY + mg->line_count * mp->perY;\n      nc_put_att_double(ncid, var_id, \"grid_boundary_bottom_projected_y\",\n\t\t\tNC_DOUBLE, 1, &lfValue);\n      lfValue = mp->startX + mg->sample_count * mp->perX;\n      nc_put_att_double(ncid, var_id, \"grid_boundary_right_projected_x\",\n\t\t\tNC_DOUBLE, 1, &lfValue);\n      nc_put_att_double(ncid, var_id, \"grid_boundary_left_projected_x\",\n\t\t\tNC_DOUBLE, 1, &mp->startX);\n      spatial_ref = (char *) MALLOC(sizeof(char)*1024);\n      datum = (char *) datum_toString(mp->datum);\n      spheroid = (char *) spheroid_toString(mp->spheroid);\n      double flat = mp->re_major/(mp->re_major - mp->re_minor);\n      sprintf(spatial_ref, \"PROJCS[\\\"Stereographic_North_Pole\\\",GEOGCS[\\\"unnamed ellipse\\\",DATUM[\\\"D_unknown\\\",SPHEROID[\\\"Unknown\\\",%.3lf,%-16.11g]],PRIMEM[\\\"Greenwich\\\",0],UNIT[\\\"Degree\\\",0.0002247191011236]],PROJECTION[\\\"Stereographic_North_Pole\\\"],PARAMETER[\\\"standard_parallel_1\\\",%.4lf],PARAMETER[\\\"central_meridian\\\",%.4lf],PARAMETER[\\\"scale_factor\\\",1],PARAMETER[\\\"false_easting\\\",%.3lf],PARAMETER[\\\"false_northing\\\",%.3lf],UNIT[\\\"Meter\\\",1,AUTHORITY[\\\"EPSG\\\",\\\"9122\\\"]],AUTHORITY[\\\"EPSG\\\",\\\"3411\\\"]]\",\n\t      mp->re_major, flat, mp->param.ps.slat, mp->param.ps.slon,\n\t      mp->param.ps.false_easting, mp->param.ps.false_northing);\n      nc_put_att_text(ncid, var_id, \"spatial_ref\", strlen(spatial_ref), \n\t\t      spatial_ref);\n      if (mp->param.ps.is_north_pole)\n\tsprintf(str, \"+proj=stere +lat_0=90.0000 +lat_ts=%.4lf \"\n\t\t\"+lon_0=%.4lf +k=1 +x_0=%.3lf +y_0=%.3lf +a=%.3lf +b=%.3lf \"\n\t\t\"+units=m +no_defs\", mp->param.ps.slat, mp->param.ps.slon,\n\t\tmp->param.ps.false_easting, mp->param.ps.false_northing,\n\t\tmp->re_major, mp->re_minor);\n      else\n\tsprintf(str, \"+proj=stere +lat_0=-90.0000 +lat_ts=%.4lf \"\n\t\t\"+lon_0=%.4lf +k=1 +x_0=%.3lf +y_0=%.3lf +a=%.3lf +b=%.3lf \"\n\t\t\"+units=m +no_defs\", mp->param.ps.slat, mp->param.ps.slon,\n\t\tmp->param.ps.false_easting, mp->param.ps.false_northing,\n\t\tmp->re_major, mp->re_minor);\n      nc_put_att_text(ncid, var_id, \"proj4text\", strlen(str), str);\n      nc_put_att_double(ncid, var_id, \"latitude_of_true_scale\", NC_DOUBLE, 1,\n\t\t\t&mp->param.ps.slat);\n      nc_put_att_double(ncid, var_id, \"longitude_of_projection_origin\", \n\t\t\tNC_DOUBLE, 1, &mp->param.ps.slon);\n      nc_put_att_double(ncid, var_id, \"semimajor_radius\", NC_DOUBLE, 1, \n\t\t\t&mp->re_major);\n      nc_put_att_double(ncid, var_id, \"semiminor_radius\", NC_DOUBLE, 1, \n\t\t\t&mp->re_minor);\n      sprintf(str, \"%.6lf %.6lf 0 %.6lf 0 %.6lf\", mp->startX, mp->perX, \n\t      mp->startY, mp->perY); \n      nc_put_att_text(ncid, var_id, \"GeoTransform\", strlen(str), str);\n    }\n    else if (mp->type == ALBERS_EQUAL_AREA) {\n\n      strcpy(str, \"albers_conical_equal_area\");\n      nc_put_att_text(ncid, var_id, \"grid_mapping_name\", strlen(str), str);\n      lfValue = 90.0;\n      nc_put_att_double(ncid, var_id, \"standard_parallel_1\", \n\t\t\tNC_DOUBLE, 1, &mp->param.albers.std_parallel1);\n      nc_put_att_double(ncid, var_id, \"standard_parallel_2\",\n\t\t\tNC_DOUBLE, 1, &mp->param.albers.std_parallel2);\n      nc_put_att_double(ncid, var_id, \"longitude_of_central_meridian\",\n\t\t\tNC_DOUBLE, 1, &mp->param.albers.center_meridian);\n      nc_put_att_double(ncid, var_id, \"latitude_of_projection_origin\",\n\t\t\tNC_DOUBLE, 1, &mp->param.albers.orig_latitude);\n      nc_put_att_double(ncid, var_id, \"false_easting\", NC_DOUBLE, 1, \n\t\t\t&mp->param.albers.false_easting);\n      nc_put_att_double(ncid, var_id, \"false_northing\", NC_DOUBLE, 1, \n\t\t\t&mp->param.albers.false_northing);\n      strcpy(str, \"xgrid\");\n      nc_put_att_text(ncid, var_id, \"projection_x_coordinate\", strlen(str), \n\t\t      str);\n      strcpy(str, \"ygrid\");\n      nc_put_att_text(ncid, var_id, \"projection_y_coordinate\", strlen(str), \n\t\t      str);\n      strcpy(str, \"m\");\n      nc_put_att_text(ncid, var_id, \"units\", strlen(str), str); \n      nc_put_att_double(ncid, var_id, \"grid_boundary_top_projected_y\",\n\t\t\tNC_DOUBLE, 1, &mp->startY);\n      lfValue = mp->startY + mg->line_count * mp->perY;\n      nc_put_att_double(ncid, var_id, \"grid_boundary_bottom_projected_y\",\n\t\t\tNC_DOUBLE, 1, &lfValue);\n      lfValue = mp->startX + mg->sample_count * mp->perX;\n      nc_put_att_double(ncid, var_id, \"grid_boundary_right_projected_x\",\n\t\t\tNC_DOUBLE, 1, &lfValue);\n      nc_put_att_double(ncid, var_id, \"grid_boundary_left_projected_x\",\n\t\t\tNC_DOUBLE, 1, &mp->startX);\n      spatial_ref = (char *) MALLOC(sizeof(char)*1024);\n      datum = (char *) datum_toString(mp->datum);\n      spheroid = (char *) spheroid_toString(mp->spheroid);\n      double flat = mp->re_major/(mp->re_major - mp->re_minor);\n      sprintf(spatial_ref, \"PROJCS[\\\"Albers_Equal_Area_Conic\\\",GEOGCS[\\\"GCS_%s\\\",DATUM[\\\"D_%s\\\",SPHEROID[\\\"%s\\\",%.3lf,%-16.11g]],PRIMEM[\\\"Greenwich\\\",0],UNIT[\\\"Degree\\\",0.0174532925199432955]],PROJECTION[\\\"Albers\\\"],PARAMETER[\\\"False_Easting\\\",%.3lf],PARAMETER[\\\"False_Northing\\\",%.3lf],PARAMETER[\\\"Central_Meridian\\\",%.4lf],PARAMETER[\\\"Standard_Parallel_1\\\",%.4lf],PARAMETER[\\\"Standard_Parallel_2\\\",%.4lf],PARAMETER[\\\"Latitude_Of_Origin\\\",%.4lf],UNIT[\\\"Meter\\\",1]]\",\n\t      datum, datum, spheroid, mp->re_major, flat, \n\t      mp->param.albers.false_easting, mp->param.albers.false_northing,\n\t      mp->param.albers.center_meridian, mp->param.albers.std_parallel1,\n\t      mp->param.albers.std_parallel2, mp->param.albers.orig_latitude);\n      nc_put_att_text(ncid, var_id, \"spatial_ref\", strlen(spatial_ref), \n\t\t      spatial_ref);\n      sprintf(str, \"+proj=aea +lat_1=%.4lf +lat_2=%.4lf +lat_0=%.4lf \"\n\t      \"+lon_0=%.4lf +x_0=%.3lf +y_0=%.3lf\", \n\t      mp->param.albers.std_parallel1, mp->param.albers.std_parallel2, \n\t      mp->param.albers.orig_latitude, mp->param.albers.center_meridian,\n\t      mp->param.albers.false_easting, mp->param.albers.false_northing);\n      nc_put_att_text(ncid, var_id, \"proj4text\", strlen(str), str);\n      nc_put_att_double(ncid, var_id, \"latitude_of_true_scale\", NC_DOUBLE, 1,\n\t\t\t&mp->param.ps.slat);\n      nc_put_att_double(ncid, var_id, \"longitude_of_projection_origin\", \n\t\t\tNC_DOUBLE, 1, &mp->param.ps.slon);\n      nc_put_att_double(ncid, var_id, \"semimajor_radius\", NC_DOUBLE, 1, \n\t\t\t&mp->re_major);\n      nc_put_att_double(ncid, var_id, \"semiminor_radius\", NC_DOUBLE, 1, \n\t\t\t&mp->re_minor);\n      sprintf(str, \"%.6lf %.6lf 0 %.6lf 0 %.6lf\", mp->startX, mp->perX, \n\t      mp->startY, mp->perY); \n      nc_put_att_text(ncid, var_id, \"GeoTransform\", strlen(str), str);\n    }\n    else if (mp->type == LAMBERT_CONFORMAL_CONIC) {\n\n      strcpy(str, \"lambert_conformal_conic\");\n      nc_put_att_text(ncid, var_id, \"grid_mapping_name\", strlen(str), str);\n      lfValue = 90.0;\n      nc_put_att_double(ncid, var_id, \"standard_parallel_1\", \n\t\t\tNC_DOUBLE, 1, &mp->param.lamcc.plat1);\n      nc_put_att_double(ncid, var_id, \"standard_parallel_2\",\n\t\t\tNC_DOUBLE, 1, &mp->param.lamcc.plat2);\n      nc_put_att_double(ncid, var_id, \"longitude_of_central_meridian\",\n\t\t\tNC_DOUBLE, 1, &mp->param.lamcc.lon0);\n      nc_put_att_double(ncid, var_id, \"latitude_of_projection_origin\",\n\t\t\tNC_DOUBLE, 1, &mp->param.lamcc.lat0);\n      nc_put_att_double(ncid, var_id, \"false_easting\", NC_DOUBLE, 1, \n\t\t\t&mp->param.lamcc.false_easting);\n      nc_put_att_double(ncid, var_id, \"false_northing\", NC_DOUBLE, 1, \n\t\t\t&mp->param.lamcc.false_northing);\n      strcpy(str, \"xgrid\");\n      nc_put_att_text(ncid, var_id, \"projection_x_coordinate\", strlen(str), \n\t\t      str);\n      strcpy(str, \"ygrid\");\n      nc_put_att_text(ncid, var_id, \"projection_y_coordinate\", strlen(str), \n\t\t      str);\n      strcpy(str, \"m\");\n      nc_put_att_text(ncid, var_id, \"units\", strlen(str), str); \n      nc_put_att_double(ncid, var_id, \"grid_boundary_top_projected_y\",\n\t\t\tNC_DOUBLE, 1, &mp->startY);\n      lfValue = mp->startY + mg->line_count * mp->perY;\n      nc_put_att_double(ncid, var_id, \"grid_boundary_bottom_projected_y\",\n\t\t\tNC_DOUBLE, 1, &lfValue);\n      lfValue = mp->startX + mg->sample_count * mp->perX;\n      nc_put_att_double(ncid, var_id, \"grid_boundary_right_projected_x\",\n\t\t\tNC_DOUBLE, 1, &lfValue);\n      nc_put_att_double(ncid, var_id, \"grid_boundary_left_projected_x\",\n\t\t\tNC_DOUBLE, 1, &mp->startX);\n      spatial_ref = (char *) MALLOC(sizeof(char)*1024);\n      datum = (char *) datum_toString(mp->datum);\n      spheroid = (char *) spheroid_toString(mp->spheroid);\n      double flat = mp->re_major/(mp->re_major - mp->re_minor);\n      sprintf(spatial_ref, \"PROJCS[\\\"Lambert_Conformal_Conic\\\",GEOGCS[\\\"GCS_%s\\\",DATUM[\\\"D_%s\\\",SPHEROID[\\\"%s\\\",%.3lf,%-16.11g]],PRIMEM[\\\"Greenwich\\\",0],UNIT[\\\"Degree\\\",0.0174532925199432955]],PROJECTION[\\\"Lambert_Conformal_Conic\\\"],PARAMETER[\\\"False_Easting\\\",%.3lf],PARAMETER[\\\"False_Northing\\\",%.3lf],PARAMETER[\\\"Central_Meridian\\\",%.4lf],PARAMETER[\\\"Standard_Parallel_1\\\",%.4lf],PARAMETER[\\\"Standard_Parallel_2\\\",%.4lf],PARAMETER[\\\"Latitude_Of_Origin\\\",%.4lf],UNIT[\\\"Meter\\\",1]]\",\n\t      datum, datum, spheroid, mp->re_major, flat, \n\t      mp->param.lamcc.false_easting, mp->param.lamcc.false_northing,\n\t      mp->param.lamcc.lon0, mp->param.lamcc.plat1,\n\t      mp->param.lamcc.plat2, mp->param.lamcc.lat0);\n      nc_put_att_text(ncid, var_id, \"spatial_ref\", strlen(spatial_ref), \n\t\t      spatial_ref);\n      sprintf(str, \"+proj=lcc +lat_1=%.4lf +lat_2=%.4lf +lat_0=%.4lf \"\n\t      \"+lon_0=%.4lf +x_0=%.3lf +y_0=%.3lf\", \n\t      mp->param.lamcc.plat1, mp->param.lamcc.plat2,\n\t      mp->param.lamcc.lat0, mp->param.lamcc.lon0,\n\t      mp->param.lamcc.false_easting, mp->param.lamcc.false_northing);\n      nc_put_att_text(ncid, var_id, \"proj4text\", strlen(str), str);\n      nc_put_att_double(ncid, var_id, \"semimajor_radius\", NC_DOUBLE, 1, \n\t\t\t&mp->re_major);\n      nc_put_att_double(ncid, var_id, \"semiminor_radius\", NC_DOUBLE, 1, \n\t\t\t&mp->re_minor);\n      sprintf(str, \"%.6lf %.6lf 0 %.6lf 0 %.6lf\", mp->startX, mp->perX, \n\t      mp->startY, mp->perY); \n      nc_put_att_text(ncid, var_id, \"GeoTransform\", strlen(str), str);\n    }\n    else if (mp->type == LAMBERT_AZIMUTHAL_EQUAL_AREA) {\n\n      strcpy(str, \"lambert_azimuthal_equal_area\");\n      nc_put_att_text(ncid, var_id, \"grid_mapping_name\", strlen(str), str);\n      nc_put_att_double(ncid, var_id, \"longitude_of_projection_origin\",\n\t\t\tNC_DOUBLE, 1, &mp->param.lamaz.center_lon);\n      nc_put_att_double(ncid, var_id, \"latitude_of_projection_origin\",\n\t\t\tNC_DOUBLE, 1, &mp->param.lamaz.center_lat);\n      nc_put_att_double(ncid, var_id, \"false_easting\", NC_DOUBLE, 1, \n\t\t\t&mp->param.lamaz.false_easting);\n      nc_put_att_double(ncid, var_id, \"false_northing\", NC_DOUBLE, 1, \n\t\t\t&mp->param.lamaz.false_northing);\n      strcpy(str, \"xgrid\");\n      nc_put_att_text(ncid, var_id, \"projection_x_coordinate\", strlen(str), \n\t\t      str);\n      strcpy(str, \"ygrid\");\n      nc_put_att_text(ncid, var_id, \"projection_y_coordinate\", strlen(str), \n\t\t      str);\n      strcpy(str, \"m\");\n      nc_put_att_text(ncid, var_id, \"units\", strlen(str), str); \n      nc_put_att_double(ncid, var_id, \"grid_boundary_top_projected_y\",\n\t\t\tNC_DOUBLE, 1, &mp->startY);\n      lfValue = mp->startY + mg->line_count * mp->perY;\n      nc_put_att_double(ncid, var_id, \"grid_boundary_bottom_projected_y\",\n\t\t\tNC_DOUBLE, 1, &lfValue);\n      lfValue = mp->startX + mg->sample_count * mp->perX;\n      nc_put_att_double(ncid, var_id, \"grid_boundary_right_projected_x\",\n\t\t\tNC_DOUBLE, 1, &lfValue);\n      nc_put_att_double(ncid, var_id, \"grid_boundary_left_projected_x\",\n\t\t\tNC_DOUBLE, 1, &mp->startX);\n      spatial_ref = (char *) MALLOC(sizeof(char)*1024);\n      datum = (char *) datum_toString(mp->datum);\n      spheroid = (char *) spheroid_toString(mp->spheroid);\n      double flat = mp->re_major/(mp->re_major - mp->re_minor);\n      sprintf(spatial_ref, \"PROJCS[\\\"Lambert_Azimuthal_Equal_Area\\\",GEOGCS[\\\"GCS_%s\\\",DATUM[\\\"D_%s\\\",SPHEROID[\\\"%s\\\",%.3lf,%-16.11g]],PRIMEM[\\\"Greenwich\\\",0],UNIT[\\\"Degree\\\",0.0174532925199432955]],PROJECTION[\\\"Lambert_Conformal_Conic\\\"],PARAMETER[\\\"False_Easting\\\",%.3lf],PARAMETER[\\\"False_Northing\\\",%.3lf],PARAMETER[\\\"Central_Meridian\\\",%.4lf],PARAMETER[\\\"Latitude_Of_Origin\\\",%.4lf],UNIT[\\\"Meter\\\",1]]\",\n\t      datum, datum, spheroid, mp->re_major, flat, \n\t      mp->param.lamaz.false_easting, mp->param.lamaz.false_northing,\n\t      mp->param.lamaz.center_lon, mp->param.lamaz.center_lat);\n      nc_put_att_text(ncid, var_id, \"spatial_ref\", strlen(spatial_ref), \n\t\t      spatial_ref);\n      sprintf(str, \"+proj=laea +lat_0=%.4lf +lon_0=%.4lf +x_0=%.3lf \"\n\t      \"+y_0=%.3lf\", \n\t      mp->param.lamaz.center_lat, mp->param.lamaz.center_lon,\n\t      mp->param.lamaz.false_easting, mp->param.lamaz.false_northing);\n      nc_put_att_text(ncid, var_id, \"proj4text\", strlen(str), str);\n      nc_put_att_double(ncid, var_id, \"semimajor_radius\", NC_DOUBLE, 1, \n\t\t\t&mp->re_major);\n      nc_put_att_double(ncid, var_id, \"semiminor_radius\", NC_DOUBLE, 1, \n\t\t\t&mp->re_minor);\n      sprintf(str, \"%.6lf %.6lf 0 %.6lf 0 %.6lf\", mp->startX, mp->perX, \n\t      mp->startY, mp->perY); \n      nc_put_att_text(ncid, var_id, \"GeoTransform\", strlen(str), str);\n    }\n  }\n  \n  // Define variables and data attributes\n  char **band_name = extract_band_names(meta->general->bands, band_count);\n  int dims_bands[3];\n  dims_bands[0] = dim_time_id;\n  if (projected) {\n    dims_bands[1] = dim_ygrid_id;\n    dims_bands[2] = dim_xgrid_id;\n  }\n  else {\n    dims_bands[1] = dim_lon_id;\n    dims_bands[2] = dim_lat_id;\n  }\n\n  for (ii=0; ii<band_count; ii++) {\n    \n    sprintf(str, \"%s_AMPLITUDE_IMAGE\", band_name[ii]);\n    nc_def_var(ncid, str, datatype, 3, dims_bands, &var_id);\n    netcdf->var_id[ii] = var_id;\n    nc_def_var_deflate(ncid, var_id, 0, 1, 6);    \n    lfValue = -999.0;\n    nc_put_att_double(ncid, var_id, \"FillValue\", NC_DOUBLE, 1, &lfValue);\n    sprintf(str, \"%s\", mg->sensor);\n    if (mg->image_data_type < 9)\n      strcat(str, \" radar backscatter\");\n    if (mg->radiometry >= r_SIGMA_DB && mg->radiometry <= r_GAMMA_DB)\n      strcat(str, \" in dB\");\n    nc_put_att_text(ncid, var_id, \"long_name\", strlen(str), str);\n    strcpy(str, \"area: backcatter value\");\n    nc_put_att_text(ncid, var_id, \"cell_methods\", strlen(str), str);\n    strcpy(str, \"1\");\n    nc_put_att_text(ncid, var_id, \"units\", strlen(str), str);\n    strcpy(str, \"unitless normalized radar cross-section\");\n    if (mg->radiometry >= r_SIGMA && mg->radiometry <= r_GAMMA)\n      strcat(str, \" stored as powerscale\");\n    else if (mg->radiometry >= r_SIGMA_DB && mg->radiometry <= r_GAMMA_DB)\n      strcat(str, \" stored as dB=10*log10(*)\");\n    nc_put_att_text(ncid, var_id, \"units_description\", strlen(str), str);\n    strcpy(str, \"longitude latitude\");\n    nc_put_att_text(ncid, var_id, \"coordinates\", strlen(str), str);\n    if (projected) {\n      strcpy(str, \"projection\");\n      nc_put_att_text(ncid, var_id, \"grid_mapping\", strlen(str), str);\n    } \n  }\n\n  // Define other attributes\n  ymd_date ymd;\n  hms_time hms;\n  parse_date(mg->acquisition_date, &ymd, &hms);\n\n  // Time\n  ii = band_count;\n  int dims_time[1] = { dim_time_id };\n  nc_def_var(ncid, \"time\", NC_FLOAT, 1, dims_time, &var_id);\n  netcdf->var_id[ii] = var_id;\n  strcpy(str, \"seconds since 1900-01-01T00:00:00Z\");\n  nc_put_att_text(ncid, var_id, \"units\", strlen(str), str);\n  strcpy(str, \"scene center time\");\n  nc_put_att_text(ncid, var_id, \"references\", strlen(str), str);\n  strcpy(str, \"time\");\n  nc_put_att_text(ncid, var_id, \"standard_name\", strlen(str), str);\n  strcpy(str, \"T\");\n  nc_put_att_text(ncid, var_id, \"axis\", strlen(str), str);\n  strcpy(str, \"serial date\");\n  nc_put_att_text(ncid, var_id, \"long_name\", strlen(str), str);\n\n  // Longitude\n  ii++;\n  if (projected) {\n    int dims_lon[2] = { dim_ygrid_id, dim_xgrid_id };\n    nc_def_var(ncid, \"longitude\", NC_FLOAT, 2, dims_lon, &var_id);\n  }\n  else {\n    int dims_lon[2] = { dim_lon_id, dim_lat_id };\n    nc_def_var(ncid, \"longitude\", NC_FLOAT, 2, dims_lon, &var_id);\n  }\n  netcdf->var_id[ii] = var_id;\n  nc_def_var_deflate(ncid, var_id, 0, 1, 6);    \n  strcpy(str, \"longitude\");\n  nc_put_att_text(ncid, var_id, \"standard_name\", strlen(str), str);\n  strcpy(str, \"longitude\");\n  nc_put_att_text(ncid, var_id, \"long_name\", strlen(str), str);\n  strcpy(str, \"degrees_east\");\n  nc_put_att_text(ncid, var_id, \"units\", strlen(str), str);\n  double *valid_range = (double *) MALLOC(sizeof(double)*2);\n  valid_range[0] = -180.0;\n  valid_range[1] = 180.0;\n  nc_put_att_double(ncid, var_id, \"valid_range\", NC_DOUBLE, 2, valid_range);\n  FREE(valid_range);\n  lfValue = -999.0;\n  nc_put_att_double(ncid, var_id, \"FillValue\", NC_DOUBLE, 1, &lfValue);\n\n  // Latitude\n  ii++;\n  if (projected) {\n    int dims_lat[2] = { dim_ygrid_id, dim_xgrid_id };\n    nc_def_var(ncid, \"latitude\", NC_FLOAT, 2, dims_lat, &var_id);\n  }\n  else {\n    int dims_lat[2] = { dim_lat_id, dim_lon_id };\n    nc_def_var(ncid, \"latitude\", NC_FLOAT, 2, dims_lat, &var_id);\n  }\n  netcdf->var_id[ii] = var_id;\n  nc_def_var_deflate(ncid, var_id, 0, 1, 6);    \n  strcpy(str, \"latitude\");\n  nc_put_att_text(ncid, var_id, \"standard_name\", strlen(str), str);\n  strcpy(str, \"latitude\");\n  nc_put_att_text(ncid, var_id, \"long_name\", strlen(str), str);\n  strcpy(str, \"degrees_north\");\n  nc_put_att_text(ncid, var_id, \"units\", strlen(str), str);\n  valid_range = (double *) MALLOC(sizeof(double)*2);\n  valid_range[0] = -90.0;\n  valid_range[1] = 90.0;\n  nc_put_att_double(ncid, var_id, \"valid_range\", NC_DOUBLE, 2, valid_range);\n  FREE(valid_range);\n  lfValue = -999.0;\n  nc_put_att_double(ncid, var_id, \"FillValue\", NC_DOUBLE, 1, &lfValue);\n\n  if (projected) {\n\n    // ygrid\n    ii++;\n    int dims_ygrid[1] = { dim_ygrid_id };\n    nc_def_var(ncid, \"ygrid\", NC_FLOAT, 1, dims_ygrid, &var_id);\n    netcdf->var_id[ii] = var_id;\n    nc_def_var_deflate(ncid, var_id, 0, 1, 6);    \n    strcpy(str, \"projection_y_coordinates\");\n    nc_put_att_text(ncid, var_id, \"standard_name\", strlen(str), str);\n    strcpy(str, \"projection_grid_y_centers\");\n    nc_put_att_text(ncid, var_id, \"long_name\", strlen(str), str);\n    strcpy(str, \"meters\");\n    nc_put_att_text(ncid, var_id, \"units\", strlen(str), str);\n    strcpy(str, \"Y\");\n    nc_put_att_text(ncid, var_id, \"axis\", strlen(str), str);\n\n    // xgrid\n    ii++;\n    int dims_xgrid[1] = { dim_xgrid_id };\n    nc_def_var(ncid, \"xgrid\", NC_FLOAT, 1, dims_xgrid, &var_id);\n    netcdf->var_id[ii] = var_id;\n    nc_def_var_deflate(ncid, var_id, 0, 1, 6);    \n    strcpy(str, \"projection_x_coordinates\");\n    nc_put_att_text(ncid, var_id, \"standard_name\", strlen(str), str);\n    strcpy(str, \"projection_grid_x_centers\");\n    nc_put_att_text(ncid, var_id, \"long_name\", strlen(str), str);\n    strcpy(str, \"meters\");\n    nc_put_att_text(ncid, var_id, \"units\", strlen(str), str);\n    strcpy(str, \"X\");\n    nc_put_att_text(ncid, var_id, \"axis\", strlen(str), str);\n  }\n  \n  // Define global attributes\n  strcpy(str, \"CF-1.4\");\n  nc_put_att_text(ncid, NC_GLOBAL, \"Conventions\", strlen(str), str);\n  strcpy(str, \"Alaska Satellite Facility\");\n  nc_put_att_text(ncid, NC_GLOBAL, \"institution\", strlen(str), str);\n  sprintf(str, \"%s %s %s image\", mg->sensor, mg->sensor_name, mg->mode);\n  nc_put_att_text(ncid, NC_GLOBAL, \"title\", strlen(str), str);\n  if (mg->image_data_type == AMPLITUDE_IMAGE)\n    strcpy(str, \"SAR backcatter image\");\n  nc_put_att_text(ncid, NC_GLOBAL, \"source\", strlen(str), str);\n  sprintf(str, \"%s\", mg->basename);\n  nc_put_att_text(ncid, NC_GLOBAL, \"original_file\", strlen(str), str);\n  if (strcmp_case(mg->sensor, \"RSAT-1\") == 0)\n    sprintf(str, \"Copyright Canadian Space Agency, %d\", ymd.year);\n  else if (strncmp_case(mg->sensor, \"ERS\", 3) == 0)\n    sprintf(str, \"Copyright European Space Agency, %d\", ymd.year);\n  else if (strcmp_case(mg->sensor, \"JERS-1\") == 0 ||\n\t   strcmp_case(mg->sensor, \"ALOS\") == 0)\n    sprintf(str, \"Copyright Japan Aerospace Exploration Agency , %d\", \n\t    ymd.year);\n  nc_put_att_text(ncid, NC_GLOBAL, \"comment\", strlen(str), str);\n  strcpy(str, \"Documentation available at: www.asf.alaska.edu\");\n  nc_put_att_text(ncid, NC_GLOBAL, \"references\", strlen(str), str);\n  time_t t;\n  struct tm *timeinfo;\n  time(&t);\n  timeinfo = gmtime(&t);\n  sprintf(str, \"%s\", asctime(timeinfo));\n  chomp(str);\n  strcat(str, \", UTC: netCDF File created.\");\n  nc_put_att_text(ncid, NC_GLOBAL, \"history\", strlen(str), str);\n\n  // Metadata  \n  int meta_id;\n  nc_def_grp(ncid, \"metadata\", &meta_id);\n\n  // Metadata - general block\n  nc_meta_str(meta_id, \"general_name\", \"file name\", NULL, mg->basename);\n  nc_meta_str(meta_id, \"general_sensor\", \"imaging satellite\", NULL, mg->sensor);\n  nc_meta_str(meta_id, \"general_sensor_name\", \"imaging sensor\", NULL, \n\t      mg->sensor_name);\n  nc_meta_str(meta_id, \"general_mode\", \"imaging mode\", NULL, mg->mode);\n  nc_meta_str(meta_id, \"general_processor\", \"name and version of processor\", \n\t      NULL, mg->processor);\n  nc_meta_str(meta_id, \"general_data_type\", \"type of samples (e.g. REAL64)\", \n\t      NULL, data_type2str(mg->data_type));\n  nc_meta_str(meta_id, \"general_image_data_type\", \n\t      \"image data type (e.g. AMPLITUDE_IMAGE)\", NULL, \n\t      image_data_type2str(mg->image_data_type));\n  nc_meta_str(meta_id, \"general_radiometry\", \"radiometry (e.g. SIGMA)\", NULL, \n\t      radiometry2str(mg->radiometry));\n  nc_meta_str(meta_id, \"general_acquisition_date\", \n\t      \"acquisition date of the image\", NULL, mg->acquisition_date);\n  nc_meta_int(meta_id, \"general_orbit\", \"orbit number of image\", NULL, \n\t      &mg->orbit);\n  if (mg->orbit_direction == 'A')\n    strcpy(str, \"Ascending\");\n  else\n    strcpy(str, \"Descending\");\n  nc_meta_str(meta_id, \"general_orbit_direction\", \"orbit direction\", NULL, str);\n  nc_meta_int(meta_id, \"general_frame\", \"frame number of image\", NULL, \n\t      &mg->frame);\n  nc_meta_int(meta_id, \"general_band_count\", \"number of bands in image\", NULL, \n\t      &mg->band_count);\n  nc_meta_str(meta_id, \"general_bands\", \"bands of the sensor\", NULL, \n\t      &mg->bands);\n  nc_meta_int(meta_id, \"general_line_count\", \"number of lines in image\", NULL, \n\t      &mg->line_count);\n  nc_meta_int(meta_id, \"general_sample_count\", \"number of samples in image\", \n\t      NULL, &mg->sample_count);\n  nc_meta_int(meta_id, \"general_start_line\", \n\t      \"first line relative to original image\", NULL, &mg->start_line);\n  nc_meta_int(meta_id, \"general_start_sample\", \n\t      \"first sample relative to original image\", NULL, \n\t      &mg->start_sample);\n  nc_meta_double(meta_id, \"general_x_pixel_size\", \"range pixel size\", \"m\", \n\t\t &mg->x_pixel_size);\n  nc_meta_double(meta_id, \"general_y_pixel_size\", \"azimuth pixel size\", \"m\", \n\t\t &mg->y_pixel_size);\n  nc_meta_double(meta_id, \"general_center_latitude\", \n\t\t \"approximate image center latitude\", \"degrees_north\", \n\t\t &mg->center_latitude);\n  nc_meta_double(meta_id, \"general_center_longitude\",\n\t\t \"approximate image center longitude\", \"degrees_east\", \n\t\t &mg->center_longitude);\n  nc_meta_double(meta_id,  \"general_re_major\", \"major (equator) axis of earth\",\n\t\t \"m\", &mg->re_major);\n  nc_meta_double(meta_id, \"general_re_minor\", \"minor (polar) axis of earth\", \n\t\t \"m\", &mg->re_minor);\n  nc_meta_double(meta_id, \"general_bit_error_rate\", \n\t\t \"fraction of bits which are in error\", NULL, \n\t\t &mg->bit_error_rate);\n  nc_meta_int(meta_id, \"general_missing_lines\", \n\t      \"number of missing lines in data take\", NULL, &mg->missing_lines);\n  nc_meta_float(meta_id, \"general_no_data\", \n\t\t\"value indicating no data for a pixel\",\tNULL, &mg->no_data);\n\n  if (ms) {\n    // Metadata - SAR block\n    if (ms->image_type == 'S')\n      sprintf(str, \"slant range\");\n    else if (ms->image_type == 'G')\n      sprintf(str, \"ground range\");\n    else if (ms->image_type == 'P')\n      sprintf(str, \"projected\");\n    else if (ms->image_type == 'R')\n      sprintf(str, \"georeferenced\");    \n    nc_meta_str(meta_id, \"sar_image_type\", \"image type\", NULL, str);\n    if (ms->look_direction == 'R')\n      sprintf(str, \"right\");\n    else if (ms->look_direction == 'L')\n      sprintf(str, \"left\");\n    nc_meta_str(meta_id, \"sar_look_direction\", \"SAR satellite look direction\", \n\t\tNULL, str);\n    nc_meta_int(meta_id, \"sar_look_count\", \"number of looks to take from SLC\", \n\t\tNULL, &ms->look_count);\n    nc_meta_int(meta_id, \"sar_multilook\", \"multilooking flag\", NULL, \n\t\t&ms->multilook);\n    nc_meta_int(meta_id, \"sar_deskewed\", \"zero doppler deskew flag\", NULL, \n\t\t&ms->deskewed);\n    nc_meta_int(meta_id, \"sar_original_line_count\", \n\t\t\"number of lines in original image\", NULL, \n\t\t&ms->original_line_count);\n    nc_meta_int(meta_id, \"sar_original_sample_count\", \n\t\t\"number of samples in original image\", NULL, \n\t\t&ms->original_sample_count);\n    nc_meta_double(meta_id, \"sar_line_increment\", \n\t\t   \"line increment for sampling\", NULL, &ms->line_increment);\n    nc_meta_double(meta_id, \"sar_sample_increment\", \n\t\t   \"sample increment for sampling\", NULL, \n\t\t   &ms->sample_increment);\n    nc_meta_double(meta_id, \"sar_range_time_per_pixel\", \n\t\t   \"time per pixel in range\", \"s\", \n\t\t   &ms->range_time_per_pixel);\n    nc_meta_double(meta_id, \"sar_azimuth_time_per_pixel\", \n\t\t   \"time per pixel in azimuth\", \"s\", \n\t\t   &ms->azimuth_time_per_pixel);\n    nc_meta_double(meta_id, \"sar_slant_range_first_pixel\", \n\t\t   \"slant range to first pixel\", \"m\", \n\t\t   &ms->slant_range_first_pixel);\n    nc_meta_double(meta_id, \"sar_slant_shift\", \n\t\t   \"error correction factor in slant range\", \"m\", \n\t\t   &ms->slant_shift);\n    nc_meta_double(meta_id, \"sar_time_shift\", \"error correction factor in time\",\n\t\t   \"s\", &ms->time_shift);\n    nc_meta_double(meta_id, \"sar_wavelength\", \"SAR carrier wavelength\", \"m\", \n\t\t   &ms->wavelength);\n    nc_meta_double(meta_id, \"sar_pulse_repetition_frequency\", \n\t\t   \"pulse repetition frequency\", \"Hz\", &ms->prf);\n    nc_meta_double(meta_id, \"sar_earth_radius\", \"earth radius at scene center\", \n\t\t   \"m\", &ms->earth_radius);\n    nc_meta_double(meta_id, \"sar_satellite_height\", \n\t\t   \"satellite height from earth's center\", \"m\", \n\t\t   &ms->satellite_height);\n    nc_meta_double(meta_id, \"sar_range_doppler_centroid\", \n\t\t   \"range doppler centroid\", \"Hz\", \n\t\t   &ms->range_doppler_coefficients[0]);\n    nc_meta_double(meta_id, \"sar_range_doppler_linear\", \n\t\t   \"range doppler per range pixel\", \"Hz/pixel\", \n\t\t   &ms->range_doppler_coefficients[1]);\n    nc_meta_double(meta_id, \"sar_range_doppler_quadratic\", \n\t\t   \"range doppler per range pixel square\", \"Hz/pixel^2\", \n\t\t   &ms->range_doppler_coefficients[2]);\n    nc_meta_double(meta_id, \"sar_azimuth_doppler_centroid\", \n\t\t   \"azimuth doppler centroid\", \"Hz\", \n\t\t   &ms->azimuth_doppler_coefficients[0]);\n    nc_meta_double(meta_id, \"sar_azimuth_doppler_linear\", \n\t\t   \"azimuth doppler per azimuth pixel\", \"Hz/pixel\", \n\t\t   &ms->azimuth_doppler_coefficients[1]);\n    nc_meta_double(meta_id, \"sar_azimuth_doppler_quadratic\", \n\t\t   \"azimuth doppler per azimuth per azimuth pixel square\", \n\t\t   \"Hz/pixel^2\", &ms->azimuth_doppler_coefficients[2]);\n  }\n\n  char tmp[50];\n  if (mo) {\n    // Metadata - state vector block\n    nc_meta_int(meta_id, \"orbit_year\", \"year of image start\", NULL, &mo->year);\n    nc_meta_int(meta_id, \"orbit_day_of_year\", \"day of the year at image start\",\n\t\tNULL, &mo->julDay);\n    nc_meta_double(meta_id, \"orbit_second_of_day\", \n\t\t   \"second of the day at image start\", \"seconds\", &mo->second);\n    int vector_count = mo->vector_count;\n    nc_meta_int(meta_id, \"orbit_vector_count\", \"number of state vectors\", NULL,\n\t\t&vector_count);\n    for (ii=0; ii<vector_count; ii++) {\n      sprintf(tmp, \"orbit_vector[%d]_time\", ii+1);\n      nc_meta_double(meta_id, tmp, \"time relative to image start\", \"s\",\n\t\t     &mo->vecs[ii].time);\n      sprintf(tmp, \"orbit_vector[%d]_position_x\", ii+1);\n      nc_meta_double(meta_id, tmp, \"x coordinate, earth-fixed\", \"m\",\n\t\t     &mo->vecs[ii].vec.pos.x);\n      sprintf(tmp, \"orbit_vector[%d]_position_y\", ii+1);\n      nc_meta_double(meta_id, tmp, \"y coordinate, earth-fixed\", \"m\",\n\t\t     &mo->vecs[ii].vec.pos.y);\n      sprintf(tmp, \"orbit_vector[%d]_position_z\", ii+1);\n      nc_meta_double(meta_id, tmp, \"z coordinate, earth-fixed\", \"m\",\n\t\t     &mo->vecs[ii].vec.pos.z);\n      sprintf(tmp, \"orbit_vector[%d]_velocity_x\", ii+1);\n      nc_meta_double(meta_id, tmp, \"x velocity, earth-fixed\", \"m/s\",\n\t\t     &mo->vecs[ii].vec.vel.x);\n      sprintf(tmp, \"orbit_vector[%d]_velocity_y\", ii+1);\n      nc_meta_double(meta_id, tmp, \"y velocity, earth-fixed\", \"m/s\",\n\t\t     &mo->vecs[ii].vec.vel.y);\n      sprintf(tmp, \"orbit_vector[%d]_velocity_z\", ii+1);\n      nc_meta_double(meta_id, tmp, \"z velocity, earth-fixed\", \"m/s\",\n\t\t     &mo->vecs[ii].vec.vel.z);\n    }    \n  }\n\n  // Finish off definition block\n  nc_enddef(ncid); \n    \n  // Write ASF metadata to XML file\n  char *output_file_name = \n    (char *) MALLOC(sizeof(char)*(strlen(output_file)+5));\n  sprintf(output_file_name, \"%s.xml\", output_file);\n  meta_write_xml(meta, output_file_name);\n  FREE(output_file_name);\n\n  // Clean up\n  FREE(str);\n  if (spatial_ref)\n    FREE(spatial_ref);\n  \n  return netcdf;\n}\n\nvoid finalize_netcdf_file(netcdf_t *netcdf, meta_parameters *md)\n{\n  int ncid = netcdf->ncid;\n  int n = md->general->band_count;\n  int nl = md->general->line_count;\n  int ns = md->general->sample_count;\n  long pixel_count = md->general->line_count * md->general->sample_count;\n  int projected = FALSE;\n  if (md->projection && md->projection->type != SCANSAR_PROJECTION)\n    projected = TRUE;\n\n  // Extra bands - Time\n  float time = (float) seconds_from_str(md->general->acquisition_date);\n  asfPrintStatus(\"Storing band 'time' ...\\n\");\n  nc_put_var_float(ncid, netcdf->var_id[n], &time);\n\n  // Extra bands - longitude\n  n++;\n  int ii, kk;\n  double *value = (double *) MALLOC(sizeof(double)*MAX_PTS);\n  double *l = (double *) MALLOC(sizeof(double)*MAX_PTS);\n  double *s = (double *) MALLOC(sizeof(double)*MAX_PTS);\n  double line, sample, lat, lon, first_value;\n  float *lons = (float *) MALLOC(sizeof(float)*pixel_count);\n  asfPrintStatus(\"Generating band 'longitude' ...\\n\");\n  meta_get_latLon(md, 0, 0, 0.0, &lat, &lon);\n  if (lon < 0.0)\n    first_value = lon + 360.0;\n  else\n    first_value = lon;\n  asfPrintStatus(\"Calculating grid for quadratic fit ...\\n\");\n  for (ii=0; ii<RES; ii++) {\n    for (kk=0; kk<RES; kk++) {\n      line = ii * nl / RES;\n      sample = kk * ns / RES;\n      meta_get_latLon(md, line, sample, 0.0, &lat, &lon);\n      l[ii*RES+kk] = line;\n      s[ii*RES+kk] = sample;\n      if (lon < 0.0)\n\tvalue[ii*RES+kk] = lon + 360.0;\n      else\n\tvalue[ii*RES+kk] = lon;\n    }\n    asfLineMeter(ii, nl);\n  }\n  quadratic_2d q = find_quadratic(value, l, s, MAX_PTS);\n  q.A = first_value;\n  for (ii=0; ii<nl; ii++) {\n    for (kk=0; kk<ns; kk++) {\n      lons[ii*ns+kk] = (float)\n\t(q.A + q.B*ii + q.C*kk + q.D*ii*ii + q.E*ii*kk + q.F*kk*kk +\n\t q.G*ii*ii*kk + q.H*ii*kk*kk + q.I*ii*ii*kk*kk + q.J*ii*ii*ii +\n\t q.K*kk*kk*kk) - 360.0;\n      if (lons[ii*ns+kk] < -180.0)\n\tlons[ii*ns+kk] += 360.0;\n    }\n    asfLineMeter(ii, nl);\n  }\n  asfPrintStatus(\"Storing band 'longitude' ...\\n\");\n  nc_put_var_float(ncid, netcdf->var_id[n], &lons[0]);\n  FREE(lons);\n\n  // Extra bands - Latitude\n  n++;\n  float *lats = (float *) MALLOC(sizeof(float)*pixel_count);\n  asfPrintStatus(\"Generating band 'latitude' ...\\n\");\n  meta_get_latLon(md, 0, 0, 0.0, &lat, &lon);\n  first_value = lat + 180.0;\n  asfPrintStatus(\"Calculating grid for quadratic fit ...\\n\");\n  for (ii=0; ii<RES; ii++) {\n    for (kk=0; kk<RES; kk++) {\n      line = ii * nl / RES;\n      sample = kk * ns / RES;\n      meta_get_latLon(md, line, sample, 0.0, &lat, &lon);\n      l[ii*RES+kk] = line;\n      s[ii*RES+kk] = sample;\n      value[ii*RES+kk] = lat + 180.0;\n    }\n    asfLineMeter(ii, nl);\n  }\n  q = find_quadratic(value, l, s, MAX_PTS);\n  q.A = first_value;\n  for (ii=0; ii<nl; ii++) {\n    for (kk=0; kk<ns; kk++) {\n      if (md->general->orbit_direction == 'A')\n\tlats[(nl-ii-1)*ns+kk] = (float)\n\t  (q.A + q.B*ii + q.C*kk + q.D*ii*ii + q.E*ii*kk + q.F*kk*kk +\n\t   q.G*ii*ii*kk + q.H*ii*kk*kk + q.I*ii*ii*kk*kk + q.J*ii*ii*ii +\n\t   q.K*kk*kk*kk) - 180.0;\n      else\n\tlats[ii*ns+kk] = (float)\n\t  (q.A + q.B*ii + q.C*kk + q.D*ii*ii + q.E*ii*kk + q.F*kk*kk +\n\t   q.G*ii*ii*kk + q.H*ii*kk*kk + q.I*ii*ii*kk*kk + q.J*ii*ii*ii +\n\t   q.K*kk*kk*kk) - 180.0;\n    }\n    asfLineMeter(ii, nl);\n  }\n  asfPrintStatus(\"Storing band 'latitude' ...\\n\");\n  nc_put_var_float(ncid, netcdf->var_id[n], &lats[0]);\n  FREE(lats);\n\n  if (projected) {\n    // Extra bands - ygrid\n    n++;\n    float *ygrids = (float *) MALLOC(sizeof(float)*pixel_count);\n    for (ii=0; ii<nl; ii++) {\n      for (kk=0; kk<ns; kk++)\n\tygrids[ii*ns+kk] = \n\t  md->projection->startY + kk*md->projection->perY;\n      asfLineMeter(ii, nl);\n    }\n    asfPrintStatus(\"Storing band 'ygrid' ...\\n\");\n    nc_put_var_float(ncid, netcdf->var_id[n], &ygrids[0]);\n    FREE(ygrids);\n    \n    // Extra bands - xgrid\n    n++;\n    float *xgrids = (float *) MALLOC(sizeof(float)*pixel_count);\n    for (ii=0; ii<nl; ii++) {\n      for (kk=0; kk<ns; kk++) \n\txgrids[ii*ns+kk] = \n\t  md->projection->startX + kk*md->projection->perX;\n      asfLineMeter(ii, nl);\n    }\n    asfPrintStatus(\"Storing band 'xgrid' ...\\n\");\n    nc_put_var_float(ncid, netcdf->var_id[n], &xgrids[0]);\n    FREE(xgrids);\n  }\n\n  // Close file and clean up\n  int status = nc_close(ncid);\n  if (status != NC_NOERR)\n    asfPrintError(\"Could not close netCDF file (%s).\\n\", nc_strerror(status));\n  FREE(netcdf->var_id);\n  FREE(netcdf);\n}\n", "meta": {"hexsha": "f0927900e9cc060be2827853717828c79f438c3e", "size": 42015, "ext": "c", "lang": "C", "max_stars_repo_path": "src/libasf_export/export_netcdf.c", "max_stars_repo_name": "glshort/MapReady", "max_stars_repo_head_hexsha": "c9065400a64c87be46418ab32e3a251ca2f55fd5", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2017-12-31T05:33:28.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-28T01:51:22.000Z", "max_issues_repo_path": "src/libasf_export/export_netcdf.c", "max_issues_repo_name": "glshort/MapReady", "max_issues_repo_head_hexsha": "c9065400a64c87be46418ab32e3a251ca2f55fd5", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/libasf_export/export_netcdf.c", "max_forks_repo_name": "glshort/MapReady", "max_forks_repo_head_hexsha": "c9065400a64c87be46418ab32e3a251ca2f55fd5", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 7.0, "max_forks_repo_forks_event_min_datetime": "2017-04-26T18:18:33.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-15T08:01:09.000Z", "avg_line_length": 43.225308642, "max_line_length": 509, "alphanum_fraction": 0.6636677377, "num_tokens": 13406, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.2909808785120009, "lm_q2_score": 0.030214586849079555, "lm_q1q2_score": 0.008791867025222317}}
{"text": "/*\n  Copyright (c) 2016-2017 Hong Xu\n\n  This file is part of WCSPLift.\n\n  WCSPLift is free software: you can redistribute it and/or modify\n  it under the terms of the GNU General Public License as published by\n  the Free Software Foundation, either version 3 of the License, or\n  (at your option) any later version.\n\n  WCSPLift is distributed in the hope that it will be useful,\n  but WITHOUT ANY WARRANTY; without even the implied warranty of\n  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n  GNU General Public License for more details.\n\n  You should have received a copy of the GNU General Public License\n  along with WCSPLift.  If not, see <http://www.gnu.org/licenses/>.\n*/\n\n/** \\file WCSPInstance.h\n *\n * Define the definition of WCSP instances and the constraints in it. Algorithms that can be applied\n * directly on WCSP instances, i.e., the min-sum message passing algorithm \\cite xkk17 and integer\n * linear programming \\cite xkk17a, are also included in this file.\n */\n\n#ifndef WCSPINSTANCE_H_\n#define WCSPINSTANCE_H_\n\n#include <array>\n#include <cstdint>\n#include <istream>\n#include <map>\n#include <numeric>\n#include <set>\n#include <stdexcept>\n#include <utility>\n#include <vector>\n\n#include <boost/dynamic_bitset.hpp>\n#include <boost/property_tree/json_parser.hpp>\n#include <boost/property_tree/ptree.hpp>\n#include <cblas.h>\n\n#include \"global.h\"\n#include \"RunningTime.h\"\n#include \"LinearProgramSolver.h\"\n\n/** \\brief Weighted constraint.\n *\n * This class describes a weighted constraint. It consists of the IDs of the variables as well as\n * how the weight corresponding to each assignment.\n *\n * \\tparam VarIdType The type of variable IDs. It must be an integer type and defaults to \\p\n * intmax_t.\n *\n * \\tparam WeightType The type of weights. It must be a numeric type and defaults to \\p double.\n *\n * \\tparam ValueType The type of values of all variables in the constraint. It should usually be a\n * bitset type and defaults to \\p boost::dynamic_bitset<>.\n */\ntemplate < class VarIdType = intmax_t,\n           class WeightType = double,\n           class ValueType = boost::dynamic_bitset<>,  // The type of the values to represent each constraint\n           class NonBooleanValueType = size_t>\nclass Constraint\n{\npublic:\n    /** Alias of \\p VarIDType. */\n    typedef VarIdType variable_id_t;\n\n    /** Alias of \\p ValueType. */\n    typedef ValueType value_t;\n\n    /** Alias of \\p WeightType. */\n    typedef WeightType weight_t;\n\n    /** Alias of \\p NonBooleanValueType. */\n    typedef NonBooleanValueType non_boolean_value_t;\n\nprivate:\n    // This class is only used for Polynomial key comparison. This function ensures keys with\n    // a smaller number of variables must precede larger number of variables.\n    class PolynomialKeyComparison\n    {\n    public:\n        bool operator () (const std::set<variable_id_t>& a, const std::set<variable_id_t>& b) const\n        {\n            if (a.size() > b.size())\n                return true;\n\n            if (a.size() < b.size())\n                return false;\n\n            return a < b;\n        }\n    };\npublic:\n    /** The polynomial form of constraints consisting of the coefficient of each term (each term is\n     * represented by an assignment of values to variables). */\n    typedef std::map<std::set<variable_id_t>, weight_t, PolynomialKeyComparison> Polynomial;\n\nprivate:\n    std::vector<variable_id_t> nonBooleanVariables;\n    std::vector<variable_id_t> variables;\n    std::map<value_t, weight_t> weights;\n    std::map<std::vector<non_boolean_value_t>, weight_t> nonBooleanWeights;\n\npublic:\n    /** Alias of \\p Constraint<VarIdType, WeightType, ValueType, NonBooleanValueType>, i.e., the\n     * class type itself. */\n    typedef Constraint<VarIdType, WeightType, ValueType, NonBooleanValueType> self_t;\n\n    /** \\brief Get the list of the IDs of non-Boolean variables in the constraint.\n     *\n     * \\return A list of variable IDs.\n     */\n    inline const std::vector<variable_id_t>& getNonBooleanVariables() const noexcept\n    {\n        return nonBooleanVariables;\n    }\n\n    /** \\brief Get the list of the IDs of variables in the constraint.\n     *\n     * \\return A list of variable IDs.\n     */\n    inline const std::vector<variable_id_t>& getVariables() const noexcept\n    {\n        return variables;\n    }\n\n    /** \\brief Get the ID of the <tt>i</tt>'th variable.\n     *\n     * \\param[in] i The index of the variable of which to get the ID.\n     *\n     * \\return The ID of the <tt>i</tt>'th variable.\n     */\n    inline variable_id_t getVariable(size_t i) const noexcept\n    {\n        return variables.at(i);\n    }\n\n    /** \\brief Set the IDs of the variables in the constraint from a \\p std::vector<variable_id_t>\n     * object.\n     *\n     * \\param[in] variables: A list of variable IDs to set.\n     */\n    inline void setVariables(const std::vector<variable_id_t>& variables) noexcept\n    {\n        this->variables = variables;\n        this->weights.clear();\n    }\n\n    /** \\brief Set the IDs of the non-Boolean variables in the constraint from a \\p\n     * std::vector<variable_id_t> object.\n     *\n     * \\param[in] variables: A list of variable IDs to set.\n     */\n    inline void setNonBooleanVariables(const std::vector<variable_id_t>& variables) noexcept\n    {\n        this->nonBooleanVariables = variables;\n        this->weights.clear();\n    }\n\n    /** \\brief Set the IDs of the variables in the constraint from a range of iterators.\n     *\n     * \\param[in] b the beginning iterator.\n     *\n     * \\param[in] e the ending iterator.\n     */\n    template<class Iter>\n    inline void setVariables(Iter b, Iter e) noexcept\n    {\n        variables.clear();\n        std::copy(b, e, std::back_inserter(variables));\n    }\n\n    /** \\brief Set the weight of a given assignment of values to variables specified by \\p v to \\p\n     * w.\n     *\n     * \\param[in] v An assignment of values to variables.\n     *\n     * \\param[in] w A weight.\n     *\n     * \\return A reference to the class object itself.\n     */\n    inline self_t& setWeight(const value_t& v, weight_t w)\n    {\n        weights[v] = w;\n        return *this;\n    }\n\n    /** \\brief Set the weight of a given assignment of values to non-Boolean variables specified by\n     * \\p v to \\p w.\n     *\n     * \\param[in] v An assignment of values to variables.\n     *\n     * \\param[in] w A weight.\n     *\n     * \\return A reference to the class object itself.\n     */\n    inline self_t& setWeight(const std::vector<non_boolean_value_t>& v, weight_t w)\n    {\n        nonBooleanWeights[v] = w;\n        return *this;\n    }\n\n    /** \\brief Get the weight of a given assignment of values to variables specified by \\p v.\n     *\n     * \\param[in] v The assignment of values to variables.\n     *\n     * \\return The weight of a given assignment of values to variables specified by \\p v.\n     */\n    inline weight_t getWeight(const value_t& v) const noexcept\n    {\n        auto it = weights.find(v);\n        if (it == weights.end()) // not found, return 0\n            return weight_t();\n\n        return it->second;\n    }\n\n    /** \\brief Get the weight of a given assignment of values to non-Boolean variables specified by\n     * \\p v.\n     *\n     * \\param[in] v The assignment of values to variables.\n     *\n     * \\return The weight of a given assignment of values to variables specified by \\p v.\n     */\n    inline weight_t getWeight(const std::vector<non_boolean_value_t>& v) const noexcept\n    {\n        auto it = nonBooleanWeights.find(v);\n        if (it == nonBooleanWeights.end()) // not found, return 0\n            return weight_t();\n\n        return it->second;\n    }\n\n    /** \\brief Get a map object that maps assignments of values to variables to weights.\n     *\n     * \\return A map object that maps assignments of values to variables to weights.\n     */\n    inline const std::map<value_t, weight_t> getWeights() const noexcept\n    {\n        return weights;\n    }\n\n    /** \\brief Represent the constraint using a \\p boost::property_tree::ptree object.\n     *\n     * \\param[out] t A \\p boost::property_tree::ptree object that represents the constraint.\n     */\n    void toPropertyTree(boost::property_tree::ptree& t) const\n    {\n        using namespace boost::property_tree;\n\n        t.clear();\n\n        // put the variables\n        ptree vs;\n        for (auto& v : variables)\n            vs.push_back(\n                std::make_pair(\"\", ptree(std::to_string(v))));\n\n        t.put_child(\"variables\", vs);\n\n        // put the weights\n        ptree ws;\n        for (auto& w : weights)\n        {\n            ptree we;\n\n            for (size_t i = 0; i < getVariables().size(); ++ i)\n            {\n                if (w.first[i])\n                    we.push_back(std::make_pair(\"\", ptree(\"1\")));\n                else\n                    we.push_back(std::make_pair(\"\", ptree(\"0\")));\n            }\n\n            we.push_back(std::make_pair(\"\", ptree(std::to_string(w.second))));\n\n            ws.push_back(std::make_pair(\"\", we));\n        }\n\n        t.put_child(\"weights\", ws);\n    }\n\n    /** \\brief Compute the coefficients of the polynomial converted from a constraint according to\n     * \\cite k08.\n     *\n     * \\param[out] p A Constraint::Polynomial object corresponding to the polynomial representation\n     * of the constraint.\n     */\n    void toPolynomial(Polynomial& p) const noexcept\n    {\n        size_t s = getVariables().size();\n\n        // we basically solve A * x = b\n\n        size_t max_int = ((size_t) 1) << s;\n\n        // matrix a\n        double * a = new double[max_int * max_int];\n        memset(a, 0, max_int * max_int * sizeof(double));\n\n/// \\cond\n#define ENTRY(a, x, y) a[(y) * max_int + (x)]\n/// \\endcond\n        // set the first column to 1\n        for (size_t i = 0; i < max_int; ++ i)\n            ENTRY(a, i, 0) = 1.0;\n        // Set the lower triangle. The row number corresponds to the assignments of variables, and\n        // the col number corresponds to terms of the polynomial in the following order:\n        // X_1, X_2, X_1 X_2, X_3, X_1 X_3, X_2 X_3, X_1 X_2 X_3...\n        for (size_t i = 1; i < max_int; ++ i)\n            for (size_t j = 1; j <= i; ++ j)\n                // (i|j)==i : the 1-bits integer i includes all the 1-bits of j\n                ENTRY(a, i, j) = ((i | j) == i) ? 1.0 : 0.0;\n#undef ENTRY\n\n        // assign the vector b\n        double * x = new double[max_int];\n        for (size_t i = 0; i < max_int; ++ i)\n            x[i] = getWeight(value_t(s, i));\n\n        cblas_dtrsv(CblasColMajor, CblasLower, CblasNoTrans, CblasUnit, max_int, a, max_int, x, 1);\n        delete[] a;\n\n        // Insert all the coefficients into the polynomial.\n        for (size_t i = 0; i < max_int; ++ i)\n        {\n            typename Polynomial::key_type k;\n\n            for (size_t j = 0; j < s; ++ j)\n                if ((((size_t) 1u) << j) & i)\n                    k.insert(getVariable(j));\n\n            p[k] += x[i];\n        }\n\n        delete[] x;\n    }\n};\n\n/** \\brief A WCSP instance.\n *\n * This class describes a WCSP instance. It consists a set of constraints.\n *\n * \\tparam VarIdType The type of variable IDs. It must be an integer type and defaults to \\p\n * intmax_t.\n *\n * \\tparam WeightType The type of weights. It must be a numeric type and defaults to \\p double.\n *\n * \\tparam ConstraintValueType The type of values of all variables in the constraints in the WCSP\n * instance. It should usually be a bitset type and defaults to \\p boost::dynamic_bitset<>.\n */\ntemplate <class VarIdType = intmax_t, class WeightType = double,\n          class ConstraintValueType = boost::dynamic_bitset<>,\n          class NonBooleanValueType = size_t>\nclass WCSPInstance\n{\npublic:\n    /** Alias of \\p VarIdType. */\n    typedef VarIdType variable_id_t;\n    /** Alias of \\p WeightType. */\n    typedef WeightType weight_t;\n    /** Alias of \\p ConstraintValueType. */\n    typedef ConstraintValueType constraint_value_t;\n    /** Alias of \\p NonBooleanValueType. */\n    typedef NonBooleanValueType non_boolean_value_t;\n\npublic:\n    /** Alias of the Constraint type in the WCSP instance, i.e., \\p\n     * Constraint<variable_id_t,weight_t,constraint_value_t>.\n     */\n    typedef Constraint<variable_id_t, weight_t, constraint_value_t> constraint_t;\n\nprivate:\n    std::vector<constraint_t> constraints;\n\n    // map from non-Boolean variables to their Boolean variable representations\n    std::vector<std::vector<variable_id_t> > nonBooleanVariables;\n\npublic:\n\n    /** \\brief Get the mapping from original variables to Boolean variables.\n     *\n     * \\return The mapping.\n     */\n    inline const std::vector<std::vector<variable_id_t> >& getNonBooleanVariables()\n        const noexcept\n    {\n        return nonBooleanVariables;\n    }\n\n    /** \\brief Display the mapping from original variables to Boolean variables.\n     */\n    inline void displayNonBooleanVariableMapping() const noexcept\n    {\n        std:: cout << \"--- Non-Boolean Variable Mapping BEGINS ---\" << std::endl;\n        for (auto i = 0; i < nonBooleanVariables.size(); ++ i)\n        {\n            std::cout << i << '\\t';\n            for (auto j : nonBooleanVariables[i])\n            {\n                std::cout << j << ' ';\n            }\n            std::cout << std::endl;\n        }\n        std:: cout << \"--- Non-Boolean Variable Mapping ENDS ---\" << std::endl;\n    }\n\n    /** \\brief Get the list of constraints.\n     *\n     * \\return A list of \\p constraint_t objects.\n     */\n    inline const std::vector<constraint_t>& getConstraints() const noexcept\n    {\n        return constraints;\n    }\n\n    /** \\brief Get the <tt>i</tt>'th constraint.\n     *\n     * \\param[in] i The index of the Constraint object to get.\n     *\n     * \\return The <tt>i</tt>'th constraint.\n     */\n    inline const constraint_t& getConstraint(size_t i) const noexcept\n    {\n        return constraints.at(i);\n    }\n\n    /** \\brief Compute the total weight corresponding to an assignment of values to all variables.\n     *\n     * \\param[in] assignments The assignment of values to all variables.\n     *\n     * \\return The computed total weight.\n     */\n    inline weight_t computeTotalWeight(\n        const std::map<variable_id_t, non_boolean_value_t>& assignments) const noexcept\n    {\n        weight_t tw = 0;\n\n        for (const auto& c : constraints)\n        {\n            std::vector<non_boolean_value_t> val(c.getNonBooleanVariables().size());\n            for (size_t i = 0; i < c.getNonBooleanVariables().size(); ++ i)\n            {\n                try\n                {\n                    val[i] = assignments.at(c.getNonBooleanVariables().at(i));\n                } catch (std::out_of_range& e)\n                {\n                    // Here, it means the variable assignments does not hold\n                    // c.getNonBooleanVariables().at(i) -- the CCG does not contain that variable.\n                    // This may well be that the variable itself is a \"dummy\" variable -- the value\n                    // of it does not affect the total weight. In this case, we always assign zero\n                    // (or anything else) to it.\n                    val[i] = 0;\n                }\n            }\n\n            tw += c.getWeight(val);\n        }\n\n        return tw;\n    }\n\npublic:\n    /** \\brief Load a problem instance from a stream.\n     *\n     * \\param[in] f The input stream.\n     */\n    void load(std::istream& f);\n\n    /** \\brief Load the problem in DIMACS format. The format specification is at\n     * http://graphmod.ics.uci.edu/group/WCSP_file_format\n     *\n     * \\param[in] f The input stream.\n     */\n    void loadDimacs(std::istream& f);\n\n    /** \\brief Load the problem in UAI format. The format specification is at\n     * http://www.hlt.utdallas.edu/~vgogate/uai14-competition/modelformat.html\n     *\n     * \\param[in] f The input stream.\n     */\n    void loadUAI(std::istream& f);\n\n    /** List of supported input file formats.\n     */\n    enum class Format\n    {\n        DIMACS,\n        UAI\n    };\n\n    /** \\brief Construct a WCSP instance from an input stream in a given format.\n     *\n     * \\param[in] f The input stream.\n     *\n     * \\param[in] format The format of \\p f.\n     */\n    WCSPInstance(std::istream& f, Format format)\n    {\n        switch (format)\n        {\n        case Format::DIMACS:\n            loadDimacs(f);\n            break;\n        case Format::UAI:\n            loadUAI(f);\n            break;\n        }\n    }\n\n    /** \\brief Convert this WCSP instance to a human-readable string.\n     *\n     * \\return The human-readable string.\n     */\n    std::string toString() const noexcept\n    {\n        std::stringstream ss;\n\n        ss << '{' << std::endl;\n        for (auto& c : constraints)\n        {\n            ss << c;\n        }\n\n        return ss.str();\n    }\n\n    /** \\brief Solve the WCSP instance using the min-sum message passing algorithm.\n     *\n     * \\param[in] delta The threshold for convergence determination. That is, the algorithm\n     * terminates iff all messages change within \\p delta compared with the previous iteration.\n     *\n     * \\return A solution to the WCSP instance.\n     */\n    std::map<variable_id_t, bool> solveUsingMessagePassing(weight_t delta) const noexcept\n    {\n        std::map<variable_id_t, std::set<const constraint_t*> > constraint_list_for_v;\n\n        // Initialize all messages.\n        std::map<std::pair<variable_id_t, const constraint_t*>, std::array<weight_t, 2> > msgs_v_to_c;\n        std::map<std::pair<const constraint_t*, variable_id_t>, std::array<weight_t, 2> > msgs_c_to_v;\n        for (const auto& c : constraints)\n        {\n            for (auto v : c.getVariables())\n            {\n                constraint_list_for_v[v].insert(&c);\n                msgs_v_to_c[std::make_pair(v, &c)] = {0, 0};\n                msgs_c_to_v[std::make_pair(&c, v)] = {0, 0};\n            }\n        }\n\n        bool converged = false;\n        uintmax_t num_iterations = 0;\n        do\n        {\n            if (RunningTime::GetInstance().isTimeOut())  // time's up\n                break;\n\n            ++ num_iterations;\n\n            converged = true;\n\n            auto msgs_v_to_c0 = msgs_v_to_c;\n            auto msgs_c_to_v0 = msgs_c_to_v;\n\n            // Update all the messages from variables to constraints.\n            for (auto& it : msgs_v_to_c)\n            {\n                auto v = it.first.first;\n                auto c = it.first.second;\n\n                std::array<weight_t, 2> m = {0, 0};\n\n                for (auto nc : constraint_list_for_v.at(v))\n                {\n                    if (nc != c)\n                    {\n                        const auto m_to_v = msgs_c_to_v0.find(std::make_pair(nc, v))->second;\n\n                        m[0] += m_to_v.at(0);\n                        m[1] += m_to_v.at(1);\n                    }\n                }\n\n                it.second = m;\n\n                // is it now convergent?\n                if (converged)\n                {\n                    auto old_m = msgs_v_to_c0.at(it.first);\n\n                    if (std::abs(old_m.at(0) - m.at(0)) > delta ||\n                        std::abs(old_m.at(1) - m.at(1)) > delta)\n                        converged = false;\n                }\n            }\n\n            // Update all the messages from constraints to variables.\n            for (auto& it : msgs_c_to_v)\n            {\n                auto c = it.first.first;\n                auto v = it.first.second;\n\n                std::vector<std::array<weight_t, 2> > m_to_c;\n                m_to_c.reserve(c->getVariables().size());\n                std::vector<variable_id_t> v_ids;\n                v_ids.reserve(c->getVariables().size());\n                size_t self_index;   // index of the variable itself\n                for (size_t i = 0; i < c->getVariables().size(); ++ i)\n                {\n                    auto nv = c->getVariable(i);\n\n                    m_to_c.push_back(msgs_v_to_c0.at(std::make_pair(nv, c)));\n                    v_ids.push_back(nv);\n\n                    if (nv == v)\n                        self_index = i;\n                }\n\n                std::array<weight_t, 2> m = {\n                    std::numeric_limits<weight_t>::max(), std::numeric_limits<weight_t>::max()\n                };\n\n                // TODO: Change the iteration which does not have an upper limit of number of bits.\n                for (unsigned long i = 0; i < (1ul << c->getVariables().size()); ++ i)\n                {\n                    constraint_value_t values(c->getVariables().size(), i);\n\n                    weight_t sum = c->getWeight(values);\n\n                    for (size_t j = 0; j < c->getVariables().size(); ++ j)\n                        if (c->getVariable(j) != v)\n                            sum += msgs_v_to_c0.at(\n                                std::make_pair(c->getVariable(j), c))[values[j] ? 1 : 0];\n\n                    size_t index_update = values[self_index] ? 1 : 0;\n\n                    if (m[index_update] > sum)\n                        m[index_update] = sum;\n                }\n\n                auto m_min = m[0] < m[1] ? m[0] : m[1];\n                m[0] -= m_min;\n                m[1] -= m_min;\n\n                it.second = m;\n\n                // is it now convergent?\n                if (converged)\n                {\n                    auto old_m = msgs_c_to_v0.at(it.first);\n\n                    if (std::abs(old_m.at(0) - m.at(0)) > delta ||\n                        std::abs(old_m.at(1) - m.at(1)) > delta)\n                        converged = false;\n                }\n            }\n        } while (!converged);\n\n        std::cout << \"Number of iterations: \" << num_iterations << std::endl;\n\n        // compute the variable values\n        std::map<variable_id_t, std::array<weight_t, 2> > assignments_w;\n\n        converged = true;\n        for (const auto& c : constraints)\n            for (auto v : c.getVariables())\n            {\n                assignments_w[v][0] += msgs_c_to_v[std::make_pair(&c, v)][0];\n                assignments_w[v][1] += msgs_c_to_v[std::make_pair(&c, v)][1];\n                if (isinf(assignments_w[v][0]) || isinf(assignments_w[v][1]))\n                    converged = false;\n            }\n\n        std::map<variable_id_t, bool> assignments;\n        for (const auto& a : assignments_w)\n            assignments[a.first] = a.second[0] > a.second[1] ? a.second[1] : a.second[0];\n\n        if (!converged)\n            std::cout << \"*** Message passing not converged! ***\" << std::endl;\n\n        return assignments;\n    }\n\n    /** \\brief Solve the WCSP instance using linear programming.\n     *\n     * \\param[in] lps The linear program solver to be used.\n     *\n     * \\return A solution to the WCSP instance.\n     */\n    std::map<variable_id_t, non_boolean_value_t> solveUsingLinearProgramming(\n        LinearProgramSolver& lps) const noexcept\n    {\n        lps.reset();\n        lps.setTimeLimit(RunningTime::GetInstance().getTimeLimit().count());\n\n        lps.setObjectiveType(LinearProgramSolver::ObjectiveType::MIN);\n\n        auto constraints = this->getConstraints();\n\n        // Every variable needs a unary constraint. This is the indices of all unary constraints.\n        std::vector<size_t> unary_indices(this->getNonBooleanVariables().size(),\n                                                 std::numeric_limits<size_t>::max());\n        size_t num_unary = 0;\n        for (size_t i = 0; i < constraints.size(); ++ i)\n        {\n            auto& vs = constraints.at(i).getVariables();\n            if (vs.size() == 1)  // unary constraint\n            {\n                unary_indices[vs.at(0)] = i;\n                ++ num_unary;\n            }\n        }\n        constraints.reserve(constraints.size() + unary_indices.size() - num_unary);\n        for (variable_id_t i = 0; i < unary_indices.size(); ++ i)\n        {\n            // no unary constraint for this var\n            if (unary_indices.at(i) == std::numeric_limits<size_t>::max())\n            {\n                constraint_t cons;\n                cons.setNonBooleanVariables(std::vector<variable_id_t>{i});\n                constraints.push_back(std::move(cons));\n                unary_indices[i] = constraints.size() - 1;\n            }\n        }\n\n        std::vector<std::vector<LinearProgramSolver::variable_id_t> > lp_variables(\n            constraints.size());\n\n        // add LP variables and constraints\n        for (size_t i = 0; i < constraints.size(); ++ i)\n        {\n            size_t num_values = 1;\n            // Cartesian product of all values\n            for (const auto& nbv : constraints.at(i).getNonBooleanVariables())\n                num_values *= nonBooleanVariables[nbv].size() + 1;\n            lp_variables[i].reserve(num_values);\n            for (size_t j = 0; j < num_values; ++ j)  // add all variables\n            {\n                std::vector<non_boolean_value_t> val;\n                val.reserve(constraints.at(i).getNonBooleanVariables().size());\n\n                size_t j0 = j;\n                for (const auto& nbv : constraints.at(i).getNonBooleanVariables())\n                {\n                    size_t d = nonBooleanVariables[nbv].size() + 1;\n                    val.push_back(j0 % d);\n                    j0 /= d;\n                }\n\n                lp_variables[i].push_back(lps.addVariable(constraints.at(i).getWeight(val)));\n            }\n\n            // Only one value in a WCSP constraint can take effect.\n            lps.addConstraint(lp_variables[i], std::vector<double>(num_values, 1.0), 1.0,\n                              LinearProgramSolver::ConstraintType::EQUAL);\n        }\n\n        // Add constraints that make sure LP variables that represent overlapped WCSP variables are\n        // consistent.\n        for (size_t i = 0; i < lp_variables.size(); ++ i)\n        {\n            for (size_t j : unary_indices)\n            {\n                if (j <= i)  // Don't do a pair twice.\n                    continue;\n\n                // Get the overlap map.\n                std::vector<std::pair<size_t, size_t> > overlapped_variables;\n\n                // Whether a variable is overlapping?\n                std::vector<bool> vs_overlap_p[2];\n                vs_overlap_p[0].resize(constraints.at(i).getNonBooleanVariables().size());\n                vs_overlap_p[1].resize(constraints.at(j).getNonBooleanVariables().size());\n                std::array<std::vector<size_t>, 2> domain_sizes;\n                domain_sizes[0].reserve(constraints.at(i).getNonBooleanVariables().size());\n                domain_sizes[1].reserve(constraints.at(j).getNonBooleanVariables().size());\n                std::vector<size_t> overlapped_domain_sizes;\n\n                for (size_t z = 0; z < 2; ++ z)\n                {\n                    size_t c = z ? j : i;\n                    for (size_t k = 0; k < constraints.at(c).getNonBooleanVariables().size();\n                         ++ k)\n                        domain_sizes[z].push_back(\n                            nonBooleanVariables[\n                                constraints.at(c).getNonBooleanVariables()[k]].size() + 1);\n                }\n\n                for (size_t k0 = 0; k0 < constraints.at(i).getNonBooleanVariables().size(); ++ k0)\n                    for (size_t k1 = 0; k1 < constraints.at(j).getNonBooleanVariables().size(); ++ k1)\n                    {\n                        if (constraints.at(i).getNonBooleanVariables()[k0] ==\n                            constraints.at(j).getNonBooleanVariables()[k1])\n                        {\n                            overlapped_variables.push_back(std::make_pair(k0, k1));\n                            overlapped_domain_sizes.push_back(\n                                nonBooleanVariables[\n                                    constraints.at(i).getNonBooleanVariables()[k0]].size() + 1\n                                );\n                            vs_overlap_p[0][k0] = true;\n                            vs_overlap_p[1][k1] = true;\n                            break;\n                        }\n                    }\n\n                std::vector<non_boolean_value_t> vs[2];\n                vs[0].resize(constraints.at(i).getNonBooleanVariables().size());\n                vs[1].resize(constraints.at(j).getNonBooleanVariables().size());\n\n                if (overlapped_domain_sizes.empty())  // no overlapping\n                    continue;\n                // Cartesian product of all values of overlapped variables\n                size_t num_values = std::accumulate(overlapped_domain_sizes.begin(),\n                                                    overlapped_domain_sizes.end(),\n                                                    1, std::multiplies<size_t>());\n\n                for (size_t k = 0; k < num_values; ++ k)\n                {\n                    size_t k0 = k;\n                    for (const auto& ov : overlapped_variables)\n                    {\n                        size_t d = nonBooleanVariables[\n                            constraints.at(i).getNonBooleanVariables()[ov.first]].size() + 1;\n                        non_boolean_value_t val = k0 % d;\n                        k0 /= d;\n                        vs[0][ov.first] = val;\n                        vs[1][ov.second] = val;\n                    }\n\n                    // non-overlapped variables\n                    std::array<std::vector<non_boolean_value_t>, 2> vs_non_overlapped;\n                    vs_non_overlapped[0].resize((vs[0].size() - overlapped_variables.size()));\n                    vs_non_overlapped[1].resize((vs[1].size() - overlapped_variables.size()));\n\n                    std::vector<LinearProgramSolver::variable_id_t> lp_vs;  // LP variables\n                    std::vector<double> coefs;\n\n                    for (size_t z = 0; z < 2; ++ z)\n                    {\n                        size_t l;\n                        do {\n                            for (l = 0; l < vs[z].size(); ++ l)\n                            {\n                                if (vs_overlap_p[z][l])\n                                    continue;\n\n                                ++ vs[z][l];\n                                if (vs[z][l] >= domain_sizes[z][l])\n                                    vs[z][l] = 0;\n                                else\n                                    break;\n                            }\n\n                            size_t index = 0;  // index corresponding to the variable values vs[z]\n                            size_t cur_base = 1;\n                            for (size_t m = 0; m < vs[z].size(); ++ m)\n                            {\n                                index += cur_base * vs[z][m];\n                                cur_base *= domain_sizes[z][m];\n                            }\n\n                            if (z == 0)\n                            {\n                                lp_vs.push_back(lp_variables[i][index]);\n                                coefs.push_back(1.0);\n                            }\n                            else\n                            {\n                                lp_vs.push_back(lp_variables[j][index]);\n                                coefs.push_back(-1.0);\n                            }\n                        } while (l != vs[z].size());\n                    }\n\n                    lps.addConstraint(lp_vs, coefs, 0.0,\n                                      LinearProgramSolver::ConstraintType::EQUAL);\n                }\n            }\n        }\n\n        std::vector<double> assignments;\n        lps.solve(assignments);\n\n        // Compute the solutions from assignments\n        std::map<variable_id_t, non_boolean_value_t> solution;\n        for (size_t i : unary_indices)\n            for (size_t j = 0; j < lp_variables[i].size(); ++ j)\n            {\n                if (assignments[lp_variables[i][j]] > 0.99)\n                {\n                    solution[constraints.at(i).getNonBooleanVariables().at(0)] = j;\n                    break;\n                }\n            }\n\n        return solution;\n    }\n};\n\ntemplate <class VarIdType, class WeightType, class ConstraintValueType, class NonBooleanValueType>\nvoid WCSPInstance<VarIdType, WeightType, ConstraintValueType, NonBooleanValueType>::loadDimacs(\n    std::istream& f)\n{\n    std::string line;\n    std::string tmp;\n    size_t max_domain_size;\n    size_t nv, nc; // number of variables, number of constraints\n\n    // first line: problem_name number_of_variables max_domain_size number_of_constraints\n    // global_upper_bound\n    std::getline(f, line);\n    std::istringstream ss(line);\n    ss >> tmp; // name\n    ss >> nv;\n    ss >> max_domain_size; // max domain size\n    ss >> nc;\n    ss >> tmp; // ignore global upper bound\n\n    // domain size of all variables\n    std::getline(f, line);\n    ss.clear();\n    ss.str(line);\n    variable_id_t cur_var_id = 0;\n    nonBooleanVariables.clear();\n    nonBooleanVariables.reserve(nv);\n    for (size_t i = 0; i < nv; ++ i)\n    {\n        size_t domain_size;\n        ss >> domain_size;\n        // Boolean variables corresponding to the current variable\n        std::vector<variable_id_t> vs(domain_size-1);\n        std::iota(vs.begin(), vs.end(), cur_var_id);\n        cur_var_id += vs.size();\n        nonBooleanVariables.push_back(std::move(vs));\n    }\n\n    constraints.clear();\n    constraints.resize(nc);\n\n    // iterate over constraints\n    for (size_t i = 0; i < nc; ++ i)\n    {\n        size_t arity;\n        weight_t default_cost;\n        size_t ntuples; // number of tuples not having the default cost\n        std::getline(f, line);\n        ss.clear();\n        ss.str(line);\n\n        ss >> arity;\n\n        // load the variables in the constraint\n        std::vector<variable_id_t> non_bool_variables;\n        non_bool_variables.reserve(arity);\n        // load the corresponding Boolean variables in the constraint\n        std::vector<variable_id_t> variables;\n        variables.reserve(arity*max_domain_size);\n        for (size_t j = 0; j < arity; ++ j)\n        {\n            variable_id_t vid;\n            ss >> vid;\n            non_bool_variables.push_back(vid);\n            const auto& nbv = nonBooleanVariables[vid];\n            variables.insert(variables.end(), nbv.begin(), nbv.end());\n        }\n        constraints[i].setVariables(std::move(variables));\n        constraints[i].setNonBooleanVariables(std::move(non_bool_variables));\n        ss >> default_cost;\n        // TODO: More efficient handling\n        if (default_cost > std::abs(1e-6))   // non-zero default cost\n        {\n            constraint_value_t values;\n            values.resize(constraints[i].getVariables().size());\n            unsigned long te = (1u << constraints[i].getVariables().size());\n            for (unsigned long l = 0; l < te; ++ l)\n            {\n                for (unsigned long k = 0; k < values.size(); ++ k)\n                    values.set(k, (l & (1u << k)) ? 1 : 0);\n                constraints[i].setWeight(values, default_cost);\n            }\n        }\n        ss >> ntuples;\n\n        // load the entries in the constraints\n        for (size_t j = 0; j < ntuples; ++ j)\n        {\n            weight_t cost;\n            constraint_value_t values;\n            values.resize(constraints[i].getVariables().size());\n            values.set();\n            std::vector<non_boolean_value_t> non_boolean_values(arity);\n            std::getline(f, line);\n            ss.clear();\n            ss.str(line);\n            for (size_t k = 0, cur_bit = 0; k < arity; ++ k)\n            {\n                int val;\n                ss >> val;\n                non_boolean_values[k] = val;\n                size_t bvs = nonBooleanVariables[constraints[i].getNonBooleanVariables()[k]].size();\n                if (bvs == 1)\n                    values.set(cur_bit ++, val ? true : false);\n                else\n                {\n                    if (val != 0)\n                        values.set(cur_bit + val - 1, false);\n                    cur_bit += bvs;\n                }\n            }\n            ss >> cost;\n            constraints[i].setWeight(std::move(non_boolean_values), cost);\n            constraints[i].setWeight(std::move(values), cost);\n        }\n    }\n}\n\ntemplate <class VarIdType, class WeightType, class ConstraintValueType, class NonBooleanValueType>\nvoid WCSPInstance<VarIdType, WeightType, ConstraintValueType, NonBooleanValueType>::loadUAI(\n    std::istream& f)\n{\n    std::string line;\n    std::string tmp;\n    size_t nv, nc; // number of variables, number of constraints\n\n    // first line: MARKOV, just ignore it\n    std::getline(f, tmp);\n\n    // second line: number of variables\n    {\n        std::getline(f, line);\n        std::istringstream ss(line);\n        ss >> nv; // number of variables\n    }\n\n    // third line: arity\n    {\n        std::getline(f, line);\n        std::istringstream ss(line);\n        variable_id_t cur_var_id = 0;\n        nonBooleanVariables.clear();\n        nonBooleanVariables.reserve(nv);\n        for (size_t i = 0; i < nv; ++ i)\n        {\n            size_t domain_size;\n            ss >> domain_size;\n            // Boolean varaibles corresponding to the current variable\n            std::vector<variable_id_t> vs(domain_size-1);\n            std::iota(vs.begin(), vs.end(), cur_var_id);\n            cur_var_id += vs.size();\n            nonBooleanVariables.push_back(std::move(vs));\n        }\n    }\n\n    // fourth line: number of constraints\n    {\n        std::getline(f, line);\n        std::istringstream ss(line);\n        ss >> nc;\n        constraints.clear();\n        constraints.resize(nc);\n    }\n\n    // iterate over constraints\n    for (size_t i = 0; i < nc; ++ i)\n    {\n        size_t arity;\n        std::getline(f, line);\n        std::istringstream ss(line);\n\n        ss >> arity;\n\n        // Load the variables in the constraint. We load it reversely because UAI format arrange\n        // their constraint value reversely as we do.\n        std::vector<variable_id_t> variables;\n        std::vector<variable_id_t> non_bool_variables(arity);\n\n        for (size_t j = 0; j < arity; ++ j)\n        {\n            variable_id_t vid;\n            ss >> vid;\n            non_bool_variables[arity-j-1] = vid;\n            variables.insert(variables.end(),\n                             nonBooleanVariables[vid].rbegin(),\n                             nonBooleanVariables[vid].rend());\n        }\n        std::reverse(variables.begin(), variables.end());\n\n        constraints[i].setVariables(std::move(variables));\n        constraints[i].setNonBooleanVariables(std::move(non_bool_variables));\n    }\n\n    // iterate over constraints\n    for (size_t i = 0; i < nc; ++ i)\n    {\n        size_t ntuples;\n        f >> ntuples;  // number of entries\n\n        // load the entries in the constraints\n        std::vector<weight_t> costs(ntuples);\n        for (size_t j = 0; j < ntuples; ++ j)\n            f >> costs[j];\n\n        // normalization constant\n        weight_t sum(std::accumulate(costs.begin(), costs.end(), weight_t()));\n\n        // set the value of each tuple\n        for (size_t j = 0; j < ntuples; ++ j)\n        {\n            costs[j] = -std::log(costs[j] / sum);\n            if (!std::isfinite(costs[j]))\n                costs[j] = 1e6;\n            constraint_value_t values;\n            std::vector<non_boolean_value_t> non_boolean_values;\n            non_boolean_values.reserve(constraints[i].getNonBooleanVariables().size());\n            size_t j0 = j;\n            for (const auto& nbv : constraints[i].getNonBooleanVariables())\n            {\n                auto d = nonBooleanVariables[nbv].size() + 1;\n                size_t cur_val = j0 % d;\n                non_boolean_values.push_back(cur_val);\n\n                if (d == 2)\n                    values.push_back(cur_val ? true : false);\n                else\n                {\n                    for (size_t k = 1; k < d; ++ k)\n                    {\n                        if (cur_val == k)\n                            values.push_back(false);\n                        else\n                            values.push_back(true);\n                    }\n                }\n                j0 /= d;\n            }\n            constraints[i].setWeight(std::move(values), costs[j]);\n            constraints[i].setWeight(std::move(non_boolean_values), costs[j]);\n        }\n    }\n}\n\n/** \\brief Write a Constraint object to a stream in a human-readable form.\n *\n * \\param[in] o The stream to write to.\n *\n * \\param[in] c The constraint object to be write to \\p o.\n *\n * \\return The stream \\p o.\n */\ntemplate <class ...T>\nstd::ostream& operator << (std::ostream& o, const Constraint<T...>& c)\n{\n    boost::property_tree::ptree t;\n    c.toPropertyTree(t);\n    boost::property_tree::write_json(o, t, true);\n    return o;\n}\n\n#endif /* WCSPINSTANCE_H_ */\n", "meta": {"hexsha": "d5f22849f5c4556ecdbaab8d1b1f49bce22842c0", "size": 40569, "ext": "h", "lang": "C", "max_stars_repo_path": "third_parties/wcsp/src/WCSPInstance.h", "max_stars_repo_name": "nandofioretto/py_dcop", "max_stars_repo_head_hexsha": "fb2dbc97b69360f5d1fb67d84749e44afcdf48c3", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2018-08-06T08:55:36.000Z", "max_stars_repo_stars_event_max_datetime": "2018-09-28T12:54:21.000Z", "max_issues_repo_path": "third_parties/wcsp/src/WCSPInstance.h", "max_issues_repo_name": "nandofioretto/py_dcop", "max_issues_repo_head_hexsha": "fb2dbc97b69360f5d1fb67d84749e44afcdf48c3", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "third_parties/wcsp/src/WCSPInstance.h", "max_forks_repo_name": "nandofioretto/py_dcop", "max_forks_repo_head_hexsha": "fb2dbc97b69360f5d1fb67d84749e44afcdf48c3", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.763496144, "max_line_length": 109, "alphanum_fraction": 0.5389583179, "num_tokens": 9309, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.36658973632215985, "lm_q2_score": 0.02333076974222782, "lm_q1q2_score": 0.008552820727996322}}
{"text": "#pragma once\n\n#include <thrust/iterator/counting_iterator.h>\n#include <thrust/iterator/transform_iterator.h>\n\n#include <cuda/runtime_api.hpp>\n\n#include <gsl-lite/gsl-lite.hpp>\n\n#include <cub/cub.cuh>\n\n#include <thrustshift/math.h>\n#include <thrustshift/not-a-vector.h>\n\nnamespace cub {\n\ntemplate <typename _UnsignedBits, typename T>\nstruct BaseTraits<SIGNED_INTEGER,\n                  false,\n                  false,\n                  _UnsignedBits,\n                  thrustshift::AbsView<T>> {\n\ttypedef _UnsignedBits UnsignedBits;\n\n\tstatic const Category CATEGORY = SIGNED_INTEGER;\n\tstatic const UnsignedBits HIGH_BIT = UnsignedBits(1)\n\t                                     << ((sizeof(UnsignedBits) * 8) - 1);\n\tstatic const UnsignedBits LOWEST_KEY = HIGH_BIT;\n\tstatic const UnsignedBits MAX_KEY = UnsignedBits(-1) ^ HIGH_BIT;\n\n\tenum {\n\t\tPRIMITIVE = true,\n\t\tNULL_TYPE = false,\n\t};\n\n\tstatic __device__ __forceinline__ UnsignedBits TwiddleIn(UnsignedBits key) {\n\t\tT val = key;\n\t\tif (val >= 0) {\n\t\t\treturn val;\n\t\t}\n\t\tUnsignedBits new_val = std::abs(val);\n\t\treturn new_val | HIGH_BIT;\n\t};\n\n\tstatic __device__ __forceinline__ UnsignedBits\n\tTwiddleOut(UnsignedBits key) {\n\t\tif (key & HIGH_BIT) {\n\t\t\tauto del_high_bit = key ^ HIGH_BIT;\n\t\t\tT x = -T(del_high_bit);\n\t\t\treturn x;\n\t\t}\n\t\treturn key;\n\t};\n\n\tstatic __host__ __device__ __forceinline__ T Max() {\n\t\treturn std::numeric_limits<T>::max();\n\t}\n\n\tstatic __host__ __device__ __forceinline__ T Lowest() {\n\t\treturn std::numeric_limits<T>::lowest();\n\t}\n};\n\ntemplate <typename _UnsignedBits, typename T>\nstruct BaseTraits<FLOATING_POINT,\n                  false,\n                  false,\n                  _UnsignedBits,\n                  thrustshift::AbsView<T>> {\n\ttypedef _UnsignedBits UnsignedBits;\n\n\tstatic const Category CATEGORY = FLOATING_POINT;\n\tstatic const UnsignedBits HIGH_BIT = UnsignedBits(1)\n\t                                     << ((sizeof(UnsignedBits) * 8) - 1);\n\tstatic const UnsignedBits LOWEST_KEY = UnsignedBits(-1);\n\tstatic const UnsignedBits MAX_KEY = UnsignedBits(-1) ^ HIGH_BIT;\n\n\tenum {\n\t\tPRIMITIVE = true,\n\t\tNULL_TYPE = false,\n\t};\n\n\tstatic __device__ __forceinline__ UnsignedBits TwiddleIn(UnsignedBits key) {\n\t\treturn key;\n\t};\n\n\tstatic __device__ __forceinline__ UnsignedBits\n\tTwiddleOut(UnsignedBits key) {\n\t\treturn key;\n\t};\n\n\tstatic __host__ __device__ __forceinline__ T Max() {\n\t\treturn FpLimits<T>::Max();\n\t}\n\n\tstatic __host__ __device__ __forceinline__ T Lowest() {\n\t\treturn FpLimits<T>::Lowest();\n\t}\n};\n\ntemplate <>\nstruct NumericTraits<thrustshift::AbsView<int>>\n    : BaseTraits<SIGNED_INTEGER,\n                 false,\n                 false,\n                 unsigned int,\n                 thrustshift::AbsView<int>> {};\ntemplate <>\nstruct NumericTraits<thrustshift::AbsView<long int>>\n    : BaseTraits<SIGNED_INTEGER,\n                 false,\n                 false,\n                 long unsigned int,\n                 thrustshift::AbsView<long int>> {};\ntemplate <>\nstruct NumericTraits<thrustshift::AbsView<long long int>>\n    : BaseTraits<SIGNED_INTEGER,\n                 false,\n                 false,\n                 long long unsigned int,\n                 thrustshift::AbsView<long long int>> {};\ntemplate <>\nstruct NumericTraits<thrustshift::AbsView<float>>\n    : BaseTraits<FLOATING_POINT,\n                 false,\n                 false,\n                 unsigned int,\n                 thrustshift::AbsView<float>> {};\ntemplate <>\nstruct NumericTraits<thrustshift::AbsView<double>>\n    : BaseTraits<FLOATING_POINT,\n                 false,\n                 false,\n                 long long unsigned int,\n                 thrustshift::AbsView<double>> {};\n\n} // namespace cub\n\nnamespace thrustshift {\n\nnamespace async {\n\n/*! \\brief Batched sort of keys with values.\n *\n *  Uses CUB's radix sort.\n */\ntemplate <class KeyInRange,\n          class KeyOutRange,\n          class ValueInRange,\n          class ValueOutRange,\n          class MemoryResource>\nvoid sort_batched_descending(cuda::stream_t& stream,\n                             KeyInRange&& keys_in,\n                             KeyOutRange&& keys_out,\n                             ValueInRange&& values_in,\n                             ValueOutRange&& values_out,\n                             std::size_t batch_len,\n                             MemoryResource& delayed_memory_resource) {\n\n\tconst std::size_t N = keys_in.size();\n\n\tgsl_Expects(N % batch_len == 0);\n\tgsl_Expects(batch_len > 0);\n\tgsl_Expects(keys_out.size() == N);\n\tgsl_Expects(values_in.size() == N);\n\tgsl_Expects(values_out.size() == N);\n\n\tauto cit = thrust::make_counting_iterator(0);\n\tauto tit = thrust::make_transform_iterator(\n\t    cit, [batch_len] __device__(int i) { return i * batch_len; });\n\n\tconst std::size_t num_batches = N / batch_len;\n\n\tsize_t tmp_bytes_size = 0;\n\tvoid* tmp_ptr = nullptr;\n\n\tusing KeyT = typename std::remove_reference<KeyOutRange>::type::value_type;\n\n\tauto exec = [&] {\n\t\tcuda::throw_if_error(cub::DeviceSegmentedRadixSort::SortPairsDescending(\n\t\t    tmp_ptr,\n\t\t    tmp_bytes_size,\n\t\t    keys_in.data(),\n\t\t    keys_out.data(),\n\t\t    values_in.data(),\n\t\t    values_out.data(),\n\t\t    gsl_lite::narrow<int>(N),\n\t\t    gsl_lite::narrow<int>(num_batches),\n\t\t    tit,\n\t\t    tit + 1,\n\t\t    0, // default value by CUB\n\t\t    sizeof(KeyT) * 8, // default value by CUB\n\t\t    stream.handle()));\n\t};\n\texec();\n\tauto tmp =\n\t    make_not_a_vector<uint8_t>(tmp_bytes_size, delayed_memory_resource);\n\ttmp_ptr = tmp.to_span().data();\n\texec();\n}\n\n/*! \\brief Batched sort of keys with respect to their absolute values.\n *\n *  Example:\n *\n *  ```\n *  batch_len = 5\n *  keys_in = {-8, 7, 10, -6, 5}\n *  // sort_batched_abs\n *  keys_out = {5, -6, 7, -8, 10}\n *  ```\n *\n *  ```\n *  batch_len = 3\n *  keys_in = {-8, 7, 10,   -6, 5, 4}\n *  // sort_batched_abs\n *  keys_out = {7, -8, 10,   4, 5, -6}\n *  ```\n */\ntemplate <class KeyInRange,\n          class KeyOutRange,\n          class ValueInRange,\n          class ValueOutRange,\n          class MemoryResource>\nvoid sort_batched_abs(cuda::stream_t& stream,\n                      KeyInRange&& keys_in,\n                      KeyOutRange&& keys_out,\n                      ValueInRange&& values_in,\n                      ValueOutRange&& values_out,\n                      std::size_t batch_len,\n                      MemoryResource& delayed_memory_resource) {\n\n\tconst std::size_t N = keys_in.size();\n\n\tgsl_Expects(N % batch_len == 0);\n\tgsl_Expects(batch_len > 0);\n\tgsl_Expects(keys_out.size() == N);\n\tgsl_Expects(values_in.size() == N);\n\tgsl_Expects(values_out.size() == N);\n\n\tusing KeyT = typename std::remove_reference<KeyOutRange>::type::value_type;\n\tusing AbsT = AbsView<KeyT>;\n\n\tauto cit = thrust::make_counting_iterator(0);\n\tauto tit = thrust::make_transform_iterator(\n\t    cit, [batch_len] __device__(int i) { return i * batch_len; });\n\n\tconst std::size_t num_batches = N / batch_len;\n\n\tsize_t tmp_bytes_size = 0;\n\tvoid* tmp_ptr = nullptr;\n\n\tauto exec = [&] {\n\t\tcuda::throw_if_error(cub::DeviceSegmentedRadixSort::SortPairs(\n\t\t    tmp_ptr,\n\t\t    tmp_bytes_size,\n\t\t    reinterpret_cast<const AbsT*>(keys_in.data()),\n\t\t    reinterpret_cast<AbsT*>(keys_out.data()),\n\t\t    values_in.data(),\n\t\t    values_out.data(),\n\t\t    gsl_lite::narrow<int>(N),\n\t\t    gsl_lite::narrow<int>(num_batches),\n\t\t    tit,\n\t\t    tit + 1,\n\t\t    0, // first key bit for comparison\n\t\t    sizeof(KeyT) * 8 - 1, // highest bit is used to save sign\n\t\t    stream.handle()));\n\t};\n\texec();\n\tauto tmp =\n\t    make_not_a_vector<uint8_t>(tmp_bytes_size, delayed_memory_resource);\n\ttmp_ptr = tmp.to_span().data();\n\texec();\n}\n\n} // namespace async\n\n} // namespace thrustshift\n", "meta": {"hexsha": "d9200d391f263dade3085d64dfd30f127c6d22d2", "size": 7600, "ext": "h", "lang": "C", "max_stars_repo_path": "include/thrustshift/sort.h", "max_stars_repo_name": "pauleonix/thrustshift", "max_stars_repo_head_hexsha": "763805f862e3121374286c927dd6949960bffb84", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/thrustshift/sort.h", "max_issues_repo_name": "pauleonix/thrustshift", "max_issues_repo_head_hexsha": "763805f862e3121374286c927dd6949960bffb84", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/thrustshift/sort.h", "max_forks_repo_name": "pauleonix/thrustshift", "max_forks_repo_head_hexsha": "763805f862e3121374286c927dd6949960bffb84", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.2401433692, "max_line_length": 77, "alphanum_fraction": 0.6168421053, "num_tokens": 1842, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.42632159254749036, "lm_q2_score": 0.019719128971477647, "lm_q1q2_score": 0.008406690466769706}}
{"text": "/*\n * Copyright 2008-2016 Jan Gasthaus\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#ifndef UTILS_H_\n#define UTILS_H_\n\n#include <string>\n#include <cmath>\n#include <map>\n#include <iostream>\n#include <fstream>\n#include <sstream>\n#include <cassert>\n#include <algorithm>\n#include <gsl/gsl_sf_gamma.h>\n\n////////////////////////////////////////////////////////////////////////////////\n/////////////////   SOME USEFUL MACROS   ///////////////////////////////////////\n////////////////////////////////////////////////////////////////////////////////\n#ifdef DEBUG\n#define tracer if (0) ; else std::cerr\n#define DBG if (1)\n#else\n#define tracer if (1) ; else std::cerr\n#define DBG if (1) ; else\n#endif\n\n  // some syntactic sugar for implementing interfaces using (multiple) inheritance\n#define interface class\n#define implements public\n\n  // A macro to disallow the copy constructor and operator= functions\n  // This should be used in the private: declarations for a class\n#define DISALLOW_COPY_AND_ASSIGN(TypeName) \\\n  TypeName(const TypeName&);               \\\n  void operator=(const TypeName&)\n\n\nnamespace gatsby { namespace libplump {\n\n/**\n * Alias: std::vector<double>\n */\ntypedef std::vector<double> d_vec;\n\n/**\n * Alias: std::vector<std::vector<double> >\n */\ntypedef std::vector<d_vec> d_vec_vec;\n\n/**\n * Alias: std::vector<unsigned int>\n */\ntypedef std::vector<unsigned int> ui_vec;\n\n/**\n * Alias: std::vector<std::vector<unsigned int> >\n */\ntypedef std::vector<ui_vec> ui_vec_vec;\n\n\n\n/**\n * Compute log2(x) -- the log2 provided by GCC is somewhat weird.\n */\ninline double log2(double x){\n  static const double LOG2 = std::log(2.);\n  return std::log(x)/LOG2;\n}\n\n\n/**\n * Read items of type E from a file and push them into a sequence of type\n * S (that has to support push_back(E item). \n *\n * Items are read from the file sizeof(E) bytes at a time. No error checking\n * is performed.\n *\n * @tparam E Type of element to read from file, elements will be read sizeof(E)\n *           bytes at a time.\n * @tparam S Type of sequence to push items into; \n *           must support push_back(E item)\n * @param fileName Name of the file to read from \n * @param seq Sequence to push items into\n * @param limit Maximum number of items to push (default: 0, no limit)\n */\ntemplate<typename E, class S>\n  inline void pushFileToVec(const std::string& fileName, S& seq, int limit = 0){\n    std::ifstream in;\n    in.open(fileName.c_str(),std::ios::binary | std::ios_base::in);\n    char buffer[sizeof(E)];\n    in.read(buffer,sizeof(E));\n    int j = 0;\n    if (limit==0)\n      limit = -1;\n    while (!in.eof() && j!=limit){\n      seq.push_back(*((E*)buffer));\n      in.read(buffer,sizeof(E));\n      j++;\n    }\n    in.close();\n  }\n\n/**\n * Push each character of string s individually into container seq of type S, \n * which has to support push_back(char c);\n *\n * @tparam S type of container to push into\n * @param s input string to push\n * @param seq output container to push into\n */\ntemplate<class S>\n  inline void pushStringToVec(const std::string& s, S& seq){\n    for (size_t i=0;i<s.length();i++) {\n      seq.push_back(s[i]);\n    }\n  }\n\n/**\n * Convert a map<T,T> where T is an integer type with \n * range 0...MAX to a vector v of length MAX+1 so that \n * v[x] = m[x] for x=1,...,MAX. v[x] = 0 if m.count(x) = 0.\n *\n * @tparam T integer type\n * @param m input map\n * @param v output vector\n * @returns pointer to histogram vector on the heap\n */\ntemplate<typename T>\n  inline void mapHistogramToVectorHistogram(const std::map<T,T>& m, std::vector<T>& v) {\n    T max = (*max_element(m.begin(), m.end())).first;\n    v.clear();\n    v.assign(max + 1,0);\n    for (typename std::map<T,T>::iterator i = m.begin(); i != m.end(); ++i) {\n      v[(*i).first] = (*i).second; \n    }\n    return v;\n  }\n\n/** \n * Count the number of times the elements k=0...max-1 occur in vec and \n * return the result in ret[k].\n */\ntemplate<typename T>\n  inline std::vector<T> vec2hist(std::vector<T>& vec, T max) {\n    std::vector<T> ret(max,0);\n    for (unsigned int i = 0; i < vec.size(); ++i) {\n      ++ret[vec[i]];\n    }\n    return ret;\n  }\n\n/**\n * Compute the mean of the elements in a sequence.\n *\n * @tparam T iteratable sequence type; must have a const_iterator member\n *           as well as begin() and end() methods.\n * @param in sequence to compute the mean of\n * @returns the mean of the elements in the sequence\n */\ntemplate<typename T>\n  inline double mean(const T& in) {\n    double mean = 0.0;\n    size_t j = 0;\n    for (typename T::const_iterator i = in.begin(); i != in.end(); ++i) {\n      mean += (((double)*i)-mean)/(++j);\n    }\n    return mean;\n  }\n\n\n/**\n * Sum the elements in a sequence.\n *\n * @tparam T iteratable sequence type; must have a const_iterator member\n *           as well as begin() and end() methods.\n * @param in sequence to compute the sum of\n * @returns the sum of the elements in the sequence\n */\ntemplate<typename T>\n  inline typename T::value_type sum(const T& in) {\n    typename T::value_type sum = 0;\n    for (typename T::const_iterator i = in.begin(); i != in.end(); ++i) {\n      sum += *i;\n    }\n    return sum;\n  }\n\ninline void log2_vec(d_vec& in) {\n  for (size_t i=0;i<in.size();i++){\n    in[i] = log2(in[i]);\n  }\n}\n\ninline void exp_vec(d_vec& in) {\n  for (size_t i=0;i<in.size();i++){\n    in[i] = exp(in[i]);\n  }\n}\n\n/**\n * Multiply all elements of a vector by a constant.\n */\ntemplate<typename elem_t>\n  inline void mult_vec(std::vector<elem_t>& in, elem_t mult) {\n    for (size_t i=0;i<in.size();i++){\n      in[i] = in[i] * mult;\n    }\n  }\n\n/**\n * Add a constant to all elements of a vector.\n */\ntemplate<typename elem_t>\n  inline void add_vec(std::vector<elem_t>& in, elem_t add) {\n    for (size_t i=0;i<in.size();i++){\n      in[i] = in[i] + add;\n    }\n  }\n\n/**\n * Subtract max element fromall elements of a vector.\n */\ntemplate<typename elem_t>\n  inline void subMax_vec(std::vector<elem_t>& in) {\n    elem_t max = *std::max_element(in.begin(), in.end());\n    // if (max == -INFINITY) {\n    //   for (size_t i=0;i<in.size();i++){\n    //     in[i] = 0;\n    //   }\n    // }\n    for (size_t i=0;i<in.size();i++){ \n      in[i] = in[i] - max;\n    }\n  }\n\n\n/**\n * Add two vectors elementwise.\n */\ntemplate<typename elem_t>\n  inline void add_vec(std::vector<elem_t>& inout, const std::vector<elem_t>& add) {\n    std::transform(inout.begin(), inout.end(), add.begin(), inout.begin(),\n                  std::plus<elem_t>());\n  }\n\n/**\n * Elementwise multiplication. Results is returned in the first argument.\n */\ntemplate<typename elem_t>\n  inline void mult_vec(std::vector<elem_t>& inout, std::vector<elem_t> in) {\n    assert(inout.size() == in.size());\n    for (size_t i=0;i<inout.size();i++){\n      inout[i] *= in[i];\n    }\n  }\n\n\n/**\n * Average the values in multiple vectors of the same length.\n **/\ninline d_vec average(const d_vec_vec& ins) {\n  d_vec out(ins[0].size(), 0);\n  for (int j = 0; j < ins.size(); j++) {\n    add_vec(out, ins[j]);\n  }\n  mult_vec(out, 1./ins.size());\n  return out;\n}\n\n\ntemplate<typename elem_t>\n  inline double prob2loss(std::vector<elem_t> in) {\n    double out = 0.0;\n    for (size_t i=0;i<in.size();i++){\n      out -= log2(in[i]);\n    }\n    return out/in.size();\n  }\n\ninline bool closeTo(double value, double target, double tol=10e-4) {\n  return std::abs(value-target) < tol;\n}\n\ntemplate<typename Iterable>\n  inline std::string iterableToString(const Iterable input) {\n    std::ostringstream output;\n    for(typename Iterable::const_iterator it = input.begin(); it!=input.end();it++) {\n      output << *it << \", \";\n    }\n    return output.str();\n  }\n\ntemplate<typename Iterable>\n  void iterableToCSVFile(const Iterable input, std::string fn) {\n    std::ofstream output(fn.c_str());\n    output.precision(10);\n    for(typename Iterable::const_iterator it = input.begin(); it!=input.end();it++) {\n      output << *it << \", \";\n    }\n  }\n\n/**\n * computes log(exp(a) + exp(b)) while avoiding numerical\n * instabilities.\n */\ninline double logsumexp(double a, double b) {\n  // choose c to be the one that is largest in abs value\n  double c = (a>b)?a:b;\n  return (log(exp(a-c) + exp(b-c))) + c;\n}\n\n\ninline double sigmoid(double x) {\n  return 1.0/(1.0 + exp(-x));\n}\n\n// logit = inverse sigmoid\ninline double logit(double x) {\n  return log(x) - log(1-x);\n}\n\n\ninline double logKramp(double base, double inc, double lim) {\n  if (inc == 0)\n      return lim*log(base);\n  if (lim <= 0) {\n    return 0;\n  } else {\n    return lim*log(inc) + gsl_sf_lnpoch(base/inc, lim);\n  }\n}\n\n\ninline double kramp(double base, double inc, double lim) {\n  return exp(logKramp(base, inc, lim));\n}\n\n\n\nstatic clock_t global_clock;\n\n/*\n * Start timing\n */\ninline void tic() {\n  global_clock = clock();\n}\n\n/**\n * Return number of seconds since last tic()\n */\ninline double toc() {\n  return (clock() - global_clock)/(double)CLOCKS_PER_SEC; \n\n}\n\n\ninline std::string makeProgressBarString(double percentDone, int total=10) {\n  std::ostringstream out;\n\n  int numDone = (int)floor(total * percentDone);\n\n  out << \"[\";\n  for (int i=0; i<numDone; i++) {\n    out << \"=\";\n  }\n  out << \">\";\n  for (int i=numDone; i<total; i++) {\n    out << \" \";\n  }\n  out << \"]\";\n  return out.str();\n}\n\n\n}} // namespace gatsby::libplump\n\n#endif /* UTILS_H_ */\n", "meta": {"hexsha": "b0f6717b5546c8e258596fb070b78a6eba5f95df", "size": 9739, "ext": "h", "lang": "C", "max_stars_repo_path": "src/libplump/utils.h", "max_stars_repo_name": "jgasthaus/libPLUMP", "max_stars_repo_head_hexsha": "18e5911575e3c9a054482b08d637dc91b0cd05b9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 13.0, "max_stars_repo_stars_event_min_datetime": "2015-02-02T21:46:58.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-16T03:50:37.000Z", "max_issues_repo_path": "src/libplump/utils.h", "max_issues_repo_name": "jgasthaus/libPLUMP", "max_issues_repo_head_hexsha": "18e5911575e3c9a054482b08d637dc91b0cd05b9", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/libplump/utils.h", "max_forks_repo_name": "jgasthaus/libPLUMP", "max_forks_repo_head_hexsha": "18e5911575e3c9a054482b08d637dc91b0cd05b9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2016-11-17T19:19:37.000Z", "max_forks_repo_forks_event_max_datetime": "2016-11-20T00:56:17.000Z", "avg_line_length": 24.7811704835, "max_line_length": 88, "alphanum_fraction": 0.6144368005, "num_tokens": 2614, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.22815650216092534, "lm_q2_score": 0.03358950298969727, "lm_q1q2_score": 0.007663663511453273}}
{"text": "/*\t$Id$ */\r\n/*\r\n * Copyright (c) 2014, 2015 Kristaps Dzonsons <kristaps@kcons.eu>\r\n *\r\n * Permission to use, copy, modify, and distribute this software for any\r\n * purpose with or without fee is hereby granted, provided that the above\r\n * copyright notice and this permission notice appear in all copies.\r\n *\r\n * THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES\r\n * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF\r\n * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR\r\n * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES\r\n * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN\r\n * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF\r\n * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\r\n */\r\n#include <assert.h>\r\n#include <math.h>\r\n#include <stdint.h>\r\n#include <stdlib.h>\r\n#ifdef __linux__\r\n#include <bsd/stdlib.h> /* arc4random() */\r\n#endif\r\n#include <string.h>\r\n\r\n#include <glib.h>\r\n#include <gtk/gtk.h>\r\n#include <gsl/gsl_rng.h>\r\n#include <gsl/gsl_multifit.h>\r\n#include <gsl/gsl_histogram.h>\r\n#include <kplot.h>\r\n\r\n#include \"extern.h\"\r\n\r\nenum\tkmltype {\r\n\tKML_INIT = 0,\r\n\tKML_KML,\r\n\tKML_DOCUMENT,\r\n\tKML_FOLDER,\r\n\tKML_PLACEMARK,\r\n\tKML_POINT,\r\n\tKML_COORDINATES,\r\n\tKML_DESCRIPTION,\r\n\tKML__MAX\r\n};\r\n\r\nenum\tkmlkey {\r\n\tKMLKEY_MEAN,\r\n\tKMLKEY_MEAN_PERCENT,\r\n\tKMLKEY_STDDEV,\r\n\tKMLKEY_POPULATION,\r\n\tKMLKEY__MAX\r\n};\r\n\r\nstruct\tkmlsave {\r\n\tFILE\t\t*f;\r\n\tstruct sim\t*cursim;\r\n\tsize_t\t\t curisland;\r\n\tgchar\t\t*buf;\r\n\tgsize\t\t bufsz;\r\n\tgsize\t\t bufmax;\r\n\tint\t\t buffering;\r\n};\r\n\r\nstruct\tkmlparse {\r\n\tenum kmltype\t elem; /* current element */\r\n\tstruct kmlplace\t*cur; /* currently-parsed kmlplace */\r\n\tgchar\t\t*buf; /* current parse text buffer */\r\n\tgsize\t \t bufsz; /* size in parse buffer */\r\n\tgsize\t \t bufmax; /* maximum sized buffer */\r\n\tgchar\t\t*altbuf; \r\n\tgsize\t \t altbufsz; \r\n\tgsize\t \t altbufmax; \r\n\tGList\t\t*places; /* parsed places */\r\n\tgchar\t\t*ign; /* element we're currently ignoring */\r\n\tsize_t\t\t ignstack; /* stack of \"ign\" while ignoring */\r\n#define\tKML_STACKSZ\t 128\r\n\tenum kmltype\t stack[128];\r\n\tsize_t\t\t stackpos;\r\n};\r\n\r\nstatic\tconst char *const kmlkeys[KMLKEY__MAX] = {\r\n\t\"mean\", /* KMLKEY_MEAN */\r\n\t\"meanpct\", /* KMLKEY_MEAN_PERCENT */\r\n\t\"stddev\", /* KMLKEY_STDDEV */\r\n\t\"population\", /* KMLKEY_POPULATION */\r\n};\r\n\r\nstatic\tconst char *const kmltypes[KML__MAX] = {\r\n\tNULL, /* KML_INIT */\r\n\t\"kml\", /* KML_KML */\r\n\t\"Document\", /* KML_DOCUMENT */\r\n\t\"Folder\", /* KML_FOLDER */\r\n\t\"Placemark\", /* KML_PLACEMARK */\r\n\t\"Point\", /* KML_POINT */\r\n\t\"coordinates\", /* KML_COORDINATES */\r\n\t\"description\", /* KML_DESCRIPTION */\r\n};\r\n\r\nstatic\tconst double DEG_TO_RAD = 0.017453292519943295769236907684886;\r\nstatic\tconst double EARTH_RADIUS_IN_METERS = 6372797.560856;\r\n\r\nstatic double\r\nkml_dist(const struct kmlplace *from, const struct kmlplace *to)\r\n{\r\n\tdouble\t latitudeArc, longitudeArc, \r\n\t\t latitudeH, lontitudeH, tmp;\r\n\r\n\tlatitudeArc = (from->lat - to->lat) * DEG_TO_RAD;\r\n\tlongitudeArc = (from->lng - to->lng) * DEG_TO_RAD;\r\n\tlatitudeH = sin(latitudeArc * 0.5);\r\n\tlatitudeH *= latitudeH;\r\n\tlontitudeH = sin(longitudeArc * 0.5);\r\n\tlontitudeH *= lontitudeH;\r\n\ttmp = cos(from->lat * DEG_TO_RAD) * \r\n\t\tcos(to->lat * DEG_TO_RAD);\r\n\r\n\treturn(EARTH_RADIUS_IN_METERS * 2.0 * \r\n\t\tasin(sqrt(latitudeH + tmp * lontitudeH)));\r\n}\r\n\r\nstatic void\r\nkml_append(gchar **buf, gsize *bufsz, \r\n\tgsize *bufmax, const char *text, gsize sz)\r\n{\r\n\r\n\t/* XXX: no check for overflow... */\r\n\tif (*bufsz + sz + 1 > *bufmax) {\r\n\t\t*bufmax = *bufsz + sz + 1024;\r\n\t\t*buf = g_realloc(*buf, *bufmax);\r\n\t}\r\n\r\n\tmemcpy(*buf + *bufsz, text, sz);\r\n\t*bufsz += sz;\r\n\t(*buf)[*bufsz] = '\\0';\r\n\tg_assert(*bufsz <= *bufmax);\r\n}\r\n\r\nstatic enum kmltype\r\nkml_lookup(const gchar *name)\r\n{\r\n\tenum kmltype\ti;\r\n\r\n\tfor (i = 0; i < KML__MAX; i++) {\r\n\t\tif (NULL == kmltypes[i])\r\n\t\t\tcontinue;\r\n\t\tif (0 == g_strcmp0(kmltypes[i], name))\r\n\t\t\tbreak;\r\n\t}\r\n\r\n\treturn(i);\r\n}\r\n\r\nstatic void\r\nkmlparse_free(gpointer dat)\r\n{\r\n\tstruct kmlplace\t*place = dat;\r\n\r\n\tif (NULL == place)\r\n\t\treturn;\r\n\tfree(place);\r\n}\r\n\r\nvoid\r\nkml_free(struct kml *kml)\r\n{\r\n\r\n\tif (NULL == kml)\r\n\t\treturn;\r\n\r\n\tg_list_free_full(kml->kmls, kmlparse_free);\r\n\r\n\tif (NULL != kml->file)\r\n\t\tg_mapped_file_unref(kml->file);\r\n}\r\n\r\n/*\r\n * Try to find the string \"@@population=NN@@\", which stipulates the\r\n * population for this particular island.\r\n * If we don't find it, just return--we'll use the default.\r\n * If we find a bad population, raise an error.\r\n */\r\nstatic int\r\nkml_placemark(const gchar *buf, struct kmlplace *place)\r\n{\r\n\tconst gchar\t*cp;\r\n\tgchar\t\t*ep;\r\n\tgsize\t\t keysz;\r\n\tgchar\t\t nbuf[22];\r\n\r\n\tkeysz = strlen(\"@@population=\");\r\n\twhile (NULL != (cp = strstr(buf, \"@@population=\"))) {\r\n\t\tbuf = cp + keysz;\r\n\t\tif (NULL == (cp = strstr(buf, \"@@\")))\r\n\t\t\tbreak;\r\n\t\tif ((gsize)(cp - buf) >= sizeof(nbuf) - 1)\r\n\t\t\treturn(0);\r\n\t\tmemcpy(nbuf, buf, cp - buf);\r\n\t\tnbuf[cp - buf] = '\\0';\r\n\t\tplace->pop = g_ascii_strtoull(buf, &ep, 10);\r\n\t\tif (ERANGE == errno || EINVAL == errno || ep == buf)\r\n\t\t\treturn(0);\r\n\t\tbreak;\r\n\t}\r\n\r\n\treturn(1);\r\n}\r\n\r\nstatic void\t\r\nkml_elem_end(GMarkupParseContext *ctx, \r\n\tconst gchar *name, gpointer dat, GError **er)\r\n{\r\n\tstruct kmlparse\t *p = dat;\r\n\tenum kmltype\t  t;\r\n\tgchar\t\t**set;\r\n\r\n\tif (NULL != p->ign) {\r\n\t\tg_assert(p->ignstack > 0);\r\n\t\tif (0 == g_strcmp0(p->ign, name))\r\n\t\t\tp->ignstack--;\r\n\t\tif (p->ignstack > 0)\r\n\t\t\treturn;\r\n\t\tg_free(p->ign);\r\n\t\tp->ign = NULL;\r\n\t\treturn;\r\n\t} \r\n\r\n\tt = kml_lookup(name);\r\n\tg_assert(p->stackpos > 0);\r\n\tg_assert(t == p->stack[p->stackpos - 1]);\r\n\tp->stackpos--;\r\n\r\n\tswitch (p->stack[p->stackpos]) {\r\n\tcase (KML_PLACEMARK):\r\n\t\t/*\r\n\t\t * if we're ending a Placemark, first check whether\r\n\t\t * we've listed a population somewhere in any of the\r\n\t\t * nested text segments.\r\n\t\t * Also make sure that we have some coordinates (the\r\n\t\t * default value was 360 for both, which of course isn't\r\n\t\t * a valid coordinate).\r\n\t\t */\r\n\t\tg_assert(NULL != p->cur);\r\n\t\tif ( ! kml_placemark(p->altbuf, p->cur)) {\r\n\t\t\t*er = g_error_new_literal\r\n\t\t\t\t(G_MARKUP_ERROR, \r\n\t\t\t\t G_MARKUP_ERROR_INVALID_CONTENT, \r\n\t\t\t\t \"Cannot parse population\");\r\n\t\t\tbreak;\r\n\t\t} else if (p->cur->lat > 180 || p->cur->lng > 180) {\r\n\t\t\t*er = g_error_new_literal\r\n\t\t\t\t(G_MARKUP_ERROR, \r\n\t\t\t\t G_MARKUP_ERROR_INVALID_CONTENT, \r\n\t\t\t\t \"No coordinates for placemark\");\r\n\t\t\tbreak;\r\n\t\t}\r\n\t\tp->places = g_list_append(p->places, p->cur);\r\n\t\tp->cur = NULL;\r\n\t\tbreak;\r\n\tcase (KML_COORDINATES):\r\n\t\t/*\r\n\t\t * Parse coordinates from the mix.\r\n\t\t * Coordinates are longitude,latitude,altitude.\r\n\t\t * Parse quickly and just make sure they're valid.\r\n\t\t */\r\n\t\tset = g_strsplit(p->buf, \",\", 3);\r\n\t\tp->cur->lng = g_ascii_strtod(set[0], NULL);\r\n\t\tif (ERANGE == errno)\r\n\t\t\t*er = g_error_new_literal\r\n\t\t\t\t(G_MARKUP_ERROR, \r\n\t\t\t\t G_MARKUP_ERROR_INVALID_CONTENT, \r\n\t\t\t\t \"Cannot parse longitude\");\r\n\t\telse if (p->cur->lng > 180.0 || p->cur->lng < -180.0)\r\n\t\t\t*er = g_error_new_literal\r\n\t\t\t\t(G_MARKUP_ERROR, \r\n\t\t\t\t G_MARKUP_ERROR_INVALID_CONTENT, \r\n\t\t\t\t \"Invalid longitude\");\r\n\t\tp->cur->lat = g_ascii_strtod(set[1], NULL);\r\n\t\tif (ERANGE == errno)\r\n\t\t\t*er = g_error_new_literal\r\n\t\t\t\t(G_MARKUP_ERROR, \r\n\t\t\t\t G_MARKUP_ERROR_INVALID_CONTENT, \r\n\t\t\t\t \"Cannot parse latitude\");\r\n\t\telse if (p->cur->lat > 90.0 || p->cur->lat < -90.0)\r\n\t\t\t*er = g_error_new_literal\r\n\t\t\t\t(G_MARKUP_ERROR, \r\n\t\t\t\t G_MARKUP_ERROR_INVALID_CONTENT, \r\n\t\t\t\t \"Invalid latitude\");\r\n\t\tg_strfreev(set);\r\n\t\tbreak;\r\n\tdefault:\r\n\t\tbreak;\r\n\t}\r\n}\r\n\r\nstatic void\r\nkml_elem_start(GMarkupParseContext *ctx, \r\n\tconst gchar *name, const gchar **attrn, \r\n\tconst gchar **attrv, gpointer dat, GError **er)\r\n{\r\n\tenum kmltype\t t;\r\n\tstruct kmlparse\t*p = dat;\r\n\r\n\tif (NULL != p->ign) {\r\n\t\tg_assert(p->ignstack > 0);\r\n\t\tif (0 == g_strcmp0(p->ign, name))\r\n\t\t\tp->ignstack++;\r\n\t\treturn;\r\n\t}\r\n\t\r\n\tif (KML__MAX == (t = kml_lookup(name))) {\r\n\t\tassert(0 == p->ignstack);\r\n\t\tp->ign = g_strdup(name);\r\n\t\tp->ignstack = 1;\r\n\t\treturn;\r\n\t}\r\n\r\n\tp->stack[p->stackpos++] = t;\r\n\tp->bufsz = 0;\r\n\t\r\n\tswitch (p->stack[p->stackpos - 1]) {\r\n\tcase (KML_PLACEMARK):\r\n\t\t/*\r\n\t\t * If we're starting a Placemark, initialise ourselves\r\n\t\t * with bad coorindates and a default population.\r\n\t\t */\r\n\t\tif (NULL == p->cur) {\r\n\t\t\tp->cur = g_malloc0(sizeof(struct kmlplace));\r\n\t\t\tp->cur->lat = p->cur->lng = 360;\r\n\t\t\tp->cur->pop = 2;\r\n\t\t\tp->altbufsz = 0;\r\n\t\t\tbreak;\r\n\t\t}\r\n\t\t*er = g_error_new_literal\r\n\t\t\t(G_MARKUP_ERROR, \r\n\t\t\t G_MARKUP_ERROR_INVALID_CONTENT, \r\n\t\t\t \"Nested placemarks not allowed.\");\r\n\t\tbreak;\r\n\tdefault:\r\n\t\tbreak;\r\n\t}\r\n}\r\n\r\nstatic void\r\nkml_text(GMarkupParseContext *ctx, \r\n\tconst gchar *txt, gsize sz, gpointer dat, GError **er)\r\n{\r\n\tstruct kmlparse\t*p = dat;\r\n\r\n\tif (NULL != p->cur)\r\n\t\tkml_append(&p->altbuf, &p->altbufsz, \r\n\t\t\t&p->altbufmax, txt, sz);\r\n\r\n\t/* No collection w/o element or while ignoring. */\r\n\tif (NULL != p->ign || 0 == p->stackpos)\r\n\t\treturn;\r\n\r\n\t/* Each element for which we're going to collect text. */\r\n\tswitch (p->stack[p->stackpos - 1]) {\r\n\tcase (KML_COORDINATES):\r\n\t\tbreak;\r\n\tdefault:\r\n\t\treturn;\r\n\t}\r\n\r\n\tkml_append(&p->buf, &p->bufsz, &p->bufmax, txt, sz);\r\n}\r\n\r\nstatic void\r\nkml_error(GMarkupParseContext *ctx, GError *er, gpointer dat)\r\n{\r\n\r\n\tg_warning(\"%s\", er->message);\r\n}\r\n\r\nstruct kml *\r\nkml_torus(size_t islands, size_t islanders)\r\n{\r\n\tstruct kml\t*kml;\r\n\tstruct kmlplace\t*p;\r\n\tsize_t\t\t i;\r\n\r\n\tkml = g_malloc0(sizeof(struct kml));\r\n\r\n\tfor (i = 0; i < islands; i++) {\r\n\t\tp = g_malloc0(sizeof(struct kmlplace));\r\n\t\tp->pop = islanders;\r\n\t\tp->lng = 360 * i / (double)islands - 180.0;\r\n\t\tp->lat = 0.0;\r\n\t\tkml->kmls = g_list_append(kml->kmls, p);\r\n\t}\r\n\r\n\treturn(kml);\r\n}\r\n\r\nstruct kml *\r\nkml_rand(size_t islands, size_t islanders)\r\n{\r\n\tstruct kml\t*kml;\r\n\tstruct kmlplace\t*p;\r\n\tsize_t\t\t i;\r\n\r\n\tkml = g_malloc0(sizeof(struct kml));\r\n\r\n\tfor (i = 0; i < islands; i++) {\r\n\t\tp = g_malloc0(sizeof(struct kmlplace));\r\n\t\tp->pop = islanders;\r\n\t\tp->lng = 360 * arc4random() / (double)UINT32_MAX - 180.0;\r\n\t\tp->lat = 180 * arc4random() / (double)UINT32_MAX - 90.0;\r\n\t\tkml->kmls = g_list_append(kml->kmls, p);\r\n\t}\r\n\r\n\treturn(kml);\r\n}\r\n\r\nstruct kml *\r\nkml_parse(const gchar *file, GError **er)\r\n{\r\n\tGMarkupParseContext\t*ctx;\r\n\tGMarkupParser\t  \t parse;\r\n\tGMappedFile\t\t*f;\r\n\tint\t\t\t rc;\r\n\tstruct kmlparse\t\t data;\r\n\tstruct kml\t\t*kml;\r\n\r\n\tif (NULL != er)\r\n\t\t*er = NULL;\r\n\r\n\tmemset(&parse, 0, sizeof(GMarkupParser));\r\n\tmemset(&data, 0, sizeof(struct kmlparse));\r\n\r\n\tdata.elem = KML_INIT;\r\n\r\n\tparse.start_element = kml_elem_start;\r\n\tparse.end_element = kml_elem_end;\r\n\tparse.text = kml_text;\r\n\tparse.error = kml_error;\r\n\r\n\tif (NULL == (f = g_mapped_file_new(file, FALSE, er)))\r\n\t\treturn(NULL);\r\n\r\n\tctx = g_markup_parse_context_new\r\n\t\t(&parse, 0, &data, NULL);\r\n\tg_assert(NULL != ctx);\r\n\trc = g_markup_parse_context_parse\r\n\t\t(ctx, g_mapped_file_get_contents(f),\r\n\t\t g_mapped_file_get_length(f), er);\r\n\r\n\tg_markup_parse_context_free(ctx);\r\n\tg_free(data.buf);\r\n\tg_free(data.altbuf);\r\n\tg_free(data.ign);\r\n\tkmlparse_free(data.cur);\r\n\r\n\tif (0 == rc) {\r\n\t\tg_list_free_full(data.places, kmlparse_free);\r\n\t\tg_mapped_file_unref(f);\r\n\t\treturn(NULL);\r\n\t} else if (NULL == data.places) {\r\n\t\tg_mapped_file_unref(f);\r\n\t\treturn(NULL);\r\n\t}\r\n\r\n\tg_assert(NULL != data.places);\r\n\tkml = g_malloc0(sizeof(struct kml));\r\n\tkml->file = f;\r\n\tkml->kmls = data.places;\r\n\treturn(kml);\r\n}\r\n\r\ndouble **\r\nkml_migration_twonearest(GList *list, enum maptop map)\r\n{\r\n\tdouble\t\t**p;\r\n\tdouble\t\t  dist, min;\r\n\tsize_t\t\t  i, j, len, minj, min2j;\r\n\tstruct kmlplace\t *pl1, *pl2;\r\n\r\n\tlen = (size_t)g_list_length(list);\r\n\tg_assert(len > 0);\r\n\tif (1 == len) {\r\n\t\tg_debug(\"Request for two nearest falling \"\r\n\t\t\t\"back to nearest\");\r\n\t\treturn(kml_migration_nearest(list, map));\r\n\t}\r\n\r\n\tp = g_malloc0_n(len, sizeof(double *));\r\n\r\n\t/* \r\n\t * Special case the torus, which has a well-defined layout\r\n\t * between nodes, such that the next (\"right\") and previous\r\n\t * (\"left\") islands, wrapping around, get the migrants.\r\n\t */\r\n\tif (MAPTOP_TORUS == map) {\r\n\t\tfor (i = 0; i < len; i++) {\r\n\t\t\tp[i] = g_malloc0_n(len, sizeof(double));\r\n\t\t\tif (i < len - 1)\r\n\t\t\t\tp[i][i + 1] = 0.5;\r\n\t\t\telse\r\n\t\t\t\tp[i][0] = 0.5;\r\n\t\t\tif (i > 0)\r\n\t\t\t\tp[i][i - 1] = 0.5;\r\n\t\t\telse\r\n\t\t\t\tp[i][len - 1] = 0.5;\r\n\t\t}\r\n\t\treturn(p);\r\n\t}\r\n\r\n\tfor (i = 0; i < len; i++) {\r\n\t\tpl1 = g_list_nth_data(list, i);\r\n\t\tp[i] = g_malloc0_n(len, sizeof(double));\r\n\t\tfor (minj = j = 0, min = DBL_MAX; j < len; j++) {\r\n\t\t\tif (i == j)\r\n\t\t\t\tcontinue;\r\n\t\t\tpl2 = g_list_nth_data(list, j);\r\n\t\t\tif ((dist = kml_dist(pl1, pl2)) < min) {\r\n\t\t\t\tmin = dist;\r\n\t\t\t\tminj = j;\r\n\t\t\t}\r\n\t\t}\r\n\t\tp[i][minj] = 0.5;\r\n\t\tfor (min2j = j = 0, min = DBL_MAX; j < len; j++) {\r\n\t\t\tif (i == j || j == minj)\r\n\t\t\t\tcontinue;\r\n\t\t\tpl2 = g_list_nth_data(list, j);\r\n\t\t\tif ((dist = kml_dist(pl1, pl2)) < min) {\r\n\t\t\t\tmin = dist;\r\n\t\t\t\tmin2j = j;\r\n\t\t\t}\r\n\t\t}\r\n\t\tp[i][min2j] = 0.5;\r\n\t\tg_assert(min2j != minj);\r\n\t\tg_assert(i != min2j);\r\n\t}\r\n\r\n\treturn(p);\r\n}\r\n\r\ndouble **\r\nkml_migration_nearest(GList *list, enum maptop map)\r\n{\r\n\tdouble\t\t**p;\r\n\tdouble\t\t  dist, min;\r\n\tsize_t\t\t  i, j, len, minj;\r\n\tstruct kmlplace\t *pl1, *pl2;\r\n\r\n\tlen = (size_t)g_list_length(list);\r\n\tg_assert(len > 0);\r\n\tp = g_malloc0_n(len, sizeof(double *));\r\n\r\n\t/* \r\n\t * Special case the torus, which has a well-defined layout\r\n\t * between nodes, such that the next (\"right\") island, wrapping\r\n\t * around, gets the migrant.\r\n\t */\r\n\tif (MAPTOP_TORUS == map) {\r\n\t\tfor (i = 0; i < len; i++) {\r\n\t\t\tp[i] = g_malloc0_n(len, sizeof(double));\r\n\t\t\tp[i][(i + 1) % len] = 1.0;\r\n\t\t}\r\n\t\treturn(p);\r\n\t}\r\n\r\n\tfor (i = 0; i < len; i++) {\r\n\t\tpl1 = g_list_nth_data(list, i);\r\n\t\tp[i] = g_malloc0_n(len, sizeof(double));\r\n\t\tfor (minj = j = 0, min = DBL_MAX; j < len; j++) {\r\n\t\t\tif (i == j)\r\n\t\t\t\tcontinue;\r\n\t\t\tpl2 = g_list_nth_data(list, j);\r\n\t\t\tif ((dist = kml_dist(pl1, pl2)) < min) {\r\n\t\t\t\tmin = dist;\r\n\t\t\t\tminj = j;\r\n\t\t\t}\r\n\t\t}\r\n\t\tp[i][minj] = 1.0;\r\n\t}\r\n\r\n\treturn(p);\r\n}\r\n\r\ndouble **\r\nkml_migration_distance(GList *list, enum maptop map)\r\n{\r\n\tdouble\t\t**p;\r\n\tdouble\t\t  dist, sum;\r\n\tsize_t\t\t  i, j, len;\r\n\tstruct kmlplace\t *pl1, *pl2;\r\n\r\n\tlen = (size_t)g_list_length(list);\r\n\tg_assert(len > 0);\r\n\tp = g_malloc0_n(len, sizeof(double *));\r\n\tfor (i = 0; i < len; i++) {\r\n\t\tpl1 = g_list_nth_data(list, i);\r\n\t\tp[i] = g_malloc0_n(len, sizeof(double));\r\n\t\tfor (sum = 0.0, j = 0; j < len; j++) {\r\n\t\t\tif (i == j) {\r\n\t\t\t\tp[i][j] = 0.0;\r\n\t\t\t\tcontinue;\r\n\t\t\t}\r\n\t\t\tpl2 = g_list_nth_data(list, j);\r\n\t\t\tdist = kml_dist(pl1, pl2);\r\n\t\t\tp[i][j] = 1.0 / (dist * dist);\r\n\t\t\tsum += p[i][j];\r\n\t\t}\r\n\t\tfor (j = 0; j < len; j++) \r\n\t\t\tif (i != j)\r\n\t\t\t\tp[i][j] = p[i][j] / sum;\r\n\t}\r\n\r\n\treturn(p);\r\n}\r\n", "meta": {"hexsha": "adf305b5dcacb45a315a9348aa38727ed51b654f", "size": 14406, "ext": "c", "lang": "C", "max_stars_repo_path": "kml.c", "max_stars_repo_name": "kristapsdz/bmigrate", "max_stars_repo_head_hexsha": "0280a899564031a5a14af87d9264cd239a89851f", "max_stars_repo_licenses": ["0BSD"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2018-03-03T17:13:19.000Z", "max_stars_repo_stars_event_max_datetime": "2018-03-03T17:13:19.000Z", "max_issues_repo_path": "kml.c", "max_issues_repo_name": "kristapsdz/bmigrate", "max_issues_repo_head_hexsha": "0280a899564031a5a14af87d9264cd239a89851f", "max_issues_repo_licenses": ["0BSD"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "kml.c", "max_forks_repo_name": "kristapsdz/bmigrate", "max_forks_repo_head_hexsha": "0280a899564031a5a14af87d9264cd239a89851f", "max_forks_repo_licenses": ["0BSD"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 23.5008156607, "max_line_length": 76, "alphanum_fraction": 0.6065528252, "num_tokens": 4589, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.2720245392906821, "lm_q2_score": 0.028007521721541584, "lm_q1q2_score": 0.007618733192976121}}
{"text": "#include <stdio.h>\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_matrix.h>\n#include <gsl/gsl_odeiv.h>\n#include <gsl/gsl_odeiv2.h>\n\n#include <stdlib.h>\n#include <string.h>\n#include <stdbool.h>\n\n#include <time.h>\n#include <math.h>\n\n#include <GL/glut.h>\n#include <GL/gl.h>\n\n#include <unistd.h>\n#include <signal.h>\n#include <sys/wait.h>\n#include <sys/types.h>\n\n#define SLICE\t360\n\ntypedef struct _line_vertex line_vertex;\nstruct _line_vertex\n{\n\tfloat x1;\n\tfloat y1;\n\n\tfloat x2;\n\tfloat y2;\n};\n\nfloat text_x = 64.0f, text_y = 58.0f;\nconst float TRANS_VAL = 100.0f;\n\nuint32_t mouse_loc;\nint x, y;\n\nbool clicked = false;\nint pos_x, pos_y;\nint mov_x, mov_y;\nint click_x, click_y;\nint special_key;\n\nbool run = false;\n\nline_vertex vertices[9] = {\n\t{ 50.0f, 50.0f, 50.0f, 30.0f },\n\t{ 50.0f, 50.0f, 55.0f, 50.0f },\n\t{ 75.0f, 50.0f, 80.0f, 50.0f },\n\t{ 80.0f, 50.0f, 80.0f, 30.0f },\n\t{ 55.0f, 55.0f, 55.0f, 45.0f },\n\t{ 55.0f, 55.0f, 75.0f, 55.0f },\n\t{ 75.0f, 55.0f, 75.0f, 45.0f },\n\t{ 55.0f, 45.0f, 75.0f, 45.0f }\n};\n\nline_vertex pick_vertices[9] = {\n\t{ 45.0f, 25.0f, 45.0f, 65.0f },\n\t{ 45.0f, 25.0f, 85.0f, 25.0f },\n\t{ 45.0f, 65.0f, 85.0f, 65.0f },\n\t{ 85.0f, 25.0f, 85.0f, 65.0f }\n};\n\nline_vertex power_vertices[5] = {\n\t{ 40.0f, 50.0f, 40.0f, 60.0f },\n\t{ 50.0f, 50.0f, 30.0f, 50.0f },\n\t{ 45.0f, 45.0f, 35.0f, 45.0f },\n\t{ 40.0f, 45.0f, 40.0f, 35.0f }\n};\n\nline_vertex ground_vertices[5] = {\n\t{ 40.0f, 50.0f, 40.0f, 60.0f },\n\t{ 50.0f, 50.0f, 30.0f, 50.0f },\n\t{ 47.5f, 47.5f, 32.5f, 47.5f },\n\t{ 45.0f, 45.0f, 35.0f, 45.0f }\n};\n\nint *jac;\n\nint rhs (double t, const double y[], double f[], void *params_ptr);\n//int jacobian (double t, const double y[], double *dfdy, double dfdt[], void *params_ptr);\n\nvoid calc_differential_eq(void);\nvoid draw_differential_eq_plot(void);\nvoid draw_lattice(void);\nvoid draw_lattice2(void);\nvoid draw_volt_plot(void);\n\nvoid reshape(int w, int h);\n\ntypedef struct _xy_plot xy_plot;\nstruct _xy_plot\n{\n\tdouble x;\n\tdouble y;\n};\n\n//xy_plot plot_res[1001];\nxy_plot plot_res[100000001];\n//double volt_res[100000001];\n\nfloat resistance;\nfloat inductance;\nfloat voltage;\n\nint sub_window;\nint sub_window2;\n\nvoid sim_reshape(int w, int h)\n{\n    GLfloat n_range = 100.0f;\n\n    if(h == 0)\n        h = 1;\n\n    glViewport(0, 0, w, h);\n    glMatrixMode(GL_PROJECTION);\n    glLoadIdentity();\n\n\t// glOrtho(표기하고자 하는 최소 x값, 최대 x값, 화면상 나타는 최소 y, 최대 y, z는 관계없음)\n\t// 즉 내가 보고자 하는 x, y, z의 범위를 지정할 수 있음\n\tglOrtho(-0.000005, 0.000005, -0.7, 0.7, -1, 1);\n\n    glMatrixMode(GL_MODELVIEW);\n    glLoadIdentity();\n}\n\nvoid simulate(void)\n{\n    glClearColor(0.0, 0.0, 0.0, 1.0);\n    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);\n    glLoadIdentity();\n\n    glColor3f(1, 0, 0);\n\n    glBegin(GL_LINE_LOOP);\n    \tglVertex3f(100.0, 0.0, 0.0);\n        glVertex3f(-100.0, 0.0, 0.0);\n    glEnd();\n\n    glColor3f(0.0, 1.0, 0.0);\n\n    glBegin(GL_LINE_LOOP);\n        glVertex3f(0.0, 100.0, 0.0);\n        glVertex3f(0.0, -100.0, 0.0);\n    glEnd();\n\n    draw_differential_eq_plot();\n    draw_lattice();\n\n    glutSwapBuffers();\n}\n\nvoid sim_reshape2(int w, int h)\n{\n    GLfloat n_range = 100.0f;\n\n    if(h == 0)\n        h = 1;\n\n    glViewport(0, 0, w, h);\n    glMatrixMode(GL_PROJECTION);\n    glLoadIdentity();\n\n\tglOrtho(-0.000005, 0.000005, -2000000, 500000, -1, 1);\n\n    glMatrixMode(GL_MODELVIEW);\n    glLoadIdentity();\n}\n\nvoid simulate2(void)\n{\n    glClearColor(0.0, 0.0, 0.0, 1.0);\n    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);\n    glLoadIdentity();\n\n    glColor3f(1, 0, 0);\n\n    glBegin(GL_LINE_LOOP);\n    \tglVertex3f(100.0, 0.0, 0.0);\n        glVertex3f(-100.0, 0.0, 0.0);\n    glEnd();\n\n    glColor3f(0.0, 1.0, 0.0);\n\n    glBegin(GL_LINE_LOOP);\n        glVertex3f(0.0, 500000.0, 0.0);\n        glVertex3f(0.0, -2000000.0, 0.0);\n    glEnd();\n\n    draw_volt_plot();\n    draw_lattice2();\n\n    glutSwapBuffers();\n}\n\nvoid keyboard_handler(unsigned char key, int x, int y)\n{\n\tint pid;\n\tint i, status;\n\n\t// fork -> execve\n\t// OpenGL -> GPU\n#if 0\n\tchar *argv[5] = {\"print_simulation\"};\n\tchar *envp[] = {0};\n\tchar volt[64] = {0};\n\tchar coil[64] = {0};\n\tchar resist[64] = {0};\n#endif\n\n\tswitch(key)\n\t{\n\t\tcase 's':\n\t\t\tprintf(\"Simulation Preparation\\n\");\n\t\t\tprintf(\"저항값 입력: \");\n\t\t\tscanf(\"%f\", &resistance);\n\t\t\tprintf(\"인덕턴스값 입력: \");\n\t\t\tscanf(\"%f\", &inductance);\n\t\t\tprintf(\"입력 전원값 입력: \");\n\t\t\tscanf(\"%f\", &voltage);\n\n\t\t\tprintf(\"R = %f, L = %f, V = %f\\n\", resistance, inductance, voltage);\n\n\t\t\tcalc_differential_eq();\n\t\t\trun = true;\n\t\t\tbreak;\n\t\tcase 'r':\n\t\t\tprintf(\"Run Simulation\\n\");\n\n#if 0\n\t\t\tpid = fork();\n\n\t\t\tif (pid > 0)\n\t\t\t{\n\t\t\t\tprintf(\"wait for simulation finished\\n\");\n\t\t\t\twait(&status);\n\t\t\t}\n\t\t\telse if (pid == 0)\n\t\t\t{\n\t\t\t\texecve(\"./print_simulation\", argv, envp);\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tperror(\"fork() \");\n\t\t\t\texit(-1);\n\t\t\t}\n#endif\n\n\t\t\tsub_window = glutCreateWindow(\"Current i(t)\");\n\n\t\t\tglutDisplayFunc(simulate);\n\t\t\tglutReshapeFunc(sim_reshape);\n\n\t\t\tsub_window2 = glutCreateWindow(\"Voltage V(t)\");\n\n\t\t\tglutDisplayFunc(simulate2);\n\t\t\tglutReshapeFunc(sim_reshape2);\n\t\t\tbreak;\n\t\tcase 't':\n\t\t\tprintf(\"Termination\\n\");\n\t\t\tglutDestroyWindow(sub_window);\n\t\t\tglutDestroyWindow(sub_window2);\n\t\t\tbreak;\n\t\tcase 27:\n\t\t\texit(1);\n\t\t\tbreak;\n\t}\n}\n\nvoid on_mouse(int button, int state, int x, int y)\n{\n\tspecial_key = glutGetModifiers();\n\n\tif (button == GLUT_LEFT_BUTTON & state == GLUT_DOWN)\n\t{\n\t\tif (clicked == false)\n\t\t{\n\t\t\tprintf(\"Click - Down\\n\");\n\t\t\tclick_x = x;\n\t\t\tclick_y = y;\n\t\t\tclicked = true;\n\n\t\t\tprintf(\"click_x = %d, click_y = %d\\n\", click_x, click_y);\n\t\t}\n\t}\n\n\tif (button == GLUT_LEFT_BUTTON & state == GLUT_UP)\n\t{\n\t\tprintf(\"Click - Up\\n\");\n\t\tclicked = false;\n\t}\n\n\tint window_width = glutGet(GLUT_WINDOW_WIDTH);\n\tint window_height = glutGet(GLUT_WINDOW_HEIGHT);\n\n\tGLbyte color[4];\n\tGLfloat depth;\n\tGLuint index;\n\n\tglReadPixels(x, window_height - y - 1, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, color);\n\tglReadPixels(x, window_height - y - 1, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &depth);\n\tglReadPixels(x, window_height - y - 1, 1, 1, GL_STENCIL_INDEX, GL_UNSIGNED_INT, &index);\n\n\tprintf(\"Clicked on pixel %d, %d, color %02hhx%02hhx%02hhx%02hhx, depth %f, stencil index %u\\n\",\n\t\t\tx, y, color[0], color[1], color[2], color[3], depth, index);\n\n}\n\nvoid drag_mouse(int x, int y)\n{\n\tpos_x = x;\n\tpos_y = y;\n\n\tspecial_key = glutGetModifiers();\n\n\tif (clicked == true)\n\t{\n\t\tprintf(\"clicked!\\n\");\n\n\t\tmov_x = (click_x - pos_x) / 3;\n\t\tmov_y = (click_y - pos_y) / 2.5;\n\n\t\tclick_x = pos_x;\n\t\tclick_y = pos_y;\n\n\t\tprintf(\"mov_x = %d, mov_y = %d\\n\", mov_x, mov_y);\n\n\t\tint i;\n\n\t\tfor (i = 0; i < 8; i++)\n\t\t{ \n\t\t\tvertices[i].x1 -= mov_x;\n\t\t\tvertices[i].x2 -= mov_x;\n\t\t\tvertices[i].y1 += mov_y;\n\t\t\tvertices[i].y2 += mov_y;\n\t\t}\n\n\t\tfor (i = 0; i < 4; i++)\n\t\t{ \n\t\t\tpick_vertices[i].x1 -= mov_x;\n\t\t\tpick_vertices[i].x2 -= mov_x;\n\t\t\tpick_vertices[i].y1 += mov_y;\n\t\t\tpick_vertices[i].y2 += mov_y;\n\t\t}\n\n\t\tfor (i = 0; i < 4; i++)\n\t\t{\n\t\t\tpower_vertices[i].x1 -= mov_x;\n\t\t\tpower_vertices[i].x2 -= mov_x;\n\t\t\tpower_vertices[i].y1 += mov_y;\n\t\t\tpower_vertices[i].y2 += mov_y;\n\t\t}\n\n\t\tfor (i = 0; i < 4; i++)\n\t\t{\n\t\t\tground_vertices[i].x1 -= mov_x;\n\t\t\tground_vertices[i].x2 -= mov_x;\n\t\t\tground_vertices[i].y1 += mov_y;\n\t\t\tground_vertices[i].y2 += mov_y;\n\t\t}\n\n\t\ttext_x -= mov_x;\n\t\ttext_y += mov_y;\n\n\t\tglutPostRedisplay();\n\t}\n}\n\nvoid drawString (char *s)\n{\n\tunsigned int i;\n\n\tfor (i = 0; i < strlen (s); i++)\n\t\tglutBitmapCharacter (GLUT_BITMAP_HELVETICA_10, s[i]);\n}\n\nvoid drawStringBig (char *s)\n{\n\tunsigned int i;\n\n\tfor (i = 0; i < strlen (s); i++)\n\t\tglutBitmapCharacter (GLUT_BITMAP_HELVETICA_18, s[i]);\n}\n\nvoid draw_outline(void)\n{\n\tint i;\n\n\tglColor3f(0, 1, 0);\n\n\tglBegin(GL_LINES);\n\t\tfor (i = 0; i < 8; i++)\n\t\t{\n\t\t\tglVertex2f(pick_vertices[i].x1, pick_vertices[i].y1);\n\t\t\tglVertex2f(pick_vertices[i].x2, pick_vertices[i].y2);\n\t\t}\n\tglEnd();\n}\n\nvoid draw_inductance_outline(void)\n{\n\tint i;\n\n\tglColor3f(0, 1, 0);\n\n\tglBegin(GL_LINES);\n\t\tfor (i = 0; i < 4; i++)\n\t\t{\n\t\t\tglVertex2f(pick_vertices[i].x1 + 50.0f, pick_vertices[i].y1);\n\t\t\tglVertex2f(pick_vertices[i].x2 + 50.0f, pick_vertices[i].y2);\n\t\t}\n\tglEnd();\n}\n\nvoid draw_resistance(void)\n{\n\tint i;\n\tstatic char label[100];\n\n\tglColor3f(1, 0, 1);\n\n\tglBegin(GL_LINES);\n\t\tfor (i = 0; i < 8; i++)\n\t\t{\n\t\t\tglVertex2f(vertices[i].x1, vertices[i].y1);\n\t\t\tglVertex2f(vertices[i].x2, vertices[i].y2);\n\t\t}\n\tglEnd();\n\n\tsprintf (label, \"R\");\n\tglRasterPos2f (text_x, text_y);\n\tdrawStringBig (label);\n}\n\nvoid draw_inductance(void)\n{\n\tint i;\n\tstatic char label[100];\n\n\tglColor3f(1, 0, 1);\n\n\tglBegin(GL_LINES);\n\t\tfor (i = 0; i < 8; i++)\n\t\t{\n\t\t\tglVertex2f(vertices[i].x1 + 50.0f, vertices[i].y1);\n\t\t\tglVertex2f(vertices[i].x2 + 50.0f, vertices[i].y2);\n\t\t}\n\tglEnd();\n\n\tsprintf (label, \"L\");\n\tglRasterPos2f (text_x + 50.0f, text_y);\n\tdrawStringBig (label);\n}\n\nvoid draw_power_outline(void)\n{\n\tint i;\n\n\tglColor3f(0, 1, 0);\n\n\tglBegin(GL_LINES);\n\t\tfor (i = 0; i < 4; i++)\n\t\t{\n\t\t\tglVertex2f(pick_vertices[i].x1 - 75.0f, pick_vertices[i].y1 + 20.0f);\n\t\t\tglVertex2f(pick_vertices[i].x2 - 75.0f, pick_vertices[i].y2 + 20.0f);\n\t\t}\n\tglEnd();\n}\n\nvoid draw_power(void)\n{\n\tint i;\n\tstatic char label[100];\n\n\tglColor3f(1, 0, 1);\n\n\tglBegin(GL_LINES);\n\t\tfor (i = 0; i < 4; i++)\n\t\t{\n\t\t\tglVertex2f(power_vertices[i].x1 - 50.0f, power_vertices[i].y1 + 15.0f);\n\t\t\tglVertex2f(power_vertices[i].x2 - 50.0f, power_vertices[i].y2 + 15.0f);\n\t\t}\n\tglEnd();\n\n\tsprintf (label, \"V\");\n\tglRasterPos2f (text_x - 70.0f, text_y + 20.0f);\n\tdrawStringBig (label);\n}\n\nvoid draw_ground_outline(void)\n{\n\tint i;\n\n\tglColor3f(0, 1, 0);\n\n\tglBegin(GL_LINES);\n\t\tfor (i = 0; i < 4; i++)\n\t\t{\n\t\t\tglVertex2f(pick_vertices[i].x1 - 75.0f, pick_vertices[i].y1 - 20.0f);\n\t\t\tglVertex2f(pick_vertices[i].x2 - 75.0f, pick_vertices[i].y2 - 20.0f);\n\t\t}\n\tglEnd();\n}\n\nvoid draw_ground(void)\n{\n\tint i;\n\tstatic char label[100];\n\n\tglColor3f(1, 0, 1);\n\n\tglBegin(GL_LINES);\n\t\tfor (i = 0; i < 4; i++)\n\t\t{\n\t\t\tglVertex2f(ground_vertices[i].x1 - 50.0f, ground_vertices[i].y1 - 30.0f);\n\t\t\tglVertex2f(ground_vertices[i].x2 - 50.0f, ground_vertices[i].y2 - 30.0f);\n\t\t}\n\tglEnd();\n\n\tsprintf (label, \"GND\");\n\tglRasterPos2f (text_x - 70.0f, text_y - 30.0f);\n\tdrawStringBig (label);\n}\n\n\n\nvoid display(void)\n{\n\tglClearColor(0.0, 0.0, 0.0, 1.0);\n\tglClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);\n\tglLoadIdentity();\n\n\tglColor3f(1, 0, 0);\n\n\tglBegin(GL_LINE_LOOP);\n\tglVertex3f(100.0, 0.0, 0.0);\n        glVertex3f(-100.0, 0.0, 0.0);\n        glEnd();\n\n        glColor3f(0.0, 1.0, 0.0);\n\n        glBegin(GL_LINE_LOOP);\n        glVertex3f(0.0, 100.0, 0.0);\n        glVertex3f(0.0, -100.0, 0.0);\n    glEnd();\n\n\tdraw_resistance();\n\tdraw_outline();\n\n\tdraw_inductance();\n\tdraw_inductance_outline();\n\n\tdraw_power();\n\tdraw_power_outline();\n\n\tdraw_ground();\n\tdraw_ground_outline();\n\n#if 0\n\tif (run)\n\t{\n\t\tdraw_differential_eq_plot();\n\t}\n\n\tdraw_lattice();\n#endif\n\n\tglutSwapBuffers();\n}\n\nvoid reshape(int w, int h)\n{\n    GLfloat n_range = 100.0f;\n\n    if(h == 0)\n        h = 1;\n\n    glViewport(0, 0, w, h);\n    glMatrixMode(GL_PROJECTION);\n    glLoadIdentity();\n\n#if 0\n    if(w <= h)\n        glOrtho(-n_range, n_range, -n_range * h / w, n_range * h / w, -n_range, n_range);\n    else\n        glOrtho(-n_range * w / h, n_range * w / h, -n_range, n_range, -n_range, n_range);\n#endif\n\n\t//glOrtho(-10, 10, -0.5, 0.5, -1, 1);\n\tglOrtho(-100, 100, -100, 100, 1.0, -1.0);\n\n    glMatrixMode(GL_MODELVIEW);\n    glLoadIdentity();\n}\n\nint calc_vertices_num(void)\n{\n\tdouble tmin = 0.0, tmax = 10.0, delta_t = 0.01;\n\treturn (tmax - tmin) / delta_t;\n}\n\nvoid calc_differential_eq(void)\n{\n    int dim = 1;\n\n\tgsl_odeiv2_system sys = {rhs, NULL, dim, NULL};  \n\tgsl_odeiv2_driver * d = gsl_odeiv2_driver_alloc_y_new (&sys, gsl_odeiv2_step_rkf45, 1e-6, 1e-6, 0.0);\n\n\tint cnt = 0;\n\n\tdouble i;\n    double x0 = 0.0,  xf = 10.0;\n    double x = x0;\n    //double y[1] = { 0.5 };\n    double y[1] = { 0.0 };\n\tdouble delta = 0.0000001;\n\n\tfor (i = 0; i <= xf; i += delta)\n    {\n        double xi = x0 + i * (xf-x0) / xf;\n        int status = gsl_odeiv2_driver_apply (d, &x, xi, y);\n\n        if (status != GSL_SUCCESS)\n        {\n            printf (\"error, return value=%d\\n\", status);\n            break;\n        }\n\n\t\tplot_res[cnt].x = x;\n\t\tplot_res[cnt].y = y[0];\n\n\t\t//volt_res[cnt] = y[0] * (resistance / inductance);\n\n\t\tif (cnt < 1001)\n\t\t{\n       \t\tprintf (\"%.8e %.8e\\n\", plot_res[cnt].x, plot_res[cnt].y);\n\t\t}\n\n\t\tcnt++;\n    }\n\n\tprintf(\"Finish Calc\\n\");\n\n    gsl_odeiv2_driver_free (d);\n\n#if 0\n    const gsl_odeiv_step_type *type_ptr = gsl_odeiv_step_rkf45;\n\n    gsl_odeiv_step *step_ptr = gsl_odeiv_step_alloc (type_ptr, dimension);\n    gsl_odeiv_control *control_ptr = gsl_odeiv_control_y_new (eps_abs, eps_rel);\n    gsl_odeiv_evolve *evolve_ptr = gsl_odeiv_evolve_alloc (dimension);\n\n    gsl_odeiv_system my_system;\t/* structure with the rhs function, etc. */\n\n    double mu = 10;\t\t/* parameter for the diffeq */\n    double y[2];\t\t\t/* current solution vector */\n\n    double t, t_next;\t\t/* current and next independent variable */\n    double tmin, tmax, delta_t;\t/* range of t and step size for output */\n\n    double h = 1e-6;\t\t/* starting step size for ode solver */\n\n\tint cnt = 0;\n\tint vertex_num = calc_vertices_num();\n\n    my_system.function = rhs;\t/* the right-hand-side functions dy[i]/dt */\n    my_system.jacobian = NULL;\n    my_system.dimension = dimension;\t/* number of diffeq's */\n    my_system.params = NULL;\n\n    tmin = 0.;\t\t\t/* starting t value */\n    tmax = 10.;\t\t\t/* final t value */\n    delta_t = 0.01;\n\n    y[1] = 0.5;\t\t\t/* initial x value */\n\n    t = tmin;             /* initialize t */\n\n    for (t_next = tmin + delta_t; t_next <= tmax; t_next += delta_t)\n    {\n        while (t < t_next)\t/* evolve from t to t_next */\n        {\n            gsl_odeiv_evolve_apply (evolve_ptr, control_ptr, step_ptr,\n                                    &my_system, &t, t_next, &h, y);\n        }\n\n\t\tplot_res[cnt].x = t;\n\t\tplot_res[cnt].y = y[0];\n        printf (\"%.5e %.5e %.5e\\n\", t, plot_res[cnt].x, plot_res[cnt].y); /* print at t=t_next */\n\n\t\tcnt++;\n    }\n\n    gsl_odeiv_evolve_free (evolve_ptr);\n    gsl_odeiv_control_free (control_ptr);\n    gsl_odeiv_step_free (step_ptr);\n#endif\n}\n\nvoid draw_lattice(void)\n{\n\tint i;\n\tfloat lattice = 0.000001;\n\tchar buf[64] = {0};\n\n\tglColor3f(1, 1, 0);\n\tglBegin(GL_LINES);\n\t\tfor (i = 1; i <= 10; i++)\n\t\t{\n\t\t\tglVertex2f(i * 0.000001, -0.01);\n\t\t\tglVertex2f(i * 0.000001, 0.01);\n\t\t}\n\tglEnd();\n\n\tfor (i = 1; i <= 10; i++)\n\t{\n\t\tsprintf(buf, \"%f\", lattice * i);\n\t    glRasterPos2f (lattice * i - 0.0000005, -0.05);\n\t    drawStringBig (buf);\n\t}\n\n\tglBegin(GL_LINES);\n\t\tfor (i = 1; i <= 10; i++)\n\t\t{\n\t\t\tglVertex2f(-0.0000002, 0.1 * i);\n\t\t\tglVertex2f(0.0000002, 0.1 * i);\n\t\t}\n\tglEnd();\n\n\tfor (i = 1; i <= 10; i++)\n\t{\n\t\tsprintf(buf, \"%.1f\", 0.1 * i);\n\t    glRasterPos2f (-0.0000004, 0.1 * i - 0.05);\n\t    drawStringBig (buf);\n\t}\n}\n\nvoid draw_differential_eq_plot(void)\n{\n\tstatic char label[100];\n\n\tfloat x = 0, x2 = 0, y2, cx, cy;\n\tfloat tmp;\n\tint cache = 0;\n\tint i;\n\n\tglColor3f(0, 1, 1);\n\tglBegin(GL_LINES);\n\t//for(; ; t += step)\n\tfor (i = 0; i < 100000000; i++)\n\t{\n\t\tx2 = plot_res[i].x;\n\t\ty2 = plot_res[i].y;\n\n\t\tif(cache)\n\t\t{\n\t\t\tglVertex2f(cx, cy);\t// 이전값\n\t\t\tglVertex2f(x2, y2);\t// 현재값\n\t\t}\n\n\t\tcache = 1;\n\t\tcx = x2;\n\t\tcy = y2;\n\t\t//printf(\"t = %f, y2 = %f\\n\", x2, y2);\n\t}\n\tglEnd();\n\n\tsprintf (label, \"i(t)\");\n\t// -0.000005\n    glRasterPos2f (-0.0000045, 0.0000045);\n    drawStringBig (label);\n}\n\nvoid draw_lattice2(void)\n{\n\tint i;\n\tfloat lattice = 0.000001;\n\tchar buf[64] = {0};\n\n\tglColor3f(1, 0, 0);\n\tglBegin(GL_LINES);\n\t\tfor (i = 1; i <= 10; i++)\n\t\t{\n\t\t\tglVertex2f(i * 0.000001, -20000);\n\t\t\tglVertex2f(i * 0.000001, 20000);\n\t\t}\n\tglEnd();\n\n\tfor (i = 1; i <= 10; i++)\n\t{\n\t\tsprintf(buf, \"%f\", lattice * i);\n\t    glRasterPos2f (lattice * i - 0.0000005, 50000);\n\t    drawStringBig (buf);\n\t}\n\n\tglBegin(GL_LINES);\n\t\tfor (i = 1; i <= 10; i++)\n\t\t{\n\t\t\tglVertex2f(-0.0000002, -200000 * i);\n\t\t\tglVertex2f(0.0000002, -200000 * i);\n\t\t}\n\tglEnd();\n\n\tfor (i = 1; i <= 10; i++)\n\t{\n\t\tsprintf(buf, \"%d\", -200000 * i);\n\t    glRasterPos2f (-0.0000015, -200000 * i);\n\t    drawStringBig (buf);\n\t}\n\n}\n\nvoid draw_volt_plot(void)\n{\n\tstatic char label[100];\n\n\tfloat x = 0, x2 = 0, y2, cx, cy;\n\tfloat tmp;\n\tint cache = 0;\n\tint i;\n\n\tglColor3f(1, 1, 0);\n\tglBegin(GL_LINES);\n\t//for(; ; t += step)\n\tfor (i = 0; i < 100000000; i++)\n\t{\n\t\tx2 = plot_res[i].x;\n\t\ty2 = plot_res[i].y * (-resistance / inductance);\n\n\t\tif(cache)\n\t\t{\n\t\t\tglVertex2f(cx, cy);\t// 이전값\n\t\t\tglVertex2f(x2, y2);\t// 현재값\n\t\t}\n\n\t\tcache = 1;\n\t\tcx = x2;\n\t\tcy = y2;\n\t\t//printf(\"t = %f, y2 = %f\\n\", x2, y2);\n\t}\n\tglEnd();\n\n\tsprintf (label, \"V(t)\");\n\t// -0.000005\n    glRasterPos2f (-0.0000045, 0.000004);\n    drawStringBig (label);\n}\n\nint main (int argc, char **argv)\n{\n\tglutInit(&argc, argv);\n\tglutInitDisplayMode(GLUT_DOUBLE);\n\tglutInitWindowSize(800, 800);\n\tglutInitWindowPosition(0, 0);\n\tglutCreateWindow(\"Digital Signal Processing\");\n\n\tprintf(\"저항 1000, 인덕터: 0.0003, 전압: 5V\\n\");\n\n\tglutDisplayFunc(display);\n\tglutReshapeFunc(reshape);\n\tglutMouseFunc(on_mouse);\n\tglutMotionFunc(drag_mouse);\n\t// 새롭게 추가된 요것은 키보드 입력을 처리하는 콜백 등록 함수\n\tglutKeyboardFunc(keyboard_handler);\n\tglutMainLoop();\n\n    return 0;\n}\n\n/*************************** rhs ****************************/\n/* \n   x' = v                  ==>  dy[0]/dt = f[0] = y[1]\n   v' = -x + \\mu v (1-x^2) ==>  dy[1]/dt = f[1] = -y[0] + mu*y[1]*(1-y[0]*y[0])\n  \n   x''(t) + x'(t) + x(t) = 0\n   x''(t) = -x'(t) - x(t)\n\n   x' = v            ===> dy[0]/dt = f[0] = y[1]\n   v' = -v - x       ===> dy[1]/dt = f[1] = -y[1] - y[0]\n*/\n\n// https://www.wolframalpha.com/input/?i=y%27%27+%2B+y%27+%2B+y+%3D+0%2C+y%280%29+%3D+1%2C+y%27%280%29+%3D+0, y(0) = 1\n// https://www.wolframalpha.com/input/?i=%28sqrt%283%29+*+sin%28sqrt%283%29+%2F+2%29+%2B+3+*+cos%28sqrt%283%29+%2F+2%29%29+%2F+%283+*+sqrt%28e%29%29, y(1)\n// (sqrt(3) * sin(sqrt(3) / 2) + 3 * cos(sqrt(3) / 2)) / (3 * sqrt(e)), y(1) = 0.6597001...\nint\nrhs (double t, const double y[], double f[], void *params_ptr)\n{\n#if 0\n\tf[0] = y[1];\n\tf[1] = -y[1] - 9 * y[0];\n#endif\n\n\tf[0] =  -(resistance / inductance) * y[0] + voltage / inductance;\n\n    return GSL_SUCCESS;\t\t/* GSL_SUCCESS defined in gsl/errno.h as 0 */\n}\n\n#if 0\n\n주석: 현재 아래 상황은 방전 상황입니다.\n      또한 현재 코드는 충전 상황입니다.\n\t  두 가지 버전으로 작성이 필요함.\n\nV = iR + L * di /dt\n초기조건 V_L(t) | (t=0) ===> V_L(0) = 0V\n\nV * (1 / L) = i(t) * (R / L) + i`(t)\n\nP(x) = R / L\n\nmu = C * exp^(int P(x)dx)\n\nmu = C * exp^(R/L)t\n\nd (mu * i(t)) / dt = (R/L) exp^(R/L)t * i(t) + exp^(R/L)t * i`(t)\n\nint d(mu * i(t)) / dt = mu * i(t) = c\n\nexp^(R/L)t * i(t) = C\n\ni(t) = C * exp^(-R/L)t\n\ni(t) | (t=0) = 0.5A ===> C = 0.5\n\ni(t) = 0.5 * exp^(-R/L)t\nV(t) = L di / dt\n     = L * 0.5 * (-R/L) * exp^(-R/L)t\n\t-(resistance / inductance)\n#endif\n", "meta": {"hexsha": "8ce56dd8b6025328afb533606f2c63516f376c74", "size": 18434, "ext": "c", "lang": "C", "max_stars_repo_path": "ch6/src/main/rl_circuit_simulation.c", "max_stars_repo_name": "EDDI-RobotAcademy/E4DS-DSP-Basic-Mathematics", "max_stars_repo_head_hexsha": "245385b79807c25081dfe2014c72843226716f92", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-10-22T00:39:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-22T00:39:04.000Z", "max_issues_repo_path": "ch6/src/main/rl_circuit_simulation.c", "max_issues_repo_name": "EDDI-RobotAcademy/E4DS-DSP-Basic-Mathematics", "max_issues_repo_head_hexsha": "245385b79807c25081dfe2014c72843226716f92", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ch6/src/main/rl_circuit_simulation.c", "max_forks_repo_name": "EDDI-RobotAcademy/E4DS-DSP-Basic-Mathematics", "max_forks_repo_head_hexsha": "245385b79807c25081dfe2014c72843226716f92", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2022-03-19T01:22:06.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-19T01:22:06.000Z", "avg_line_length": 19.7577706324, "max_line_length": 154, "alphanum_fraction": 0.588043832, "num_tokens": 7142, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.44939263446475963, "lm_q2_score": 0.015663645351566797, "lm_q1q2_score": 0.007039126849862289}}
{"text": "/* usleep, inet_aton */\n#define _GNU_SOURCE\n\n#include <stdio.h>\n#include <time.h>\n#include <stdlib.h>\n#include <string.h>\n#include <unistd.h>\n#include <pthread.h>\n#include <fcntl.h>\n#include <assert.h>\n#include <sys/types.h>\n#include <sys/socket.h>\n#include <netinet/in.h>\n#include <arpa/inet.h>\n#include <gsl/gsl_matrix.h>\n#include <gsl/gsl_vector.h>\n#include <gsl/gsl_blas.h>\n#include \"agent.h\"\n\n/*\n * Grafo con 6 nodi -> dmax = 5\n * devo prendere una frequenza  fs > 2*dmax/pi\n * e quindi una ts < pi/(2*dmax) = 0.314 sec\n * prendiamo h di runge kutta = ts\n */\n\nint _agents_number = 6;\n\nfloat h = 0.05;\n\nint N = 32768;\n\ndouble x0[6] = {0.00, 0.00, 0.00, 0.00, 0.00, 0.00};\n\ndouble z0[6] = {1.00, 0.00, 0.00, 0.00, 0.00, 0.00};\n\ntypedef enum {\n    log_debug = 1,\n    log_normal = 2,\n    log_details = 4\n} log_t;\n\nint log_level = log_normal;\n\n/*int log_level = log_debug | log_normal | log_details;*/\n\nstruct msg_t {\n    int msg_id;\n    int msg_time;\n    float msg_x;\n    float msg_z;\n};\n\nstruct agent_t {\n    int agent_id;\n    int agent_x;\n    int agent_z;\n    pthread_mutex_t agent_mutex;\n};\n\ntypedef struct msg_t *msg;\n\nstatic pthread_mutex_t agent_class_mutex;\nstatic int agentObjectsNumber = 0;\n\nstatic void initClassAgent() {\n    pthread_mutex_init(&(agent_class_mutex), NULL);\n}\n\nstatic void cleanClassAgent() {\n    pthread_mutex_destroy(&(agent_class_mutex));\n\n}\n\nagent allocAgent() {\n\n    agent agent_M_;\n\n    if (agentObjectsNumber == 0) initClassAgent();\n\n    agentObjectsNumber++;\n\n    agent_M_ = (agent) malloc(sizeof (struct agent_t));\n\n    agent_M_->agent_id = 0;\n    pthread_mutex_init(&(agent_M_->agent_mutex), NULL);\n\n    return agent_M_;\n\n}\n\nvoid freeAgent(agent _F_agent) {\n\n    pthread_mutex_destroy(&(_F_agent->agent_mutex));\n\n    free(_F_agent);\n\n    _F_agent = NULL;\n\n    agentObjectsNumber--;\n\n    if (agentObjectsNumber == 0) cleanClassAgent();\n}\n\nvoid setIdAgent(agent agent_p) {\n    agent_p = NULL;\n}\n\nvoid getIdAgent(agent agent_p) {\n    agent_p = NULL;\n}\n\nvoid setAgentState(agent agent_p) {\n    agent_p = NULL;\n}\n\nvoid getAgentState(agent agent_p) {\n    agent_p = NULL;\n}\n\nstatic int connectTo(char *_ip_address_remote, int _ip_port_remote) {\n\n    int socket_M_;\n\n    struct sockaddr_in sockaddr_in_remote_;\n\n    memset(&sockaddr_in_remote_, 0, sizeof (sockaddr_in_remote_));\n    sockaddr_in_remote_.sin_family = AF_INET;\n    sockaddr_in_remote_.sin_port = htons(_ip_port_remote);\n    inet_aton(_ip_address_remote, &(sockaddr_in_remote_.sin_addr));\n\n    if ((socket_M_ = socket(AF_INET, SOCK_STREAM, 0)) == -1) {\n        perror(\"connectTo: socket() Error\\n\");\n        exit(1);\n    }\n\n    while (connect(socket_M_, (struct sockaddr *) & sockaddr_in_remote_, sizeof (struct sockaddr_in)) == -1) {\n        perror(\"connectTo: connect() Error\\n\");\n        exit(1);\n    }\n\n    return socket_M_;\n}\n\nstatic void sendMsg(int _socket, msg _msg) {\n\n    if (send(_socket, _msg, sizeof (struct msg_t), 0) == -1) {\n        perror(\"sendMsg: send() Error\\n\");\n        exit(1);\n    };\n}\n\nstatic msg recvMsg(int _socket) {\n\n    msg _M_msg = (struct msg_t *) malloc(sizeof (struct msg_t));\n\n    if (recv(_socket, _M_msg, sizeof (struct msg_t), 0) == -1) {\n        perror(\"recvMsg: recv() Error\\n\");\n        exit(1);\n    }\n\n    return _M_msg;\n}\n\nparametri_agent allocParamAgent(int _identity, char *_agent_router_ip, int _port_agent_to_router, int _port_router_to_agent) {\n\n    parametri_agent _M_parametri_agent = (parametri_agent) malloc(sizeof (struct parametri_agent_t));\n\n    _M_parametri_agent->identity = _identity;\n    _M_parametri_agent->agent_router_ip = _agent_router_ip;\n    _M_parametri_agent->port_router_to_agent = _port_router_to_agent;\n    _M_parametri_agent->port_agent_to_router = _port_agent_to_router;\n\n    return _M_parametri_agent;\n}\n\nvoid *runAgent(void *_parametri_agent) {\n\n    parametri_agent _parametri = (parametri_agent) _parametri_agent;\n\n    int _identity = _parametri->identity;\n\n    char *_agent_router_ip;\n    int _port_router_to_agent;\n    int _port_agent_to_router;\n\n    int agent_to_router_socket_;\n    int router_to_agent_socket_;\n\n    int _agent_neighborhood;\n\n    int i, c;\n\n    msg _M_msg_in, _M_msg_out;\n\n    double x[4] = {0.00, 0.00, 0.00, 0.00};\n    double z[4] = {0.00, 0.00, 0.00, 0.00};\n    double r[4] = {0.00, 0.00, 0.00, 0.00};\n    double sx[4] = {0.00, 0.00, 0.00, 0.00};\n    double sz[4] = {0.00, 0.00, 0.00, 0.00};\n\n    FILE *agent_log;\n    char agent_log_file_name[FILENAME_MAX];\n\n    gsl_matrix *_adjacency_matrix;\n    FILE *agent_adjacency_matrix_file;\n\n    _adjacency_matrix = gsl_matrix_alloc(_agents_number, _agents_number);\n    agent_adjacency_matrix_file = fopen(\"adjacency_matrix.txt\", \"r\");\n    gsl_matrix_fscanf(agent_adjacency_matrix_file, _adjacency_matrix);\n    fclose(agent_adjacency_matrix_file);\n\n    /*\n     * Apertura del file di log\n     */\n\n    sprintf(agent_log_file_name, \"agent_%d.log\", _identity);\n\n    agent_log = fopen(agent_log_file_name, \"w\");\n\n    if (agent_log == NULL) {\n        perror(\"Errore apertura file: \\\"agent.log\\\"\\n\");\n        exit(1);\n    };\n\n    setbuf(agent_log, NULL);\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: Open log\\n\", _identity);\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: Parametri di invocazione:\\n\", _identity);\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: > _identity = %d\\n\", _identity, _identity);\n\n    _agent_router_ip = _parametri->agent_router_ip;\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: > _agent_router_ip = %s\\n\", _identity, _agent_router_ip);\n\n    _port_agent_to_router = _parametri->port_agent_to_router;\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: > _port_agent_to_router = %d\\n\", _identity, _port_agent_to_router);\n\n    _port_router_to_agent = _parametri->port_router_to_agent;\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: > _port_router_to_agent = %d\\n\", _identity, _port_router_to_agent);\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: Memoria:\\n\", _identity);\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: > h = %2.8g\\n\", _identity, h);\n\n    /*\n     * Calcolo del numero di agent vicini attraverso l'analisi della adjacency_matrix\n     */\n\n    _agent_neighborhood = 0;\n\n    for (i = 0; i < _agents_number; i++) {\n\n        _agent_neighborhood = _agent_neighborhood + (int) gsl_matrix_get(_adjacency_matrix, i, _identity - 1);\n\n        if (log_level & log_debug) fprintf(agent_log, \"A%d: > gsl_matrix_get(%d,%d) = %d\\n\", _identity, i, _identity - 1, (int) gsl_matrix_get(_adjacency_matrix, i, _identity - 1));\n    };\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: > _agent_neighborhood = %d\\n\", _identity, _agent_neighborhood);\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: > _agents_number = %d\\n\", _identity, _agents_number);\n\n    _M_msg_out = (struct msg_t *) malloc(sizeof (struct msg_t));\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: > alloc(msg_out)\\n\", _identity);\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: Socket:\\n\", _identity);\n\n    agent_to_router_socket_ = connectTo(_agent_router_ip, _port_agent_to_router);\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: > connectTo(%s,%d)\\n\", _identity, _agent_router_ip, _port_agent_to_router);\n\n    router_to_agent_socket_ = connectTo(_agent_router_ip, _port_router_to_agent);\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: > connectTo(%s,%d)\\n\", _identity, _agent_router_ip, _port_router_to_agent);\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: Signal:\\n\", _identity);\n\n    /*\n     * Imposto l'identità dei messaggi in output\n     */\n\n    _M_msg_out->msg_id = _identity;\n\n    /*\n     * Imposto il timer interno\n     */\n\n    _M_msg_out->msg_time = 0;\n\n    /*\n     * Invio di un messaggio contenente la propria identità sui due canali di in/out\n     */\n\n    _M_msg_out->msg_x = 0.00;\n    _M_msg_out->msg_z = 0.00;\n\n    sendMsg(router_to_agent_socket_, _M_msg_out);\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: > snd (%d,%d,%2.8g,%2.8g) > %d\\n\", _identity, _M_msg_out->msg_id, _M_msg_out->msg_time, _M_msg_out->msg_x, _M_msg_out->msg_z, _port_router_to_agent);\n\n    sendMsg(agent_to_router_socket_, _M_msg_out);\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: > snd (%d,%d,%2.8g,%2.8g) > %d\\n\", _identity, _M_msg_out->msg_id, _M_msg_out->msg_time, _M_msg_out->msg_x, _M_msg_out->msg_z, _port_agent_to_router);\n\n\n    /*\n     * Ciclo principale\n     */\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: Loop:\\n\", _identity);\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: > for i=[0,%d]\\n\", _identity, N);\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: ----- Loop Start -----\\n\", _identity);\n\n    x[0] = x0[_identity - 1];\n    z[0] = z0[_identity - 1];\n\n    for (c = 0; c < N; c++) {\n\n        if (log_level & log_debug) fprintf(agent_log, \"A%d: > i = %d\\n\", _identity, c);\n\n        /*\n         * snd x\n         */\n\n        _M_msg_out->msg_time = 0;\n        _M_msg_out->msg_x = x[0];\n        _M_msg_out->msg_z = z[0];\n        sendMsg(agent_to_router_socket_, _M_msg_out);\n        if (log_level & log_normal) fprintf(agent_log, \"%2.8g %2.8g\\n\", _M_msg_out->msg_x, _M_msg_out->msg_z);\n        if (log_level & log_details) fprintf(agent_log, \"A%d: > snd (%d,%d,%2.8g,%2.8g)\\n\", _identity, _M_msg_out->msg_id, _M_msg_out->msg_time, _M_msg_out->msg_x, _M_msg_out->msg_z);\n\n        /*\n         * k1\n         */\n\n        while (r[0] < _agent_neighborhood) {\n            _M_msg_in = recvMsg(router_to_agent_socket_);\n            if (log_level & log_details) fprintf(agent_log, \"A%d: > rcv (%d,%d,%2.8g,%2.8g)\\n\", _identity, _M_msg_in->msg_id, _M_msg_out->msg_time, _M_msg_in->msg_x, _M_msg_in->msg_z);\n            sx[_M_msg_in->msg_time] = sx[_M_msg_in->msg_time] + _M_msg_in->msg_x;\n            sz[_M_msg_in->msg_time] = sz[_M_msg_in->msg_time] + _M_msg_in->msg_z;\n            r[_M_msg_in->msg_time]++;\n        }\n\n\n        x[1] = r[0] * z[0] - sz[0];\n        z[1] = sx[0] - r[0] * x[0];\n        sx[0] = 0;\n        sz[0] = 0;\n        r[0] = 0;\n\n        _M_msg_out->msg_time = 1;\n        _M_msg_out->msg_x = x[1];\n        _M_msg_out->msg_z = z[1];\n        sendMsg(agent_to_router_socket_, _M_msg_out);\n        if (log_level & log_details) fprintf(agent_log, \"A%d: > snd (%d,%d,%2.8g,%2.8g)\\n\", _identity, _M_msg_out->msg_id, _M_msg_out->msg_time, _M_msg_out->msg_x, _M_msg_out->msg_z);\n\n        /*\n         * k2\n         */\n\n        while (r[1] < _agent_neighborhood) {\n            _M_msg_in = recvMsg(router_to_agent_socket_);\n            if (log_level & log_details) fprintf(agent_log, \"A%d: > rcv (%d,%d,%2.8g,%2.8g)\\n\", _identity, _M_msg_in->msg_id, _M_msg_out->msg_time, _M_msg_in->msg_x, _M_msg_in->msg_z);\n            sx[_M_msg_in->msg_time] = sx[_M_msg_in->msg_time] + _M_msg_in->msg_x;\n            sz[_M_msg_in->msg_time] = sz[_M_msg_in->msg_time] + _M_msg_in->msg_z;\n            r[_M_msg_in->msg_time]++;\n        }\n\n        x[2] = x[1] + h * (r[1] * z[1] - sz[1]) / 2;\n        z[2] = z[1] + h * (sx[1] - r[1] * x[1]) / 2;\n        sx[1] = 0;\n        sz[1] = 0;\n        r[1] = 0;\n\n        _M_msg_out->msg_time = 2;\n        _M_msg_out->msg_x = x[2];\n        _M_msg_out->msg_z = z[2];\n        sendMsg(agent_to_router_socket_, _M_msg_out);\n        if (log_level & log_details) fprintf(agent_log, \"A%d: > snd (%d,%d,%2.8g,%2.8g)\\n\", _identity, _M_msg_out->msg_id, _M_msg_out->msg_time, _M_msg_out->msg_x, _M_msg_out->msg_z);\n\n        /*\n         * k3\n         */\n\n        while (r[2] < _agent_neighborhood) {\n            _M_msg_in = recvMsg(router_to_agent_socket_);\n            if (log_level & log_details) fprintf(agent_log, \"A%d: > rcv (%d,%d,%2.8g,%2.8g)\\n\", _identity, _M_msg_in->msg_id, _M_msg_out->msg_time, _M_msg_in->msg_x, _M_msg_in->msg_z);\n            sx[_M_msg_in->msg_time] = sx[_M_msg_in->msg_time] + _M_msg_in->msg_x;\n            sz[_M_msg_in->msg_time] = sz[_M_msg_in->msg_time] + _M_msg_in->msg_z;\n            r[_M_msg_in->msg_time]++;\n        }\n\n        x[3] = x[1] + h * (r[2] * z[2] - sz[2]) / 2;\n        z[3] = z[1] + h * (sx[2] - r[2] * x[2]) / 2;\n        sx[2] = 0;\n        sz[2] = 0;\n        r[2] = 0;\n\n        _M_msg_out->msg_time = 3;\n        _M_msg_out->msg_x = x[3];\n        _M_msg_out->msg_z = z[3];\n        sendMsg(agent_to_router_socket_, _M_msg_out);\n        if (log_level & log_details) fprintf(agent_log, \"A%d: > snd (%d,%d,%2.8g,%2.8g)\\n\", _identity, _M_msg_out->msg_id, _M_msg_out->msg_time, _M_msg_out->msg_x, _M_msg_out->msg_z);\n\n        /*\n         * k4, x\n         */\n\n        while (r[3] < _agent_neighborhood) {\n            _M_msg_in = recvMsg(router_to_agent_socket_);\n            if (log_level & log_details) fprintf(agent_log, \"A%d: > rcv (%d,%d,%2.8g,%2.8g)\\n\", _identity, _M_msg_in->msg_id, _M_msg_out->msg_time, _M_msg_in->msg_x, _M_msg_in->msg_z);\n            sx[_M_msg_in->msg_time] = sx[_M_msg_in->msg_time] + _M_msg_in->msg_x;\n            sz[_M_msg_in->msg_time] = sz[_M_msg_in->msg_time] + _M_msg_in->msg_z;\n            r[_M_msg_in->msg_time]++;\n        }\n\n        x[0] = x[0] + h * (x[1] + x[2] + x[3] + h * (r[3] * z[3] - sz[3]) / 2) / 3;\n        z[0] = z[0] + h * (z[1] + z[2] + z[3] + h * (sx[3] - r[3] * x[3]) / 2) / 3;\n        sx[3] = 0;\n        sz[3] = 0;\n        r[3] = 0;\n\n    }\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: ----- Loop End ------\\n\", _identity);\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: Signal:\\n\", _identity);\n\n    /*\n     * Invio del killer message\n     */\n\n    _M_msg_out->msg_id = -1;\n    _M_msg_out->msg_x = 0;\n    _M_msg_out->msg_z = 0;\n\n    sendMsg(agent_to_router_socket_, _M_msg_out);\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: > snd (%d,%d,%2.8g,%2.8g) > %d\\n\", _identity, _M_msg_out->msg_id, _M_msg_out->msg_time, _M_msg_out->msg_x, _M_msg_out->msg_z, _port_agent_to_router);\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: Socket:\\n\", _identity);\n\n    /*\n     * Chiusura delle sockets\n     */\n\n    close(router_to_agent_socket_);\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: > close(%d)\\n\", _identity, _port_router_to_agent);\n\n    close(agent_to_router_socket_);\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: > close(%d)\\n\", _identity, _port_agent_to_router);\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: Memoria:\\n\", _identity);\n\n    /*\n     * Free delle variabili usate\n     */\n\n    free(_M_msg_out);\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: > free(msg_out)\\n\", _identity);\n\n    free(_parametri_agent);\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: > parametri\\n\", _identity);\n\n    /*\n     * fflush e chiusura del logfile\n     */\n\n    if (log_level & log_debug) fprintf(agent_log, \"A%d: Close log\\n\", _identity);\n\n    fflush(agent_log);\n\n    fclose(agent_log);\n\n    return NULL;\n}\n", "meta": {"hexsha": "cd307fc7e4a06419fa2c7be2d50231e73d73e10b", "size": 14792, "ext": "c", "lang": "C", "max_stars_repo_path": "agent.c", "max_stars_repo_name": "vittorioc/VirtualAgent", "max_stars_repo_head_hexsha": "0455a86a79ef2c5a817b9a1ec26d9025703d22ab", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2017-01-29T01:05:11.000Z", "max_stars_repo_stars_event_max_datetime": "2017-01-29T01:05:11.000Z", "max_issues_repo_path": "agent.c", "max_issues_repo_name": "vittorioc/VirtualAgent", "max_issues_repo_head_hexsha": "0455a86a79ef2c5a817b9a1ec26d9025703d22ab", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "agent.c", "max_forks_repo_name": "vittorioc/VirtualAgent", "max_forks_repo_head_hexsha": "0455a86a79ef2c5a817b9a1ec26d9025703d22ab", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.2494887526, "max_line_length": 205, "alphanum_fraction": 0.6313547864, "num_tokens": 4762, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3451052574867685, "lm_q2_score": 0.020023439535066828, "lm_q1q2_score": 0.006910194256519978}}
{"text": "#include <config.h>\n#include <gsl/gsl_math.h>\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_sum.h>\n\ngsl_sum_levin_utrunc_workspace * \ngsl_sum_levin_utrunc_alloc (size_t n)\n{\n  gsl_sum_levin_utrunc_workspace * w;\n\n  if (n == 0)\n    {\n      GSL_ERROR_VAL (\"length n must be positive integer\", GSL_EDOM, 0);\n    }\n\n  w = (gsl_sum_levin_utrunc_workspace *) malloc(sizeof(gsl_sum_levin_utrunc_workspace));\n\n  if (w == NULL)\n    {\n      GSL_ERROR_VAL (\"failed to allocate struct\", GSL_ENOMEM, 0);\n    }\n\n  w->q_num = (double *) malloc (n * sizeof (double));\n\n  if (w->q_num == NULL)\n    {\n      free(w) ; /* error in constructor, prevent memory leak */\n\n      GSL_ERROR_VAL (\"failed to allocate space for q_num\", GSL_ENOMEM, 0);\n    }\n\n  w->q_den = (double *) malloc (n * sizeof (double));\n\n  if (w->q_den == NULL)\n    {\n      free (w->q_num);\n      free (w) ; /* error in constructor, prevent memory leak */\n\n      GSL_ERROR_VAL (\"failed to allocate space for q_den\", GSL_ENOMEM, 0);\n    }\n\n  w->dsum = (double *) malloc (n * sizeof (double));\n\n  if (w->dsum == NULL)\n    {\n      free (w->q_den);\n      free (w->q_num);\n      free (w) ; /* error in constructor, prevent memory leak */\n\n      GSL_ERROR_VAL (\"failed to allocate space for dsum\", GSL_ENOMEM, 0);\n    }\n\n  w->size = n;\n  w->terms_used = 0;\n  w->sum_plain = 0;\n\n  return w;\n}\n\nvoid\ngsl_sum_levin_utrunc_free (gsl_sum_levin_utrunc_workspace * w)\n{\n  RETURN_IF_NULL (w);\n  free (w->dsum);\n  free (w->q_den);\n  free (w->q_num);\n  free (w);\n}\n", "meta": {"hexsha": "81ddf67fecf0c6650801da7f68e2c9c3b91eae9f", "size": 1495, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/sum/work_utrunc.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-01-11T02:53:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-25T17:31:22.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/sum/work_utrunc.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/sum/work_utrunc.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 14.0, "max_forks_repo_forks_event_min_datetime": "2015-07-21T04:47:52.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-12T12:31:25.000Z", "avg_line_length": 21.6666666667, "max_line_length": 88, "alphanum_fraction": 0.618729097, "num_tokens": 475, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.31742627850202554, "lm_q2_score": 0.02161533032037945, "lm_q1q2_score": 0.006861273862190044}}
{"text": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <sys/time.h>\n#include <time.h>\n#include <math.h>\n#include <float.h>\n#include \"bingham/util.h\"\n//#include <lapacke.h>\n//#undef I  // fuck C99!\n\nconst color_t colormap[256] =\n  {{0, 0, 131},\n   {0, 0, 135},\n   {0, 0, 139},\n   {0, 0, 143},\n   {0, 0, 147},\n   {0, 0, 151},\n   {0, 0, 155},\n   {0, 0, 159},\n   {0, 0, 163},\n   {0, 0, 167},\n   {0, 0, 171},\n   {0, 0, 175},\n   {0, 0, 179},\n   {0, 0, 183},\n   {0, 0, 187},\n   {0, 0, 191},\n   {0, 0, 195},\n   {0, 0, 199},\n   {0, 0, 203},\n   {0, 0, 207},\n   {0, 0, 211},\n   {0, 0, 215},\n   {0, 0, 219},\n   {0, 0, 223},\n   {0, 0, 227},\n   {0, 0, 231},\n   {0, 0, 235},\n   {0, 0, 239},\n   {0, 0, 243},\n   {0, 0, 247},\n   {0, 0, 251},\n   {0, 0, 255},\n   {0, 4, 255},\n   {0, 8, 255},\n   {0, 12, 255},\n   {0, 16, 255},\n   {0, 20, 255},\n   {0, 24, 255},\n   {0, 28, 255},\n   {0, 32, 255},\n   {0, 36, 255},\n   {0, 40, 255},\n   {0, 44, 255},\n   {0, 48, 255},\n   {0, 52, 255},\n   {0, 56, 255},\n   {0, 60, 255},\n   {0, 64, 255},\n   {0, 68, 255},\n   {0, 72, 255},\n   {0, 76, 255},\n   {0, 80, 255},\n   {0, 84, 255},\n   {0, 88, 255},\n   {0, 92, 255},\n   {0, 96, 255},\n   {0, 100, 255},\n   {0, 104, 255},\n   {0, 108, 255},\n   {0, 112, 255},\n   {0, 116, 255},\n   {0, 120, 255},\n   {0, 124, 255},\n   {0, 128, 255},\n   {0, 131, 255},\n   {0, 135, 255},\n   {0, 139, 255},\n   {0, 143, 255},\n   {0, 147, 255},\n   {0, 151, 255},\n   {0, 155, 255},\n   {0, 159, 255},\n   {0, 163, 255},\n   {0, 167, 255},\n   {0, 171, 255},\n   {0, 175, 255},\n   {0, 179, 255},\n   {0, 183, 255},\n   {0, 187, 255},\n   {0, 191, 255},\n   {0, 195, 255},\n   {0, 199, 255},\n   {0, 203, 255},\n   {0, 207, 255},\n   {0, 211, 255},\n   {0, 215, 255},\n   {0, 219, 255},\n   {0, 223, 255},\n   {0, 227, 255},\n   {0, 231, 255},\n   {0, 235, 255},\n   {0, 239, 255},\n   {0, 243, 255},\n   {0, 247, 255},\n   {0, 251, 255},\n   {0, 255, 255},\n   {4, 255, 251},\n   {8, 255, 247},\n   {12, 255, 243},\n   {16, 255, 239},\n   {20, 255, 235},\n   {24, 255, 231},\n   {28, 255, 227},\n   {32, 255, 223},\n   {36, 255, 219},\n   {40, 255, 215},\n   {44, 255, 211},\n   {48, 255, 207},\n   {52, 255, 203},\n   {56, 255, 199},\n   {60, 255, 195},\n   {64, 255, 191},\n   {68, 255, 187},\n   {72, 255, 183},\n   {76, 255, 179},\n   {80, 255, 175},\n   {84, 255, 171},\n   {88, 255, 167},\n   {92, 255, 163},\n   {96, 255, 159},\n   {100, 255, 155},\n   {104, 255, 151},\n   {108, 255, 147},\n   {112, 255, 143},\n   {116, 255, 139},\n   {120, 255, 135},\n   {124, 255, 131},\n   {128, 255, 128},\n   {131, 255, 124},\n   {135, 255, 120},\n   {139, 255, 116},\n   {143, 255, 112},\n   {147, 255, 108},\n   {151, 255, 104},\n   {155, 255, 100},\n   {159, 255, 96},\n   {163, 255, 92},\n   {167, 255, 88},\n   {171, 255, 84},\n   {175, 255, 80},\n   {179, 255, 76},\n   {183, 255, 72},\n   {187, 255, 68},\n   {191, 255, 64},\n   {195, 255, 60},\n   {199, 255, 56},\n   {203, 255, 52},\n   {207, 255, 48},\n   {211, 255, 44},\n   {215, 255, 40},\n   {219, 255, 36},\n   {223, 255, 32},\n   {227, 255, 28},\n   {231, 255, 24},\n   {235, 255, 20},\n   {239, 255, 16},\n   {243, 255, 12},\n   {247, 255, 8},\n   {251, 255, 4},\n   {255, 255, 0},\n   {255, 251, 0},\n   {255, 247, 0},\n   {255, 243, 0},\n   {255, 239, 0},\n   {255, 235, 0},\n   {255, 231, 0},\n   {255, 227, 0},\n   {255, 223, 0},\n   {255, 219, 0},\n   {255, 215, 0},\n   {255, 211, 0},\n   {255, 207, 0},\n   {255, 203, 0},\n   {255, 199, 0},\n   {255, 195, 0},\n   {255, 191, 0},\n   {255, 187, 0},\n   {255, 183, 0},\n   {255, 179, 0},\n   {255, 175, 0},\n   {255, 171, 0},\n   {255, 167, 0},\n   {255, 163, 0},\n   {255, 159, 0},\n   {255, 155, 0},\n   {255, 151, 0},\n   {255, 147, 0},\n   {255, 143, 0},\n   {255, 139, 0},\n   {255, 135, 0},\n   {255, 131, 0},\n   {255, 128, 0},\n   {255, 124, 0},\n   {255, 120, 0},\n   {255, 116, 0},\n   {255, 112, 0},\n   {255, 108, 0},\n   {255, 104, 0},\n   {255, 100, 0},\n   {255, 96, 0},\n   {255, 92, 0},\n   {255, 88, 0},\n   {255, 84, 0},\n   {255, 80, 0},\n   {255, 76, 0},\n   {255, 72, 0},\n   {255, 68, 0},\n   {255, 64, 0},\n   {255, 60, 0},\n   {255, 56, 0},\n   {255, 52, 0},\n   {255, 48, 0},\n   {255, 44, 0},\n   {255, 40, 0},\n   {255, 36, 0},\n   {255, 32, 0},\n   {255, 28, 0},\n   {255, 24, 0},\n   {255, 20, 0},\n   {255, 16, 0},\n   {255, 12, 0},\n   {255, 8, 0},\n   {255, 4, 0},\n   {255, 0, 0},\n   {251, 0, 0},\n   {247, 0, 0},\n   {243, 0, 0},\n   {239, 0, 0},\n   {235, 0, 0},\n   {231, 0, 0},\n   {227, 0, 0},\n   {223, 0, 0},\n   {219, 0, 0},\n   {215, 0, 0},\n   {211, 0, 0},\n   {207, 0, 0},\n   {203, 0, 0},\n   {199, 0, 0},\n   {195, 0, 0},\n   {191, 0, 0},\n   {187, 0, 0},\n   {183, 0, 0},\n   {179, 0, 0},\n   {175, 0, 0},\n   {171, 0, 0},\n   {167, 0, 0},\n   {163, 0, 0},\n   {159, 0, 0},\n   {155, 0, 0},\n   {151, 0, 0},\n   {147, 0, 0},\n   {143, 0, 0},\n   {139, 0, 0},\n   {135, 0, 0},\n   {131, 0, 0},\n   {128, 0, 0}};\n\n\ndouble get_time_ms()\n{\n  struct timeval tv;\n  struct timezone tz;\n\n  gettimeofday(&tv, &tz);\n\n  return 1000.*tv.tv_sec + tv.tv_usec/1000.;\n}\n\n\n// returns a pointer to the nth word (starting from 0) in string s\nchar *sword(const char *s, const char *delim, int n)\n{\n  if (s == NULL)\n    return NULL;\n\n  s += strspn(s, delim);  // skip over initial delimeters\n\n  int i;\n  for (i = 0; i < n; i++) {\n    s += strcspn(s, delim);  // skip over word\n    s += strspn(s, delim);  // skip over delimeters\n  }\n\n  return (char *)s;\n}\n\n\n// splits a string into k words\nchar **split(const char *s, const char *delim, int *k)\n{\n  const char *sbuf = s + strspn(s, delim);  // skip over initial whitespace\n  s = sbuf;\n\n  // determine the number of words\n  int num_words = 0;\n  while (*s != '\\0') {\n    s = sword(s, delim, 1);\n    num_words++;\n  }\n\n  // fill in the words\n  int i;\n  s = sbuf;\n  char **words;\n  safe_calloc(words, num_words, char *);\n  for (i = 0; i < num_words; i++) {\n    int slen = strcspn(s, delim);  // add \"\\n\" ?\n    safe_calloc(words[i], slen+1, char);  // +1 to null-terminate the string\n    strncpy(words[i], s, slen);\n    s = sword(s, delim, 1);\n  }\n\n  *k = num_words;\n  return words;\n}\n\n\n// compare the first word of s1 with the first word of s2\nint wordcmp(const char *s1, const char *s2, const char *delim)\n{\n  int n1 = strcspn(s1, delim);\n  int n2 = strcspn(s2, delim);\n\n  if (n1 < n2)\n    return -1;\n  else if (n1 > n2)\n    return 1;\n\n  return strncmp(s1, s2, n1);\n}\n\n\n// replace a word in a string array\nvoid replace_word(char **words, int num_words, const char *from, const char *to)\n{\n  int i;\n  for (i = 0; i < num_words; i++) {\n    if (!strcmp(words[i], from)) {\n      safe_realloc(words[i], strlen(to)+1, char);\n      strcpy(words[i], to);\n    }\n  }\n}\n\n\n// computes the log factorial of x\ndouble lfact(int x)\n{\n  static double logf[MAXFACT];\n  static int first = 1;\n  int i;\n\n  if (first) {\n    first = 0;\n    logf[0] = 0;\n    for (i = 1; i < MAXFACT; i++)\n      logf[i] = log(i) + logf[i-1];\n  }\n\n  return logf[x];\n}\n\n\n// computes the factorial of x\ndouble fact(int x)\n{\n  return exp(lfact(x));\n}\n\n\n// computes the surface area of a unit sphere with dimension d\ndouble surface_area_sphere(int d)\n{\n  switch(d) {\n  case 0:\n    return 2;\n  case 1:\n    return 2*M_PI;\n  case 2:\n    return 4*M_PI;\n  case 3:\n    return 2*M_PI*M_PI;\n  }\n\n  return (2*M_PI/((double)d-1))*surface_area_sphere(d-2);\n}\n\n\n// logical not of a binary array\nvoid vnot(int y[], int x[], int n)\n{\n  int i;\n  for (i = 0; i < n; i++)\n    y[i] = !x[i];\n}\n\n\n// count the non-zero elements of x\nint count(int x[], int n)\n{\n  int i;\n  int cnt = 0;\n  for (i = 0; i < n; i++)\n    if (x[i] != 0)\n      cnt++;\n\n  return cnt;\n}\n\n\n// returns a dense array of the indices of x's non-zero elements\nint find(int *k, int x[], int n)\n{\n  int i;\n  int cnt = 0;\n  for (i = 0; i < n; i++)\n    if (x[i] != 0)\n      k[cnt++] = i;\n  return cnt;\n}\n\n\n// returns a sparse array of the indices of x's non-zero elements\nint findinv(int *k, int x[], int n)\n{\n  int i;\n  int cnt = 0;\n  for (i = 0; i < n; i++)\n    if (x[i] != 0)\n      k[i] = cnt++;\n  return cnt;\n}\n\n\n// computes a dense array of the indices of x==a\nint findeq(int *k, int x[], int a, int n)\n{\n  int i;\n  int cnt = 0;\n  if (k != NULL) {\n    for (i = 0; i < n; i++) {\n      if (x[i] == a)\n\tk[cnt++] = i;\n    }\n  }\n  else\n    for (i = 0; i < n; i++)\n      if (x[i] == a)\n\tcnt++;\n  return cnt;\n}\n\n\n// computes the sum of x's elements\ndouble sum(double x[], int n)\n{\n  int i;\n  double y = 0;\n  for (i = 0; i < n; i++)\n    y += x[i];\n  return y;\n}\n\n// computes the product of x's elements\ndouble prod(double x[], int n)\n{\n  int i;\n  double y = 1;\n  for (i = 0; i < n; i++)\n    y *= x[i];\n  return y;\n}\n\n\n// computes the max of x\ndouble arr_max(double x[], int n)\n{\n  int i;\n\n  double y = x[0];\n  for (i = 1; i < n; i++)\n    if (x[i] > y)\n      y = x[i];\n\n  return y;\n}\n\n// computes the max of x\nint arr_max_i(int x[], int n)\n{\n  int i;\n\n  int y = x[0];\n  for (i = 1; i < n; i++)\n    if (x[i] > y)\n      y = x[i];\n\n  return y;\n}\n\n// computes the masked max of x\ndouble arr_max_masked(double x[], int mask[], int n)\n{\n  int i;\n\n  for (i = 0; i < n; i++)\n    if (mask[i])\n      break;\n  if (i==n)\n    return NAN;\n\n  double y = x[i++];\n  for (; i < n; i++)\n    if (mask[i] && (x[i] > y))\n      y = x[i];\n\n  return y;\n}\n\n// computes the masked max of x\nfloat arr_maxf_masked(float x[], int mask[], int n)\n{\n  int i;\n\n  for (i = 0; i < n; i++)\n    if (mask[i])\n      break;\n  if (i==n)\n    return NAN;\n\n  float y = x[i++];\n  for (; i < n; i++)\n    if (mask[i] && (x[i] > y))\n      y = x[i];\n\n  return y;\n}\n\n// computes the min of x\ndouble arr_min(double x[], int n)\n{\n  int i;\n\n  double y = x[0];\n  for (i = 1; i < n; i++)\n    if (x[i] < y)\n      y = x[i];\n\n  return y;\n}\n\n// computes the min of x\nint arr_min_i(int x[], int n)\n{\n  int i;\n\n  int y = x[0];\n  for (i = 1; i < n; i++)\n    if (x[i] < y)\n      y = x[i];\n\n  return y;\n}\n\n// computes the masked min of x\ndouble arr_min_masked(double x[], int mask[], int n)\n{\n  int i;\n\n  for (i = 0; i < n; i++)\n    if (mask[i] != 0)\n      break;\n  if (i==n)\n    return NAN;\n\n  double y = x[i++];\n  for (; i < n; i++)\n    if (mask[i] && (x[i] < y))\n      y = x[i];\n\n  return y;\n}\n\n// computes the masked min of x\nfloat arr_minf_masked(float x[], int mask[], int n)\n{\n  int i;\n\n  for (i = 0; i < n; i++)\n    if (mask[i])\n      break;\n  if (i==n)\n    return NAN;\n\n  float y = x[i++];\n  for (; i < n; i++)\n    if (mask[i] && (x[i] < y))\n      y = x[i];\n\n  return y;\n}\n\n// returns the index of the max of x\nint find_max(double x[], int n)\n{\n  int i;\n  int idx = 0;\n  for (i = 1; i < n; i++)\n    if (x[i] > x[idx])\n      idx = i;\n  return idx;\n}\n\n// returns the index of the min of x\nint find_min(double x[], int n)\n{\n  int i;\n  int idx = 0;\n  for (i = 1; i < n; i++)\n    if (x[i] < x[idx])\n      idx = i;\n  return idx;\n}\n\n// returns the index of the max of x\nint find_imax(int x[], int n)\n{\n  int i;\n  int idx = 0;\n  for (i = 1; i < n; i++)\n    if (x[i] > x[idx])\n      idx = i;\n  return idx;\n}\n\n// returns the index of the min of x\nint find_imin(int x[], int n)\n{\n  int i;\n  int idx = 0;\n  for (i = 1; i < n; i++)\n    if (x[i] < x[idx])\n      idx = i;\n  return idx;\n}\n\n// computes the sum of x's elements\nint isum(int x[], int n)\n{\n  int i;\n  int y = 0;\n  for (i = 0; i < n; i++)\n    y += x[i];\n  return y;\n}\n\n// computes the max of x\nint imax(int x[], int n)\n{\n  int i;\n\n  int y = x[0];\n  for (i = 1; i < n; i++)\n    if (x[i] > y)\n      y = x[i];\n\n  return y;\n}\n\n\n// computes the min of x\nint imin(int x[], int n)\n{\n  int i;\n\n  int y = x[0];\n  for (i = 1; i < n; i++)\n    if (x[i] < y)\n      y = x[i];\n\n  return y;\n}\n\n\n// computes the norm of x\ndouble norm(double x[], int n)\n{\n  double d = 0.0;\n  int i;\n\n  for (i = 0; i < n; i++)\n    d += x[i]*x[i];\n\n  return sqrt(d);\n}\n\n// computes the norm of x-y\ndouble dist(double x[], double y[], int n)\n{\n  double d = 0.0;\n  int i;\n\n  for (i = 0; i < n; i++)\n    d += (x[i]-y[i])*(x[i]-y[i]);\n\n  return sqrt(d);\n}\n\n\n// computes the norm^2 of x-y\ndouble dist2(double x[], double y[], int n)\n{\n  double d = 0.0;\n  int i;\n\n  for (i = 0; i < n; i++)\n    d += (x[i]-y[i])*(x[i]-y[i]);\n\n  return d;\n}\n\n\n// computes the dot product of z and y\ndouble dot(double x[], double y[], int n)\n{\n  int i;\n  double z = 0.0;\n  for (i = 0; i < n; i++)\n    z += x[i]*y[i];\n  return z;\n}\n\n\n//computes the cross product of x and y\nvoid cross(double z[3], double x[3], double y[3])\n{\n  z[0] = x[1]*y[2] - x[2]*y[1];\n  z[1] = x[2]*y[0] - x[0]*y[2];\n  z[2] = x[0]*y[1] - x[1]*y[0];\n}\n\nvoid cross4d(double w[4], double x[4], double y[4], double z[4]) {\n  double **V = new_matrix2(4, 3);\n  int i;\n  for (i = 0; i < 4; ++i) {\n    V[i][0] = x[i];\n    V[i][1] = y[1];\n    V[i][2] = z[i];\n  }\n  double **W = new_matrix2(3, 3);\n  int indices[4][3] = {{2, 3, 4}, {1, 3, 4}, {1, 2, 4}, {1, 2, 3}};\n  int cut_axis = 0;\n  double dmax = 0;\n  for (i = 0; i < 4; ++i) {\n    reorder_rows(W, V, indices[i], 3, 3);\n    double tmp = fabs(det(W, 3));\n    if (dmax < tmp) {\n      dmax = tmp;\n      cut_axis = i;\n    }    \n  }\n  double *c0 = V[cut_axis];\n  int uncut_axis[3];\n  for (i = 0; i < cut_axis; ++i) {\n    uncut_axis[i] = i;\n    w[i] = 0;\n  }\n  for (i = cut_axis + 1; i < 4; ++i) {\n    uncut_axis[i-1] = i;\n    w[i] = 0;\n  }\n  w[cut_axis] = 1;\n  reorder_rows(W, V, uncut_axis, 3, 3);\n  inv(W, W, 3);\n  mult(c0, c0, -1, 3);\n  \n  double tmp[3];\n  matrix_vec_mult(tmp, W, c0, 3, 3); \n  for (i = 0; i < 3; ++i) {\n    w[uncut_axis[i]] = tmp[i];\n  }\n  free_matrix2(V);\n  free_matrix2(W);\n}\n\n// adds two vectors, z = x+y\nvoid add(double z[], double x[], double y[], int n)\n{\n  int i;\n  for (i = 0; i < n; i++)\n    z[i] = x[i] + y[i];\n}\n\n\n// subtracts two vectors, z = x-y\nvoid sub(double z[], double x[], double y[], int n)\n{\n  int i;\n  for (i = 0; i < n; i++)\n    z[i] = x[i] - y[i];\n}\n\n\n// multiplies a vector by a scalar, y = c*x\nvoid mult(double y[], double x[], double c, int n)\n{\n  int i;\n  for (i = 0; i < n; i++)\n    y[i] = c*x[i];\n}\n\n// computes the cumulative sum of x\nvoid cumsum(double y[], double x[], int n)\n{\n  int i;\n  double c = 0;\n  for (i = 0; i < n; i++) {\n    c += x[i];\n    y[i] = c;\n  }\n}\n\n// takes absolute value element-wise\nvoid vec_func(double y[], double x[], double n, double (*f)(double)) {\n  int i;\n  for (i = 0; i < n; ++i) {\n    y[i] = (*f)(x[i]);\n  }\n}\n\n// sets y = x/norm(x)\nvoid normalize(double y[], double x[], int n)\n{\n  double d = norm(x, n);\n  int i;\n  for (i = 0; i < n; i++)\n    y[i] = x[i]/d;\n}\n\n\n// sets y = x/sum(x)\nvoid normalize_pmf(double y[], double x[], int n)\n{\n  double d = sum(x, n);\n  int i;\n  for (i = 0; i < n; i++)\n    y[i] = x[i]/d;\n}\n\n\n// multiplies two vectors, z = x.*y\nvoid vmult(double z[], double x[], double y[], int n)\n{\n  int i;\n  for (i = 0; i < n; i++)\n    z[i] = x[i]*y[i];\n}\n\n\n// averages two vectors, z = (x+y)/2\nvoid avg(double z[], double x[], double y[], int n)\n{\n  add(z, x, y, n);\n  mult(z, z, .5, n);\n}\n\n\n// averages two vectors, z = w*x+(1-w)*y\nvoid wavg(double z[], double x[], double y[], double w, int n)\n{\n  int i;\n  for (i = 0; i < n; i++)\n    z[i] = w*x[i] + (1-w)*y[i];\n}\n\n\n// averages three vectors, y = (x1+x2+x3)/3\nvoid avg3(double y[], double x1[], double x2[], double x3[], int n)\n{\n  add(y, x1, x2, n);\n  add(y, y, x3, n);\n  mult(y, y, 1/3.0, n);\n}\n\n\n// calculate the projection of x onto y\nvoid proj(double z[], double x[], double y[], int n)\n{\n  double u[n];  // y's unit vector\n  double d = norm(y, n);\n  mult(u, y, 1/d, n);\n  mult(z, u, dot(x,u,n), n);\n}\n\n\n// binary search to find i s.t. A[i-1] <= x < A[i]\nint binary_search(double x, double *A, int n)\n{\n  int i0 = 0;\n  int i1 = n-1;\n  int i;\n\n  while (i0 <= i1) {\n    i = (i0 + i1) / 2;\n    if (x > A[i])\n      i0 = i + 1;\n    else if (i > 0 && x < A[i-1])\n      i1 = i-1;\n    else\n      break;\n  }\n\n  if (i0 <= i1)\n    return i;\n\n  return n-1;\n}\n\nvoid plane_from_3points(double *coeffs, double *p0, double *p1, double *p2)\n{\n    double diff1[3], diff2[3];\n    sub(diff1, p1, p0, 3);\n    sub(diff2, p2, p0, 3);\n    double normal[3];\n    cross(normal, diff1, diff2);\n    normalize(normal, normal, 3);\n    double flip = normal[2] > 0.0 ? -1.0 : 1.0; // flip normal towards camera\n    \n    coeffs[0] = normal[0] * flip;\n    coeffs[1] = normal[1] * flip;\n    coeffs[2] = normal[2] * flip;\n    coeffs[3] = -dot(normal, p0, 3) * flip;\n}\n\n// quaternion multiplication:  z = x*y\nvoid quaternion_mult(double z[4], double x[4], double y[4])\n{\n  double a = x[0];\n  double b = x[1];\n  double c = x[2];\n  double d = x[3];\n  double y0 = y[0];\n  double y1 = y[1];\n  double y2 = y[2];\n  double y3 = y[3];\n\n  z[0] = a*y0 - b*y1 - c*y2 - d*y3;\n  z[1] = b*y0 + a*y1 - d*y2 + c*y3;\n  z[2] = c*y0 + d*y1 + a*y2 - b*y3;\n  z[3] = d*y0 - c*y1 + b*y2 + a*y3;\n}\n\n\n// invert a quaternion\nvoid quaternion_inverse(double q_inv[4], double q[4])\n{\n  q_inv[0] = q[0];\n  q_inv[1] = -q[1];\n  q_inv[2] = -q[2];\n  q_inv[3] = -q[3];\n}\n\n\n// quaternion exponentiation (q2 = q^a)\nvoid quaternion_pow(double q2[4], double q[4], double a)\n{\n  double u[3];  // axis of rotation\n  normalize(u, &q[1], 3);\n  double w = MIN(MAX(q[0], -1.0), 1.0);  // for numerical stability\n  double theta2 = acos(w);  // theta / 2.0\n  double s = sin(a*theta2);\n  q2[0] = cos(a*theta2);\n  mult(&q2[1], u, s, 3);\n}\n\n\n// quaternion interpolation (slerp)\nvoid quaternion_interpolation(double q[4], double q0[4], double q1[4], double t)\n{\n  double q0_inv[4], q01[4];\n  quaternion_inverse(q0_inv, q0);\n  quaternion_mult(q01, q1, q0_inv);\n  quaternion_pow(q01, q01, t);\n  quaternion_mult(q, q01, q0);\n}\n\n\n// convert a rotation matrix to a unit quaternion\nvoid rotation_matrix_to_quaternion(double *q, double **R)\n{\n  double S;\n  double tr = R[0][0] + R[1][1] + R[2][2];\n  if (tr > 0) {\n    S = sqrt(tr+1.0) * 2;  // S=4*qw\n    q[0] = 0.25 * S;\n    q[1] = (R[2][1] - R[1][2]) / S;\n    q[2] = (R[0][2] - R[2][0]) / S;\n    q[3] = (R[1][0] - R[0][1]) / S;\n  }\n  else if ((R[0][0] > R[1][1]) && (R[0][0] > R[2][2])) {\n    S = sqrt(1.0 + R[0][0] - R[1][1] - R[2][2]) * 2;  // S=4*qx \n    q[0] = (R[2][1] - R[1][2]) / S;\n    q[1] = 0.25 * S;\n    q[2] = (R[0][1] + R[1][0]) / S; \n    q[3] = (R[0][2] + R[2][0]) / S; \n  }\n  else if (R[1][1] > R[2][2]) {\n    S = sqrt(1.0 + R[1][1] - R[0][0] - R[2][2]) * 2;  // S=4*qy\n    q[0] = (R[0][2] - R[2][0]) / S;\n    q[1] = (R[0][1] + R[1][0]) / S; \n    q[2] = 0.25 * S;\n    q[3] = (R[1][2] + R[2][1]) / S; \n  }\n  else {\n    S = sqrt(1.0 + R[2][2] - R[0][0] - R[1][1]) * 2;  // S=4*qz\n    q[0] = (R[1][0] - R[0][1]) / S;\n    q[1] = (R[0][2] + R[2][0]) / S;\n    q[2] = (R[1][2] + R[2][1]) / S;\n    q[3] = 0.25 * S;\n  }\n\n  normalize(q, q, 4);\n}\n\n\n// convert a unit quaternion to a rotation matrix\nvoid quaternion_to_rotation_matrix(double **R, double *q)\n{\n  double a = q[0];\n  double b = q[1];\n  double c = q[2];\n  double d = q[3];\n\n  R[0][0] = a*a + b*b - c*c - d*d;\n  R[0][1] = 2*b*c - 2*a*d;\n  R[0][2] = 2*b*d + 2*a*c;\n  R[1][0] = 2*b*c + 2*a*d;\n  R[1][1] = a*a - b*b + c*c - d*d;\n  R[1][2] = 2*c*d - 2*a*b;\n  R[2][0] = 2*b*d - 2*a*c;\n  R[2][1] = 2*c*d + 2*a*b;\n  R[2][2] = a*a - b*b - c*c + d*d;\n}\n\nint find_first_non_zero(double *v, int n)\n{\n  int i;\n  for (i = 0; i < n; ++i) {\n    if (v[i] != 0.)\n      return i;\n  }\n  return -1;\n}\n\nint find_first_lt(double *x, double a, int n)\n{\n  int i;\n  for (i = 0; i < n; ++i)\n    if (x[i] < a)\n      break;\n  return i;\n}\n\nint find_first_gt(double *x, double a, int n)\n{\n  int i;\n  for (i = 0; i < n; ++i)\n    if (x[i] > a)\n      break;\n  return i;\n}\n\n/*\nshort *ismember(double *A, double *B, int n, int m) {\n  short *C;\n  safe_calloc(C, n, short);\n  int i, j;\n  // NOTE(sanja): this can be done in O(n log n + m) if necessary. Also, SSE2-able :)\n  for (i = 0; i < n; ++i) {\n    for (j = 0; j < m; ++j) {\n      if (double_is_equal(A[i], B[j])) {\n\tC[i] = 1;\n\tbreak;\n      }\n    }\n  }\n  return C;\n}\n\nshort *ismemberi(int *A, int *B, int n, int m) {\n  short *C;\n  safe_calloc(C, n, short);\n  int i, j;\n  // NOTE(sanja): this can be done in O(n log n + m) if necessary. Also, SSE2-able :)\n  for (i = 0; i < n; ++i) {\n    for (j = 0; j < m; ++j) {\n      if (A[i] == B[j]) {\n\tC[i] = 1;\n\tbreak;\n      }\n    }\n  }\n  return C;\n}\n*/\n\n// check if y contains x\nint ismemberi(int x, int *y, int n)\n{\n  int i;\n  for (i = 0; i < n; ++i)\n    if (x == y[i])\n      return 1;\n  return 0;\n}\n\n// reverses an array of doubles (safe for x==y)\nvoid reverse(double *y, double *x, int n)\n{\n  int i;\n  for (i = 0; i < n/2; i++) {\n    double tmp = x[i];\n    y[i] = x[n-i-1];\n    y[n-i-1] = tmp;\n  }\n}\n\n// reverses an array of ints (safe for x==y)\nvoid reversei(int *y, int *x, int n)\n{\n  int i;\n  for (i = 0; i < n/2; i++) {\n    int tmp = x[i];\n    y[i] = x[n-i-1];\n    y[n-i-1] = tmp;\n  }\n}\n\n// reorder an array of doubles (safe for x==y)\nvoid reorder(double *y, double *x, int *idx, int n)\n{\n  int i;\n  double *y2 = y;\n  if (x==y)\n    safe_calloc(y2, n, double);\n  for (i = 0; i < n; i++)\n    y2[i] = x[idx[i]];\n  if (x==y) {\n    memcpy(y, y2, n*sizeof(double));\n    free(y2);\n  }\n}\n\n// reorder an array of ints (safe for x==y)\nvoid reorderi(int *y, int *x, int *idx, int n)\n{\n  int i;\n  int *y2 = y;\n  if (x==y)\n    safe_calloc(y2, n, int);\n  for (i = 0; i < n; i++)\n    y2[i] = x[idx[i]];\n  if (x==y) {\n    memcpy(y, y2, n*sizeof(int));\n    free(y2);\n  }\n}\n\n// add an element to the front of a list\nilist_t *ilist_add(ilist_t *x, int a)\n{\n  ilist_t *head;\n  safe_malloc(head, 1, ilist_t);\n  head->x = a;\n  head->next = x;\n  head->len = (x ? 1 + x->len : 1);\n\n  return head;\n}\n\n\n// check if a list contains an element\nint ilist_contains(ilist_t *x, int a)\n{\n  if (!x)\n    return 0;\n\n  ilist_t *tmp;\n  for (tmp = x; tmp; tmp = tmp->next)\n    if (tmp->x == a)\n      return 1;\n  return 0;\n}\n\n\n// find the index of an element in a list (or -1 if not found)\nint ilist_find(ilist_t *x, int a)\n{\n  int i = 0;\n  ilist_t *tmp;\n  for (tmp = x; tmp; tmp = tmp->next) {\n    if (tmp->x == a)\n      return i;\n    i++;\n  }\n\n  return -1;\n}\n\n\n// free a list\nvoid ilist_free(ilist_t *x)\n{\n  ilist_t *tmp, *tmp2;\n  tmp = x;\n  while (tmp) {\n    tmp2 = tmp->next;\n    free(tmp);\n    tmp = tmp2;\n  }  \n}\n\n\nstatic void init_rand()\n{\n  static int first = 1;\n  if (first) {\n    first = 0;\n    int seed = time(NULL); \n    //    seed = 1371836140;\n    //int seed = 1368560954; <-- Crashes straw bowl on 3/9\n    //1368457226; <--- Shows overlap on 5/3\n    printf(\"********* seed = %d\\n\", seed);\n    srand (seed);\n  }\n}\n\n\n// returns a random int between 0 and n-1\nint irand(int n)\n{\n  init_rand();\n\n  if (n < 0)\n    printf(\"Negative n: %d\\n\", n);\n  return rand() % n;\n}\n\n\n// returns a random double in [0,1]\ndouble frand()\n{\n  init_rand();\n\n  return fabs(rand()) / (double)RAND_MAX;\n}\n\n\n// samples d integers from 0:n-1 uniformly without replacement\nvoid randperm(int *x, int n, int d)\n{\n  init_rand();\n\n  int i;\n\n  if (d > n) {\n    fprintf(stderr, \"Error: d > n in randperm()\\n\");\n    return;\n  }\n  \n  // sample a random starting point\n  int i0 = rand() % n;\n\n  // use a random prime step to cycle through x\n  static const int big_primes[100] = {996311, 163573, 481123, 187219, 963323, 103769, 786979, 826363, 874891, 168991, 442501, 318679, 810377, 471073, 914519, 251059, 321983, 220009, 211877, 875339, 605603, 578483, 219619, 860089, 644911, 398819, 544927, 444043, 161717, 301447, 201329, 252731, 301463, 458207, 140053, 906713, 946487, 524389, 522857, 387151, 904283, 415213, 191047, 791543, 433337, 302989, 445853, 178859, 208499, 943589, 957331, 601291, 148439, 296801, 400657, 829637, 112337, 134707, 240047, 669667, 746287, 668243, 488329, 575611, 350219, 758449, 257053, 704287, 252283, 414539, 647771, 791201, 166031, 931313, 787021, 520529, 474667, 484361, 358907, 540271, 542251, 825829, 804709, 664843, 423347, 820367, 562577, 398347, 940349, 880603, 578267, 644783, 611833, 273001, 354329, 506101, 292837, 851017, 262103, 288989};\n\n  int step = big_primes[rand() % 100];\n\n  int idx = i0;\n  for (i = 0; i < d; i++) {\n    x[i] = idx;\n    idx = (idx + step) % n;\n  }\n\n  /*\n  if (d > 2*sqrt(n*log(n))) {\n    double r[n];\n    int idx[n];\n    for (i = 0; i < n; i++)\n      r[i] = frand();\n    sort_indices(r, idx, n);\n    memcpy(x, idx, d*sizeof(int));\n  }\n  else {\n    for (i = 0; i < d; i++) {\n      while (1) {\n\tx[i] = rand() % n;\n\tfor (j = 0; j < i; j++)\n\t  if (x[j] == x[i])\n\t    break;\n\tif (j == i)  // x[i] is unique\n\t  break;\n      }\n    }\n  }\n  */\n}\n\n// approximation to the inverse error function\ndouble erfinv(double x)\n{\n  if (x < 0)\n    return -erfinv(-x);\n\n  double a = .147;\n\n  double y1 = (2/(M_PI*a) + log(1-x*x)/2.0);\n  double y2 = sqrt(y1*y1 - (1/a)*log(1-x*x));\n  double y3 = sqrt(y2 - y1);\n  \n  return y3;\n}\n\n\n// generate a random sample from a normal distribution\ndouble normrand(double mu, double sigma)\n{\n  double u = frand();\n  \n  return mu + sigma*sqrt(2.0)*erfinv(2*u-1);\n}\n\n\n// compute the pdf of a normal random variable\ndouble normpdf(double x, double mu, double sigma)\n{\n  double dx = x - mu;\n\n  return exp(-dx*dx / (2*sigma*sigma)) / (sqrt(2*M_PI) * sigma);\n}\n\n\n// samples from the probability mass function w with n elements\nint pmfrand(double *w, int n) {\n\n  int i;\n  double r = frand();\n  double wtot = 0;\n  for (i = 0; i < n; i++) {\n    wtot += w[i];\n    if (wtot >= r)\n      return i;\n  }\n\n  return 0;\n}\n\n// samples from the cumulative mass function w with n elements (much faster than pmfrand)\nint cmfrand(double *w, int n)\n{\n  double r = frand();\n  return binary_search(r, w, n);\n}\n\n// sample from a multivariate normal\nvoid mvnrand(double *x, double *mu, double **S, int d)\n{\n  double z[d], **V = new_matrix2(d,d);\n  eigen_symm(z,V,S,d);\n  int i;\n  for (i = 0; i < d; i++)\n    z[i] = sqrt(z[i]);\n\n  mvnrand_pcs(x,mu,z,V,d);\n\n  free_matrix2(V);\n}\n\ndouble mvnpdf(double *x, double *mu, double **S, int d)\n{\n  double **S_inv = new_matrix2(d,d);\n  inv(S_inv, S, d);\n  \n  double dx[d];\n  sub(dx, x, mu, d);\n  double S_inv_dx[d];\n  matrix_vec_mult(S_inv_dx, S_inv, dx, d, d);\n  double dm = dot(dx, S_inv_dx, d);\n\n  double p = exp(-.5*dm) / sqrt(pow(2*M_PI, d) * det(S,d));\n\n  free_matrix2(S_inv);\n\n  return p;\n\n}\n\n/* compute a multivariate normal pdf\ndouble mvnpdf(double *x, double *mu, double **S, int d)\n{\n  double z[d], **V = new_matrix2(d,d);\n  eigen_symm(z,V,S,d);\n  int i;\n  for (i = 0; i < d; i++)\n    z[i] = sqrt(z[i]);\n\n  printf(\"S = [%f %f %f; %f %f %f; %f %f %f]\\n\", S[0][0], S[0][1], S[0][2], S[1][0], S[1][1], S[1][2], S[2][0], S[2][1], S[2][2]); //dbug\n  printf(\"z = [%f, %f, %f]\\n\", z[0], z[1], z[2]); //dbug\n\n  double p = mvnpdf_pcs(x,mu,z,V,d);\n\n  free_matrix2(V);\n  return p;\n}\n*/\n\n// sample from a multivariate normal in principal components form\nvoid mvnrand_pcs(double *x, double *mu, double *z, double **V, int d)\n{\n  int i;\n  double s, v[d];\n\n  memcpy(x, mu, d*sizeof(double));\n\n  for (i = 0; i < d; i++) {\n    s = normrand(0, z[i]);\n    mult(v, V[i], s, d);  // v = s*V[i]\n    add(x, x, v, d);      // x += v\n  }\n}\n\n\n// compute a multivariate normal pdf in principal components form\ndouble mvnpdf_pcs(double *x, double *mu, double *z, double **V, int d)\n{\n  int i;\n  double xv, dx[d];\n  sub(dx, x, mu, d);  // dx = x - mu\n\n  double logp = -(d/2)*log(2*M_PI) - log(prod(z,d));\n  for (i = 0; i < d; i++) {\n    xv = dot(dx, V[i], d) / z[i];\n    logp -= 0.5*xv*xv;\n  }\n\n  return exp(logp);\n}\n\n\n// sample from an angular central gaussian in principal components form\nvoid acgrand_pcs(double *x, double *z, double **V, int d)\n{\n  int i;\n  double mu[d];\n  for (i = 0; i < d; i++)\n    mu[i] = 0;\n\n  mvnrand_pcs(x, mu, z, V, d);\n  normalize(x, x, d);\n}\n\n\n// compute an angular central gaussian pdf in principal components form\ndouble acgpdf_pcs(double *x, double *z, double **V, int d)\n{\n  int i;\n  double p = 1 / (prod(z,d) * surface_area_sphere(d-1));\n  double xv, md = 0;  // mahalanobis distance\n  for (i = 0; i < d; i++) {\n    xv = dot(x, V[i], d) / z[i];\n    md += xv*xv;\n  }\n  p *= pow(md, -d/2);\n  \n  return p;\n}\n\n\n// create a new n-by-m-by-p 3d matrix of doubles\ndouble ***new_matrix3(int n, int m, int p)\n{\n  if (n*m*p == 0) return NULL;\n  int i;\n  double **X2 = new_matrix2(n*m, p);\n  double ***X;\n  safe_malloc(X, n, double**);\n  for (i = 0; i < n; i++)\n    X[i] = X2 + m*i;\n\n  return X;\n}\n\n// free a 3d matrix\nvoid free_matrix3(double ***X)\n{\n  free_matrix2(X[0]);\n  free(X);\n}\n\n// create a new n-by-m-by-p 3d matrix of floats\nfloat ***new_matrix3f(int n, int m, int p)\n{\n  if (n*m*p == 0) return NULL;\n  int i;\n  float **X2 = new_matrix2f(n*m, p);\n  float ***X;\n  safe_malloc(X, n, float**);\n  for (i = 0; i < n; i++)\n    X[i] = X2 + m*i;\n\n  return X;\n}\n\n// free a 3d matrix\nvoid free_matrix3f(float ***X)\n{\n  free_matrix2f(X[0]);\n  free(X);\n}\n\n// copy a 3d matrix of doubles: Y = X\nvoid matrix3_copy(double ***Y, double ***X, int n, int m, int p)\n{\n  memcpy(Y[0][0], X[0][0], n*m*p*sizeof(double));\n}\n\n// clone a 3d matrix of doubles: Y = new(X)\ndouble ***matrix3_clone(double ***X, int n, int m, int p)\n{\n  double ***Y = new_matrix3(n,m,p);\n  matrix3_copy(Y, X, n, m, p);\n\n  return Y;\n}\n\n// create a new n-by-m 2d matrix of doubles\ndouble **new_matrix2(int n, int m)\n{\n  if (n*m == 0) return NULL;\n  int i;\n  double *raw, **X;\n  safe_calloc(raw, n*m, double);\n  safe_malloc(X, n, double*);\n\n  for (i = 0; i < n; i++)\n    X[i] = raw + m*i;\n\n  return X;\n}\n\nvoid add_rows_matrix2(double ***X, int n, int m, int new_n)\n{\n  int i;\n  double *raw = (*X)[0];\n  safe_realloc(raw, m * new_n, double);\n  safe_realloc(*X, new_n, double*);\n  for (i = 0; i < new_n; i++)\n    (*X)[i] = raw + m*i;\n}\n\nvoid add_rows_matrix2i(int ***X, int n, int m, int new_n)\n{\n  int i;\n  int *raw = (*X)[0];\n  safe_realloc(raw, m * new_n, int);\n  safe_realloc(*X, new_n, int*);\n  for (i = 0; i < new_n; i++)\n    (*X)[i] = raw + m*i;\n}\n\n\n/*\nvoid resize_matrix2(double ***X, int n, int m, int n2, int m2)\n{\n  if (m2 == m)\n    add_rows_matrix2(X, n, m, n2);\n  else {\n    \n  }\n}\n*/\n\n// create a new n-by-m 2d matrix of floats\nfloat **new_matrix2f(int n, int m)\n{\n  if (n*m == 0) return NULL;\n  int i;\n  float *raw, **X;\n  safe_calloc(raw, n*m, float);\n  safe_malloc(X, n, float*);\n\n  for (i = 0; i < n; i++)\n    X[i] = raw + m*i;\n\n  return X;\n}\n\n// create a new n-by-m 2d matrix of ints\nint **new_matrix2i(int n, int m)\n{\n  if (n*m == 0) return NULL;\n  int i, *raw, **X;\n  safe_calloc(raw, n*m, int);\n  safe_malloc(X, n, int*);\n\n  for (i = 0; i < n; i++)\n    X[i] = raw + m*i;\n\n  return X;\n}\n\n// create a new n-by-m 2d matrix of chars\nchar **new_matrix2c(int n, int m)\n{\n  if (n*m == 0) return NULL;\n  int i;\n  char *raw, **X;\n  safe_calloc(raw, n*m, char);\n  safe_malloc(X, n, char*);\n\n  for (i = 0; i < n; i++)\n    X[i] = raw + m*i;\n\n  return X;\n}\n\n// create a new n-by-m 2d matrix of doubles\ndouble **new_matrix2_data(int n, int m, double *data)\n{\n  double **X = new_matrix2(n,m);\n  memcpy(X[0], data, n*m*sizeof(double));\n  return X;\n}\n\n// create a new n-by-m 2d matrix of floats\nfloat **new_matrix2f_data(int n, int m, float *data)\n{\n  float **X = new_matrix2f(n,m);\n  memcpy(X[0], data, n*m*sizeof(float));\n  return X;\n}\n\n// create a new n-by-m 2d matrix of ints\nint **new_matrix2i_data(int n, int m, int *data)\n{\n  int **X = new_matrix2i(n,m);\n  memcpy(X[0], data, n*m*sizeof(int));\n  return X;\n}\n\n// create a new n-by-m 2d matrix of chars\nchar **new_matrix2c_data(int n, int m, char *data)\n{\n  char **X = new_matrix2c(n,m);\n  memcpy(X[0], data, n*m*sizeof(char));\n  return X;\n}\n\n/*\ndouble **add_matrix_row(double **X, int n, int m)\n{\n  //printf(\"DANGER! Reallocating matrix rows is not tested yet!\\n\");\n  double *raw = X[0];\n  safe_realloc(raw, (n + 1) * m, double);\n  safe_realloc(X, n+1, double*);\n  X[n] = raw + m * n;\n\n  return X;\n}\n*/\n\ndouble **new_identity_matrix2(int n) {\n  double **mat = new_matrix2(n, n);\n  int i;\n  for (i = 0; i < n; ++i)\n    mat[i][i] = 1;\n  return mat;\n}\n\nint **new_identity_matrix2i(int n) {\n  int **mat = new_matrix2i(n, n);\n  int i;\n  for (i = 0; i < n; ++i)\n    mat[i][i] = 1;\n  return mat;\n}\n\ndouble **new_diag_matrix2(double *diag, int n) {\n  double **mat = new_matrix2(n, n);\n  int i;\n  for (i = 0; i < n; ++i) {\n    mat[i][i] = diag[i];\n  }\n  return mat;\n}\n\nint **new_diag_matrix2i(int *diag, int n) {\n  int **mat = new_matrix2i(n, n);\n  int i;\n  for (i = 0; i < n; ++i) {\n    mat[i][i] = diag[i];\n  }\n  return mat;\n}\n\n// free a 2d matrix of doubles\nvoid free_matrix2(double **X)\n{\n  if (X == NULL) return;\n  free(X[0]);\n  free(X);\n}\n\n// free a 2d matrix of floats\nvoid free_matrix2f(float **X)\n{\n  if (X == NULL) return;\n  free(X[0]);\n  free(X);\n}\n\n// free a 2d matrix of ints\nvoid free_matrix2i(int **X)\n{\n  if (X == NULL) return;\n  free(X[0]);\n  free(X);\n}\n\n// free a 2d matrix of chars\nvoid free_matrix2c(char **X)\n{\n  if (X == NULL) return;\n  free(X[0]);\n  free(X);\n}\n\n/*\n * Write a matrix in the following format.\n *\n * <nrows> <ncols>\n * <row 1>\n * <row 2>\n * ...\n */\nvoid save_matrix(const char *fout, double **X, int n, int m)\n{\n  //fprintf(stderr, \"saving matrix to %s\\n\", fout);\n\n  FILE *f = fopen(fout, \"w\");\n  int i, j;\n\n  fprintf(f, \"%d %d\\n\", n, m);\n  for (i = 0; i < n; i++) {\n    for (j = 0; j < m; j++)\n      fprintf(f, \"%f \", X[i][j]);\n    fprintf(f, \"\\n\");\n  }\n\n  fclose(f);\n}\n\nvoid save_matrixi(const char *fout, int **X, int n, int m)\n{\n  //fprintf(stderr, \"saving matrix to %s\\n\", fout);\n\n  FILE *f = fopen(fout, \"w\");\n  int i, j;\n\n  fprintf(f, \"%d %d\\n\", n, m);\n  for (i = 0; i < n; i++) {\n    for (j = 0; j < m; j++)\n      fprintf(f, \"%d \", X[i][j]);\n    fprintf(f, \"\\n\");\n  }\n\n  fclose(f);\n}\n\n/*\n * Write a 3d matrix in the following format.\n *\n * <ntabs> <nrows> <ncols>\n * <tab 1 row 1>\n * <tab 1 row 2>\n * ...\n * <tab 2 row 1>\n * <tab 2 row 2>\n * ...\n */\nvoid save_matrix3(const char *fout, double ***X, int n, int m, int p)\n{\n  //fprintf(stderr, \"saving matrix3 to %s\\n\", fout);\n\n  FILE *f = fopen(fout, \"w\");\n  int i, j, k;\n\n  fprintf(f, \"%d %d %d\\n\", n, m, p);\n  for (i = 0; i < n; i++) {\n    for (j = 0; j < m; j++) {\n      for (k = 0; k < p; k++)\n\tfprintf(f, \"%f \", X[i][j][k]);\n      fprintf(f, \"\\n\");\n    }\n  }\n\n  fclose(f);\n}\n\n/*\n * Load a matrix in the following format.\n *\n * <nrows> <ncols>\n * <row 1>\n * <row 2>\n * ...\n */\ndouble **load_matrix(char *fin, int *n, int *m)\n{\n  FILE *f = fopen(fin, \"r\");\n\n  if (f == NULL) {\n    fprintf(stderr, \"Invalid filename: %s\\n\", fin);\n    return NULL;\n  }\n\n  char sbuf0[128], *s = sbuf0;\n  if (fgets(s, 128, f) == NULL || sscanf(s, \"%d %d\", n, m) < 2) {\n    fprintf(stderr, \"Corrupt matrix header in file %s\\n\", fin);\n    fclose(f);\n    return NULL;\n  }\n\n  double **X = new_matrix2(*n, *m);\n\n  const int CHARS_PER_FLOAT = 20;\n  const int buflen = CHARS_PER_FLOAT * (*m);\n  char sbuf[buflen];\n\n  int i, j;\n  for (i = 0; i < *n; i++) {\n    s = sbuf;\n    if (fgets(s, buflen, f) == NULL)\n      break;\n    for (j = 0; j < *m; j++) {\n      if (sscanf(s, \"%lf\", &X[i][j]) < 1)\n\tbreak;\n      s = sword(s, \" \\t\", 1);\n    }\n    if (j < *m)\n      break;\n  }\n  if (i < *n) {\n    fprintf(stderr, \"Corrupt matrix file '%s' at line %d, element %d\\n\", fin, i+2, j+1);\n    fclose(f);\n    free_matrix2(X);\n    return NULL;\n  }\n\n  fclose(f);\n\n  return X;\n}\n\n/*\n * Load a 3d matrix in the following format.\n *\n * <ntabs> <nrows> <ncols>\n * <tab 1 row 1>\n * <tab 1 row 2>\n * ...\n * <tab 2 row 1>\n * <tab 2 row 2>\n * ...\n */\ndouble ***load_matrix3(char *fin, int *n, int *m, int *p)\n{\n  FILE *f = fopen(fin, \"r\");\n\n  if (f == NULL) {\n    fprintf(stderr, \"Invalid filename: %s\\n\", fin);\n    return NULL;\n  }\n\n  char sbuf0[128], *s = sbuf0;\n  if (fgets(s, 128, f) == NULL || sscanf(s, \"%d %d %d\", n, m, p) < 3) {\n    fprintf(stderr, \"Corrupt matrix header in file %s\\n\", fin);\n    fclose(f);\n    return NULL;\n  }\n\n  double ***X = new_matrix3(*n, *m, *p);\n\n  const int CHARS_PER_FLOAT = 20;\n  const int buflen = CHARS_PER_FLOAT * (*p);\n  char sbuf[buflen];\n\n  int i, j, k;\n  for (i = 0; i < *n; i++) {\n    for (j = 0; j < *m; j++) {\n      s = sbuf;\n      if (fgets(s, buflen, f) == NULL)\n\tbreak;\n      for (k = 0; k < *p; k++) {\n\tif (sscanf(s, \"%lf\", &X[i][j][k]) < 1)\n\t  break;\n\ts = sword(s, \" \\t\", 1);\n      }\n      if (k < *p)\n\tbreak;\n    }\n    if (j < *m)\n      break;\n  }\n  if (i < *n) {\n    fprintf(stderr, \"Corrupt matrix file '%s' at line %d\\n\", fin, i*(*m)+j+2);\n    fclose(f);\n    free_matrix3(X);\n    return NULL;\n  }\n\n  fclose(f);\n\n  return X;\n}\n\n\n// calculate the area of a triangle\ndouble triangle_area(double x[], double y[], double z[], int n)\n{\n  double a = dist(x, y, n);\n  double b = dist(x, z, n);\n  double c = dist(y, z, n);\n  double s = .5*(a + b + c);\n\n  return sqrt(s*(s-a)*(s-b)*(s-c));\n}\n\n\n// calculate the volume of a tetrahedron\ndouble tetrahedron_volume(double x1[], double x2[], double x3[], double x4[], int n)\n{\n  double U = dist2(x1, x2, n);\n  double V = dist2(x1, x3, n);\n  double W = dist2(x2, x3, n);\n  double u = dist2(x3, x4, n);\n  double v = dist2(x2, x4, n);\n  double w = dist2(x1, x4, n);\n\n  double a = v+w-U;\n  double b = w+u-V;\n  double c = u+v-W;\n\n  return sqrt( (4*u*v*w - u*a*a - v*b*b - w*c*c + a*b*c) ) / 12.0 ;\n}\n\n\n// calculate the volume of a tetrahedron\ninline double tetrahedron_volume_old(double x[], double y[], double z[], double w[], int n)\n{\n  // make an orthonormal basis in the xyz plane (with x at the origin)\n  double u[n], v[n], v_proj[n];\n  sub(u, y, x, n);             // u = y-x\n  sub(v, z, x, n);             // v = z-x\n  proj(v_proj, v, u, n);       // project v onto u\n  sub(v, v, v_proj, n);        // v -= v_proj\n  mult(u, u, 1/norm(u,n), n);  // normalize u\n  mult(v, v, 1/norm(v,n), n);  // normalize v\n\n  // project (w-x) onto xyz plane\n  double w2[n], wu[n], wv[n], w_proj[n];\n  sub(w2, w, x, n);            // w2 = w-x\n  proj(wu, w2, u, n);          // project w2 onto u\n  proj(wv, w2, v, n);          // project w2 onto v\n  add(w_proj, wu, wv, n);      // w_proj = wu + wv\n  sub(w2, w2, w_proj, n);      // w2 -= w_proj\n\n  double h = norm(w2, n);  // height\n  double A = triangle_area(x, y, z, n);\n\n  return h*A/3.0;\n}\n\n\n// transpose a matrix\nvoid transpose(double **Y, double **X, int n, int m)\n{\n  double **X2 = X;\n  if (Y == X)\n    X2 = matrix_clone(X,n,m);\n\n  int i, j;\n  for (i = 0; i < n; i++)\n    for (j = 0; j < m; j++)\n      Y[j][i] = X2[i][j];\n\n  if (Y == X)\n    free_matrix2(X2);\n}\n\n\n/*\nint test_matrix_copy()\n{\n  double X_data[6] = {1,2,3,4,5,6};\n  double **X = new_matrix2_data(3,2, X_data);\n\n  //double **X = new_matrix2(2,2);\n  //X[0][0] = 1;\n  //X[0][1] = 2;\n  //X[1][0] = 3;\n  //X[1][1] = 4;\n\n  \n\n  \n  // 1 2\n  // 3 4\n\n\n}\n*/\n\n// matrix copy, Y = X \nvoid matrix_copy(double **Y, double **X, int n, int m)\n{\n  memcpy(Y[0], X[0], n*m*sizeof(double));\n}\n\n\n// matrix clone, Y = new(X)\ndouble **matrix_clone(double **X, int n, int m)\n{\n  double **Y = new_matrix2(n,m);\n  matrix_copy(Y, X, n, m);\n\n  return Y;\n}\n\n\n// matrix addition, Z = X+Y\nvoid matrix_add(double **Z, double **X, double **Y, int n, int m)\n{\n  add(Z[0], X[0], Y[0], n*m);\n}\n\n// matrix subtraction, Z = X-Y\nvoid matrix_sub(double **Z, double **X, double **Y, int n, int m)\n{\n  sub(Z[0], X[0], Y[0], n*m);\n}\n\n// matrix multiplication, Z = X*Y, where X is n-by-p and Y is p-by-m\nvoid matrix_mult(double **Z, double **X, double **Y, int n, int p, int m)\n{\n  double **Z2 = (Z==X || Z==Y ? new_matrix2(n,m) : Z);\n  int i, j, k;\n  for (i = 0; i < n; i++) {     // row i\n    for (j = 0; j < m; j++) {   // column j\n      Z2[i][j] = 0;\n      for (k = 0; k < p; k++)\n\tZ2[i][j] += X[i][k]*Y[k][j];\n    }\n  }\n  if (Z==X || Z==Y) {\n    matrix_copy(Z, Z2, n, m);\n    free_matrix2(Z2);\n  }\n}\n\n\n// matrix-vector multiplication, y = A*x\nvoid matrix_vec_mult(double *y, double **A, double *x, int n, int m)\n{\n  int i;\n  if (y == x) {\n    double z[m];\n    memcpy(z, x, m*sizeof(double));\n    for (i = 0; i < n; i++)\n      y[i] = dot(A[i], z, m);\n  }\n  else\n    for (i = 0; i < n; i++)\n      y[i] = dot(A[i], x, m);\n}\n\n// vector-matrix multiplication, y = x*A\nvoid vec_matrix_mult(double *y, double *x, double **A, int n, int m)\n{\n  int i, j;\n  if (y == x) {\n    double z[n];\n    memcpy(z, x, n*sizeof(double));\n    for (j = 0; j < m; j++) {\n      y[j] = 0;\n      for (i = 0; i < n; i++)\n\ty[j] += z[i]*A[i][j];\n    }\n  }\n  else {\n    for (j = 0; j < m; j++) {\n      y[j] = 0;\n      for (i = 0; i < n; i++)\n\ty[j] += x[i]*A[i][j];\n    }\n  }\n}\n\n// matrix element-wise multiplication\nvoid matrix_elt_mult(double **Z, double **X, double **Y, int n, int m) {\n  int i, j;\n  for (i = 0; i < n; ++i) {\n    for (j = 0; j < m; ++j) {\n      Z[i][j] = X[i][j] * Y[i][j];\n    }\n  }\n}\n\nvoid matrix_pow(double **Y, double **X, int n, int m, double pw) {\n  int i, j;\n  for (i = 0; i < n; ++i)\n    for (j = 0; j < m; ++j)\n      Y[i][j] = pow(X[i][j], pw);\n}\n\nvoid matrix_sum(double y[], double **X, int n, int m) {\n  int i, j;\n  memset(y, 0, n * sizeof(double));\n  for (i = 0; i < n; ++i) {\n    for (j = 0; j < m; ++j) {\n      y[j] += X[i][j];\n    }\n  }\n}\n\n// outer product of x and y, Z = x'*y\nvoid outer_prod(double **Z, double x[], double y[], int n, int m)\n{\n  int i, j;\n  for (i = 0; i < n; i++)\n    for (j = 0; j < m; j++)\n      Z[i][j] = x[i]*y[j];\n}\n\n\n// row vector min\nvoid row_min(double *y, double **X, int n, int m)\n{\n  int i,j;\n  memcpy(y, X[0], m*sizeof(double));\n  for (i = 1; i < n; i++)\n    for (j = 0; j < m; j++)\n      if (X[i][j] < y[j])\n\ty[j] = X[i][j];\n}\n\n\n// row vector max\nvoid row_max(double *y, double **X, int n, int m)\n{\n  int i,j;\n  memcpy(y, X[0], m*sizeof(double));\n  for (i = 1; i < n; i++)\n    for (j = 0; j < m; j++)\n      if (X[i][j] > y[j])\n\ty[j] = X[i][j];\n}\n\n\n// row vector mean \n// NOTE(sanja): this is adding up columns, not rows.\nvoid mean(double *mu, double **X, int n, int m)\n{\n  memset(mu, 0, m*sizeof(double));  // mu = 0\n\n  int i, j;\n  for (i = 0; i < n; i++)\n    for (j = 0; j < m; j++)\n      mu[j] += X[i][j];\n\n  mult(mu, mu, 1/(double)n, m);\n}\n\nvoid variance(double *vars, double **X, int n, int m)\n{\n  double mu[m];\n  mean(mu, X, n, m);\n  memset(vars, 0, m*sizeof(double));\n  int i, j;\n  for (i = 0; i < n; i++) {\n    for (j = 0; j < m; j++) {\n      double dx = X[i][j] - mu[j];\n      vars[j] += dx*dx;\n    }\n  }\n  mult(vars, vars, 1/(double)n, m);\n}\n\n// compute the covariance of the rows of X, given mean mu\nvoid cov(double **S, double **X, double *mu, int n, int m)\n{\n  int i, j, k;\n\n  memset(S[0], 0, m*m*sizeof(double));\n  double dx[m];\n\n  if (m == 3) {\n    for (i = 0; i < n; i++) {\n      dx[0] = X[i][0] - mu[0];\n      dx[1] = X[i][1] - mu[1];\n      dx[2] = X[i][2] - mu[2];\n      S[0][0] += dx[0]*dx[0];\n      S[0][1] += dx[0]*dx[1];\n      S[0][2] += dx[0]*dx[2];\n      S[1][0] += dx[1]*dx[0];\n      S[1][1] += dx[1]*dx[1];\n      S[1][2] += dx[1]*dx[2];\n      S[2][0] += dx[2]*dx[0];\n      S[2][1] += dx[2]*dx[1];\n      S[2][2] += dx[2]*dx[2];\n    }\n  }\n  else {\n    for (i = 0; i < n; i++) {\n      sub(dx, X[i], mu, m);\n      for (j = 0; j < m; j++)\n\tfor (k = 0; k < m; k++)\n\t  S[j][k] += dx[j]*dx[k];\n    }\n  }\n\n  /*\n  double **dX = matrix_clone(X, n, m);\n  if (mu != NULL)\n    for (i = 0; i < n; i++)\n      sub(dX[i], X[i], mu, m);\n  double **dXt = new_matrix2(m, n);\n  transpose(dXt, dX, n, m);\n  matrix_mult(S, dXt, dX, m, n, m);\n  */\n  mult(S[0], S[0], 1/(double)n, m*m);\n\n  //free_matrix2(dX);\n  //free_matrix2(dXt);\n}\n\n\n// weighted row vector mean\nvoid wmean(double *mu, double **X, double *w, int n, int m)\n{\n  memset(mu, 0, m*sizeof(double));  // mu = 0\n\n  int i, j;\n  for (i = 0; i < n; i++)\n    for (j = 0; j < m; j++)\n      mu[j] += w[i]*X[i][j];\n\n  mult(mu, mu, 1.0/sum(w,n), m);\n}\n\n\n// compute the weighted covariance of the rows of X, given mean mu\nvoid wcov(double **S, double **X, double *w, double *mu, int n, int m)\n{\n  int i;\n\n  memset(S[0], 0, m*m*sizeof(double));\n\n  double **Si = new_matrix2(m,m);\n  for (i = 0; i < n; i++) {\n    outer_prod(Si, X[i], X[i], m, m);\n    mult(Si[0], Si[0], w[i], m*m);\n    matrix_add(S, S, Si, m, m);\n  }\n\n  mult(S[0], S[0], 1.0/sum(w,n), m*m);\n\n  if (mu != NULL) {\n    double **S_mu = new_matrix2(m,m);\n    outer_prod(S_mu, mu, mu, m, m);\n    sub(S[0], S[0], S_mu[0], m*m);\n    free_matrix2(S_mu);\n  }\n}\n\n\n// solve the equation Ax = b, where A is a square n-by-n matrix\nvoid solve(double *x, double **A, double *b, int n)\n{\n  double **A_inv = new_matrix2(n,n);\n  inv(A_inv, A, n);\n\n  int i;\n  for (i = 0; i < n; i++)\n    x[i] = dot(A_inv[i], b, n);\n\n  free_matrix2(A_inv);\n}\n\n\n// compute the determinant of the n-by-n matrix X\ndouble det(double **X, int n)\n{\n  if (n == 1)\n    return X[0][0];\n\n  else if (n == 2)\n    return X[0][0]*X[1][1] - X[0][1]*X[1][0];\n\n  else if (n == 3) {\n    double a = X[0][0];\n    double b = X[0][1];\n    double c = X[0][2];\n    double d = X[1][0];\n    double e = X[1][1];\n    double f = X[1][2];\n    double g = X[2][0];\n    double h = X[2][1];\n    double i = X[2][2];\n    return a*e*i - a*f*h + b*f*g - b*d*i + c*d*h - c*e*g;\n  }\n\n  else if (n == 4) {\n    double a00 = X[0][0];\n    double a01 = X[0][1];\n    double a02 = X[0][2];\n    double a03 = X[0][3];\n    double a10 = X[1][0];\n    double a11 = X[1][1];\n    double a12 = X[1][2];\n    double a13 = X[1][3];\n    double a20 = X[2][0];\n    double a21 = X[2][1];\n    double a22 = X[2][2];\n    double a23 = X[2][3];\n    double a30 = X[3][0];\n    double a31 = X[3][1];\n    double a32 = X[3][2];\n    double a33 = X[3][3];\n\n    return a00*a11*a22*a33 - a00*a11*a23*a32 - a00*a12*a21*a33 + a00*a12*a23*a31 + a00*a13*a21*a32\n      - a00*a13*a22*a31 - a01*a10*a22*a33 + a01*a10*a23*a32 + a01*a12*a20*a33 - a01*a12*a23*a30\n      - a01*a13*a20*a32 + a01*a13*a22*a30 + a02*a10*a21*a33 - a02*a10*a23*a31 - a02*a11*a20*a33\n      + a02*a11*a23*a30 + a02*a13*a20*a31 - a02*a13*a21*a30 - a03*a10*a21*a32 + a03*a10*a22*a31\n      + a03*a11*a20*a32 - a03*a11*a22*a30 - a03*a12*a20*a31 + a03*a12*a21*a30;\n\n  }\n\n  else {\n    fprintf(stderr, \"Error: det() not supported for > 4x4 matrices\\n\");\n    exit(1);\n  }\n\n  return 0;\n}\n\n\n// compute the inverse (Y) of the n-by-n matrix X\nvoid inv(double **Y, double **X, int n)\n{\n  double d = det(X,n);\n\n  if (n == 1)\n    Y[0][0] = 1/d;\n\n  else if (n == 2) {\n    Y[0][0] = X[1][1] / d;\n    Y[0][1] = -X[0][1] / d;\n    Y[1][0] = -X[1][0] / d;\n    Y[1][1] = X[0][0] / d;\n  }\n\n  else if (n == 3) {\n    Y[0][0] = (X[1][1]*X[2][2] - X[1][2]*X[2][1]) / d;\n    Y[0][1] = (X[0][2]*X[2][1] - X[0][1]*X[2][2]) / d;\n    Y[0][2] = (X[0][1]*X[1][2] - X[0][2]*X[1][1]) / d;\n    Y[1][0] = (X[1][2]*X[2][0] - X[1][0]*X[2][2]) / d;\n    Y[1][1] = (X[0][0]*X[2][2] - X[0][2]*X[2][0]) / d;\n    Y[1][2] = (X[0][2]*X[1][0] - X[0][0]*X[1][2]) / d;\n    Y[2][0] = (X[1][0]*X[2][1] - X[1][1]*X[2][0]) / d;\n    Y[2][1] = (X[0][1]*X[2][0] - X[0][0]*X[2][1]) / d;\n    Y[2][2] = (X[0][0]*X[1][1] - X[0][1]*X[1][0]) / d;\n  }\n\n  else if (n == 4) {\n    double a00 = X[0][0];\n    double a01 = X[0][1];\n    double a02 = X[0][2];\n    double a03 = X[0][3];\n    double a10 = X[1][0];\n    double a11 = X[1][1];\n    double a12 = X[1][2];\n    double a13 = X[1][3];\n    double a20 = X[2][0];\n    double a21 = X[2][1];\n    double a22 = X[2][2];\n    double a23 = X[2][3];\n    double a30 = X[3][0];\n    double a31 = X[3][1];\n    double a32 = X[3][2];\n    double a33 = X[3][3];\n\n    Y[0][0] = (a11*a22*a33 - a11*a23*a32 - a12*a21*a33 + a12*a23*a31 + a13*a21*a32 - a13*a22*a31) / d;\n    Y[0][1] = (a01*a23*a32 - a01*a22*a33 + a02*a21*a33 - a02*a23*a31 - a03*a21*a32 + a03*a22*a31) / d;\n    Y[0][2] = (a01*a12*a33 - a01*a13*a32 - a02*a11*a33 + a02*a13*a31 + a03*a11*a32 - a03*a12*a31) / d;\n    Y[0][3] = (a01*a13*a22 - a01*a12*a23 + a02*a11*a23 - a02*a13*a21 - a03*a11*a22 + a03*a12*a21) / d;\n    Y[1][0] = (a10*a23*a32 - a10*a22*a33 + a12*a20*a33 - a12*a23*a30 - a13*a20*a32 + a13*a22*a30) / d;\n    Y[1][1] = (a00*a22*a33 - a00*a23*a32 - a02*a20*a33 + a02*a23*a30 + a03*a20*a32 - a03*a22*a30) / d;\n    Y[1][2] = (a00*a13*a32 - a00*a12*a33 + a02*a10*a33 - a02*a13*a30 - a03*a10*a32 + a03*a12*a30) / d;\n    Y[1][3] = (a00*a12*a23 - a00*a13*a22 - a02*a10*a23 + a02*a13*a20 + a03*a10*a22 - a03*a12*a20) / d;\n    Y[2][0] = (a10*a21*a33 - a10*a23*a31 - a11*a20*a33 + a11*a23*a30 + a13*a20*a31 - a13*a21*a30) / d;\n    Y[2][1] = (a00*a23*a31 - a00*a21*a33 + a01*a20*a33 - a01*a23*a30 - a03*a20*a31 + a03*a21*a30) / d;\n    Y[2][2] = (a00*a11*a33 - a00*a13*a31 - a01*a10*a33 + a01*a13*a30 + a03*a10*a31 - a03*a11*a30) / d;\n    Y[2][3] = (a00*a13*a21 - a00*a11*a23 + a01*a10*a23 - a01*a13*a20 - a03*a10*a21 + a03*a11*a20) / d;\n    Y[3][0] = (a10*a22*a31 - a10*a21*a32 + a11*a20*a32 - a11*a22*a30 - a12*a20*a31 + a12*a21*a30) / d;\n    Y[3][1] = (a00*a21*a32 - a00*a22*a31 - a01*a20*a32 + a01*a22*a30 + a02*a20*a31 - a02*a21*a30) / d;\n    Y[3][2] = (a00*a12*a31 - a00*a11*a32 + a01*a10*a32 - a01*a12*a30 - a02*a10*a31 + a02*a11*a30) / d;\n    Y[3][3] = (a00*a11*a22 - a00*a12*a21 - a01*a10*a22 + a01*a12*a20 + a02*a10*a21 - a02*a11*a20) / d;\n  }\n\n  else {\n    fprintf(stderr, \"Error: inv() not supported for > 4x4 matrices\\n\");\n    exit(1);\n  }\n}\n\n/**\n * Solves the quadratic equation: f(x) = a*x^2 + b*x + c\n * Sets x[0] and x[1] to be the real roots of f(x), if found.\n * Returns the number of real roots found.\n */\nint solve_quadratic(double *x, double a, double b, double c)\n{\n  double s2 = b*b - 4*a*c;\n  if (s2 < 0.0)\n    return 0;\n\n  double s = sqrt(s2);\n  x[0] = .5*(-b + s)/a;\n  x[1] = .5*(-b - s)/a;\n\n  return 2;\n}\n\n/**\n * Solves the cubic equation: f(x) = a*x^3 + b*x^2 + c*x + d\n * Sets x[0], x[1], and x[2] to be the real roots of f(x), if found.\n * Returns the number of real roots found.\n *\nint solve_cubic(double *x, double a, double b, double c, double d)\n{\n  double p = -b/(3.0*a);\n  double q = p*p*p + (b*c - 3.0*a*d)/(6*a*a);\n  double r = c/(3.0*a);\n    \n}\n*/\n\n\n/**\n * Compute the eigenvalues z and eigenvectors V of a real symmetric n-by-n matrix X\n * The eigenvalues, z, will be sorted from smallest to largest in magnitude, and the\n * eigenvectors will be stored in the rows of V.\n * @param X (input) Symmetric n-by-n matrix\n * @param n (input) Dimensionality of X\n * @param z (output) Eigenvalues of X, from smallest to largest in magnitude\n * @param V (output) Eigenvectors of X, in the rows\n */\n\n/*\nvoid eigen_symm(double z[], double **V, double **X, int n)\n{\n  double **Vt = matrix_clone(X,n,n);\n  double z2[n];\n  int i, j;\n\n  //TODO: replace this with solve_cubic() for n < 4\n\n  int info = LAPACKE_dsyevd(LAPACK_COL_MAJOR, 'V', 'U', n, Vt[0], n, z2);\n  if (info)\n    fprintf(stderr, \"Error: eigen_symm failed to converge!\\n\");\n\n  // sort eigenvalues\n  double tolerance = 1e-10;\n  int idx[n];\n  sort_indices(z2, idx, n);\n  if (z2[idx[0]] < -tolerance)  // negative eigenvalues --> sort in reverse order\n    reversei(idx, idx, n);\n  for (i = 0; i < n; i++)\n    z[i] = z2[idx[i]];\n  for (i = 0; i < n; i++)\n    for (j = 0; j < n; j++)\n      V[i][j] = Vt[j][idx[i]];\n\n  //cleanup\n  free_matrix2(Vt);\n}\n*/\n\n\nvoid eigen_symm_2d(double z[], double **V, double **X)\n{\n  double a = X[0][0];\n  double b = X[0][1];\n  double c = X[1][1];\n\n  const double epsilon = 1e-16;\n\n  if (b*b < epsilon * fabs(a*c)) {\n    if (fabs(a) < fabs(c)) {\n      z[0] = a;\n      z[1] = c;\n      V[0][0] = V[1][1] = 1.0;\n      V[0][1] = V[1][0] = 0.0;\n    }\n    else {\n      z[0] = c;\n      z[1] = a;\n      V[0][0] = V[1][1] = 0.0;\n      V[0][1] = V[1][0] = 1.0;\n    }\n    return;\n  }\n\n  double s = sqrt((a+c)*(a+c) + 4.*(b*b-a*c));\n  double z1 = (a+c+s)/2.;\n  double z2 = (a+c-s)/2.;\n  if (fabs(z1) < fabs(z2)) {\n    z[0] = z1;\n    z[1] = z2;\n  }\n  else {\n    z[1] = z1;\n    z[0] = z2;\n  }\n\n  double d0 = hypot(b, z[0]-a);\n  double d1 = hypot(b, z[1]-a);\n  V[0][0] = b/d0;\n  V[0][1] = (z[0]-a)/d0;\n  V[1][0] = b/d1;\n  V[1][1] = (z[1]-a)/d1;\n}\n\n\nvoid eigen_symm(double z[], double **V, double **X, int n)\n{\n  if (n == 2) {\n    eigen_symm_2d(z,V,X);\n    return;\n  }\n\n  // naive Jacobi method\n  int i, j;\n  double tolerance = 1e-10;\n  double **A = matrix_clone(X,n,n);\n  double **B = new_matrix2(n,n);\n  double **G = new_matrix2(n,n);\n  double **Gt = new_matrix2(n,n);\n\n  int cnt = 1; //dbug\n\n  // initialize V = I\n  for (i = 0; i < n; i++) {\n    V[i][i] = 1;\n    for (j = i+1; j < n; j++)\n      V[i][j] = V[j][i] = 0;\n  }\n\n  //printf(\"break 1\\n\");  //dbug\n\n  while (1) {\n\n    //dbug\n    //printf(\"A:\\n\");\n    //print_matrix(A, n, n);\n    //printf(\"\\n\");\n\n    // check for convergence\n    double d_off = 0, d_diag = 0;\n    for (i = 0; i < n; i++) {\n      d_diag += A[i][i]*A[i][i];\n      for (j = i+1; j < n; j++)\n\td_off = MAX(d_off, fabs(A[i][j]));\n    }\n    d_diag = sqrt(d_diag / (double)n);\n    if (d_off < MAX(tolerance * d_diag, tolerance))\n      break;\n\n    //dbug\n    if (cnt++ % 1000 == 0) {\n      printf(\"d_off = %e, d_diag = %e\\n\", d_off, d_diag);  //dbug\n      if (!isfinite(d_off) || !isfinite(d_diag))\n\treturn;\n    }\n\n    // find largest pivot\n    double pivot = 0;\n    int ip=0, jp=0;\n    for (i = 0; i < n; i++) {\n      for (j = i+1; j < n; j++) {\n\tdouble p = fabs(A[i][j]);\n\tif (p > pivot) {\n\t  pivot = p;\n\t  ip = i;\n\t  jp = j;\n\t}\n      }\n    }\n\n    //printf(\"pivot = %f, ip = %d, jp = %d\\n\", pivot, ip, jp);  //dbug\n    \n    // compute Givens cos, sin\n    double a = (A[jp][jp] - A[ip][ip]) / (2 * A[ip][jp]);\n    double t = 1 / (fabs(a) + sqrt(1 + a*a));  // tan\n    if (a < 0)\n      t = -t;\n    double c = 1 / sqrt(1 + t*t);  // cos\n    double s = t*c;  // sin\n\n    //printf(\"a = %f, t = %f, c = %f, s = %f\\n\", a, t, c, s);  //dbug\n\n    // compute Givens rotation matrix\n    for (i = 0; i < n; i++) {\n      G[i][i] = 1;\n      for (j = i+1; j < n; j++)\n\tG[i][j] = G[j][i] = 0;\n    }\n    G[ip][ip] = G[jp][jp] = c;\n    G[ip][jp] = s;\n    G[jp][ip] = -s;\n\n    //dbug\n    //printf(\"givens rotation matrix:\\n\");\n    //print_matrix(G, n, n);\n    //printf(\"\\n\");\n    \n    // compute new A\n    transpose(Gt, G, n, n);\n    matrix_mult(B, A, G, n, n, n);   // B = A*G\n    matrix_mult(A, Gt, B, n, n, n);  // A = Gt*B\n    \n    // compute new V (with eigenvectors in the rows)\n    matrix_mult(B, Gt, V, n, n, n);  // B = Gt*V\n    matrix_copy(V, B, n, n);     // V = B;\n  }\n\n  //printf(\"break 2\\n\");  //dbug\n\n  // sort eigenvalues\n  int idx[n];\n  double z2[n];\n  for (i = 0; i < n; i++)\n    z[i] = A[i][i];\n  sort_indices(z, idx, n);\n  if (z[idx[0]] < -tolerance) {  // negative eigenvalues --> sort in reverse order\n    reversei(idx, idx, n);\n    //for (i = 0; i < n/2; i++) {\n    //  int tmp = idx[i];\n    //  idx[i] = idx[n-i-1];\n    //  idx[n-i-1] = tmp;\n    //}\n  }\n  for (i = 0; i < n; i++)\n    z2[i] = z[idx[i]];\n  for (i = 0; i < n; i++)\n    z[i] = z2[i];\n  for (i = 0; i < n; i++)\n    for (j = 0; j < n; j++)\n      B[i][j] = V[idx[i]][j];\n  matrix_copy(V, B, n, n);\n\n  free_matrix2(A);\n  free_matrix2(B);\n  free_matrix2(G);\n  free_matrix2(Gt);\n}\n\n\n// reorder the rows of X, Y = X(idx,:)\nvoid reorder_rows(double **Y, double **X, int *idx, int n, int m)\n{\n  int i;\n  double **Y2 = (X==Y ? new_matrix2(n,m) : Y);\n  for (i = 0; i < n; i++)\n    memcpy(Y2[i], X[idx[i]], m*sizeof(double));\n  if (X==Y) {\n    matrix_copy(Y, Y2, n, m);\n    free_matrix2(Y2);\n  }\n}\n\n// reorder the rows of X, Y = X(idx,:)\nvoid reorder_rowsi(int **Y, int **X, int *idx, int n, int m)\n{\n  int i;\n  int **Y2 = (X==Y ? new_matrix2i(n,m) : Y);\n  for (i = 0; i < n; i++)\n    memcpy(Y2[i], X[idx[i]], m*sizeof(int));\n  if (X==Y) {\n    memcpy(Y[0], Y2[0], n*m*sizeof(int));\n    free_matrix2i(Y2);\n  }\n}\n\nvoid repmat(double **B, double **A, int rep_n, int rep_m, int n, int m)\n{\n  int i, rep_i, rep_j;\n\n  // copy A into top-left corner of B\n  if (A != B)\n    for (i = 0; i < n; ++i)\n      memcpy(B[i], A[i], m * sizeof(double)); \n\n  // repeat top-left corner to the right\n  for (i = 0; i < n; ++i)\n    for (rep_j = 1; rep_j < rep_m; ++rep_j)\n      memcpy(&B[i][rep_j * m], B[i], m * sizeof(double)); \n\n  // repeat top of B downwards\n  for (rep_i = 1; rep_i < rep_n; ++rep_i)\n    memcpy(B[rep_i * n], B[0], m * rep_m * n * sizeof(double));\n}\n\nvoid repmati(int **B, int **A, int rep_n, int rep_m, int n, int m)\n{\n  int i, rep_i, rep_j;\n\n  // copy A into top-left corner of B\n  if (A != B)\n    for (i = 0; i < n; ++i)\n      memcpy(B[i], A[i], m * sizeof(int)); \n\n  // repeat top-left corner to the right\n  for (i = 0; i < n; ++i)\n    for (rep_j = 1; rep_j < rep_m; ++rep_j)\n      memcpy(&B[i][rep_j * m], B[i], m * sizeof(int)); \n\n  // repeat top of B downwards\n  for (rep_i = 1; rep_i < rep_n; ++rep_i)\n    memcpy(B[rep_i * n], B[0], m * rep_m * n * sizeof(int));\n}\n\n/*\n * blur matrix with a 3x3 gaussian filter with sigma=.5\n */\nvoid blur_matrix(double **dst, double **src, int n, int m)\n{\n  double G[3] = {.6193, .0838, .0113};\n\n  double **I = (dst==src ? new_matrix2(n,m) : dst);\n  memcpy(I[0], src[0], n*m*sizeof(double));\n\n  int i,j;\n  for (i = 1; i < n-1; i++)\n    for (j = 1; j < m-1; j++)\n      I[i][j] = G[0]*src[i][j] + G[1]*(src[i+1][j] + src[i-1][j] + src[i][j+1] + src[i][j-1]) + G[2]*(src[i+1][j+1] + src[i+1][j-1] + src[i-1][j+1] + src[i-1][j-1]);\n\n  if (dst==src) {\n    memcpy(dst[0], I[0], n*m*sizeof(double));\n    free_matrix2(I);\n  }\n}\n\n/*\n * blur masked matrix with a 3x3 gaussian filter with sigma=.5\n */\nvoid blur_matrix_masked(double **dst, double **src, int **mask, int n, int m)\n{\n  double G[3] = {.6193, .0838, .0113};\n\n  double **I = (dst==src ? new_matrix2(n,m) : dst);\n  memcpy(I[0], src[0], n*m*sizeof(double));\n\n  int i,j;\n  for (i = 1; i < n-1; i++) {\n    for (j = 1; j < m-1; j++) {\n      double x[9] = {mask[i][j] ? src[i][j] : 0., mask[i+1][j] ? src[i+1][j] : 0., mask[i-1][j] ? src[i-1][j] : 0., mask[i][j+1] ? src[i][j+1] : 0., mask[i][j-1] ? src[i][j-1] : 0.,\n\t\t  mask[i+1][j+1] ? src[i+1][j+1] : 0., mask[i+1][j-1] ? src[i+1][j-1] : 0., mask[i-1][j+1] ? src[i-1][j+1] : 0., mask[i-1][j-1] ? src[i-1][j-1] : 0.};\n\n      double v = G[0]*x[0] + G[1]*(x[1] + x[2] + x[3] + x[4]) + G[2]*(x[5] + x[6] + x[7] + x[8]);\n\n      int n0 = !!mask[i][j];\n      int n1 = !!mask[i+1][j] + !!mask[i-1][j] + !!mask[i][j+1] + !!mask[i][j-1];\n      int n2 = !!mask[i+1][j+1] + !!mask[i-1][j-1] + !!mask[i-1][j+1] + !!mask[i+1][j-1];\n      double g_tot = n0*G[0] + n1*G[1] + n2*G[2];\n\n      I[i][j] = v / g_tot;\n    }\n  }\n\n  if (dst==src) {\n    memcpy(dst[0], I[0], n*m*sizeof(double));\n    free_matrix2(I);\n  }\n}\n\nvoid print_matrix(double **X, int n, int m)\n{\n  int i, j;\n  for (i = 0; i < n; i++) {\n    for (j = 0; j < m; j++)\n      printf(\"%f \", X[i][j]);\n    printf(\"\\n\");\n  }\n}\n\n\n// perform linear regression: dot(b,x[i]) = y[i], i=1..n\nvoid linear_regression(double *b, double **X, double *y, int n, int d)\n{\n  double **Xt = new_matrix2(d,n);\n  transpose(Xt,X,n,d);\n\n  double **XtX = new_matrix2(d,d);\n  matrix_mult(XtX,Xt,X,d,n,d);\n\n  double Xty[d];\n  matrix_vec_mult(Xty,Xt,y,d,n);\n\n  solve(b, XtX, Xty, d);\n\n  free_matrix2(Xt);\n  free_matrix2(XtX);\n}\n\n\n// fit a polynomial: \\sum{b[i]*x[j]^i} = y[j], i=1..n, j=1..d\nvoid polynomial_regression(double *b, double *x, double *y, int n, int d)\n{\n  double **X = new_matrix2(n,d);\n\n  int i, j;\n  for (i = 0; i < n; i++)\n    X[i][0] = 1;\n\n  for (i = 0; i < n; i++)\n    for (j = 1; j < d; j++)\n      X[i][j] = X[i][j-1]*x[i];\n\n  linear_regression(b,X,y,n,d);\n\n  free_matrix2(X);\n}\n\n\n\n\n\n\n/* create a new graph\ngraph_t *graph_new(int num_vertices, int edge_capacity)\n{\n  int i;\n  graph_t *g = (graph_t *)malloc(sizeof(graph_t));\n\n  g->nv = num_vertices;\n  g->vertices = (vertex_t *)calloc(g->nv, sizeof(vertex_t));\n  for (i = 0; i < g->nv; i++)\n    g->vertices[i].index = i;\n\n  g->ne = 0;\n  g->_edge_capacity = edge_capacity;\n  g->edges = (edge_t *)calloc(edge_capacity, sizeof(edge_t));\n\n  return g;\n}\n*/\n\n\n// free a graph\nvoid graph_free(graph_t *g)\n{\n  int i;\n  free(g->edges);\n  for (i = 0; i < g->nv; i++) {\n    free(g->vertices[i].edges);\n    ilist_free(g->vertices[i].neighbors);\n  }\n  free(g);\n}\n\n\n/* add an edge to a graph\nvoid graph_add_edge(graph_t *g, int i, int j)\n{\n  ilist\n  for \n\n\n  if (g->ne == g->_edge_capacity) {\n    g->_edge_capacity *= 2;\n    g->edges = (edge_t *)realloc(g->edges, g->_edge_capacity * sizeof(edge_t));\n  }\n\n  g->edges[g->ne].i = i;\n  g->edges[g->ne].j = j;\n  g->ne++;\n\n  g->vertices[i]\n}\n*/\n\n\n// find the index of an edge in a graph\nint graph_find_edge(graph_t *g, int i, int j)\n{\n  int k = ilist_find(g->vertices[i].neighbors, j);\n\n  if (k < 0)\n    return -1;\n\n  return g->vertices[i].edges[k];\n}\n\n\n// smooth the edges of a graph\nvoid graph_smooth(double **dst, double **src, graph_t *g, int d, double w)\n{\n  int i, j;\n  double p[d];\n  ilist_t *v;\n\n  if (dst != src)\n    memcpy(dst[0], src[0], d*g->nv*sizeof(double));\n\n  for (i = 0; i < g->nv; i++) {\n    memset(p, 0, d * sizeof(double));                        // p = 0\n    for (v = g->vertices[i].neighbors; v; v = v->next) {\n      j = v->x;\n      add(p, p, dst[j], d);                                  // p += dst[j]\n    }\n    mult(p, p, 1/norm(p, d), d);                             // p = p/norm(p)\n\n    wavg(dst[i], p, dst[i], w, d);                           // dst[i] = w*p + (1-w)*dst[i]\n  }\n}\n\n\nstatic int dcomp(const void *px, const void *py)\n{\n  double x = *(double *)px;\n  double y = *(double *)py;\n\n  if (x == y)\n    return 0;\n\n  return (x < y ? -1 : 1);\n}\n\n// sample uniformly from a simplex S with n vertices\nvoid sample_simplex(double x[], double **S, int n, int d)\n{\n  int i;\n\n  // get n-1 uniform samples, u, on [0,1], and sort them\n  double u[n];\n  for (i = 0; i < n-1; i++)\n    u[i] = frand();\n  u[n-1] = 1;\n\n  qsort((void *)u, n-1, sizeof(double), dcomp);\n\n  // mixing coefficients are the order statistics of u\n  double c[n];\n  c[0] = u[0];\n  for (i = 1; i < n; i++)\n    c[i] = u[i] - u[i-1];\n\n  // x = sum(c[i]*S[i])\n  mult(x, S[0], c[0], d);\n  for (i = 1; i < n; i++) {\n    double y[d];\n    mult(y, S[i], c[i], d);\n    add(x, x, y, d);\n  }\n}\n\n\n/*******************\ntypedef struct {\n  int nv;\n  int ne;\n  int nf;\n  int *vertices;\n  edge_t *edges;\n  face_t *faces;\n  int *nvn;  // # vertex neighbors\n  int *nen;  // # edge neighbors\n  int **vertex_neighbors;  // vertex -> {vertices}\n  int **vertex_edges;      // vertex -> {edges}\n  int **edge_neighbors;    // edge -> {vertices}\n  int **edge_faces;        // edge -> {faces}\n  // internal vars\n  int _vcap;\n  int _ecap;\n  int _fcap;\n  int *_vncap;\n  int *_encap;\n} meshgraph_t;\n******************/\n\n\n/*\n * Create a new meshgraph with initial vertex capacity 'vcap' and degree capacity 'dcap'.\n */\nmeshgraph_t *meshgraph_new(int vcap, int dcap)\n{\n  int i;\n  meshgraph_t *g;\n  safe_calloc(g, 1, meshgraph_t);\n\n  safe_malloc(g->vertices, vcap, int);\n  safe_malloc(g->edges, vcap, edge_t);\n  safe_malloc(g->faces, vcap, face_t);\n\n  g->_vcap = g->_ecap = g->_fcap = vcap;\n  safe_malloc(g->_vncap, vcap, int);\n  safe_malloc(g->_encap, vcap, int);\n\n  safe_malloc(g->vertex_neighbors, vcap, int *);\n  safe_malloc(g->vertex_edges, vcap, int *);\n  safe_calloc(g->nvn, vcap, int);\n  for (i = 0; i < vcap; i++) {\n    safe_malloc(g->vertex_neighbors[i], dcap, int);\n    safe_malloc(g->vertex_edges[i], dcap, int);\n    g->_vncap[i] = dcap;\n  }\n\n  safe_malloc(g->edge_neighbors, vcap, int *);\n  safe_malloc(g->edge_faces, vcap, int *);\n  safe_calloc(g->nen, vcap, int);\n  for (i = 0; i < vcap; i++) {\n    safe_malloc(g->edge_neighbors[i], dcap, int);\n    safe_malloc(g->edge_faces[i], dcap, int);\n    g->_encap[i] = dcap;\n  }\n\n  return g;\n}\n\n\nvoid meshgraph_free(meshgraph_t *g)\n{\n  int i;\n\n  free(g->vertices);\n  free(g->edges);\n  free(g->faces);\n  free(g->nvn);\n  free(g->nen);\n  free(g->_vncap);\n  free(g->_encap);\n\n  for (i = 0; i < g->nv; i++) {\n    free(g->vertex_neighbors[i]);\n    free(g->vertex_edges[i]);\n  }\n  free(g->vertex_neighbors);\n  free(g->vertex_edges);\n\n  for (i = 0; i < g->ne; i++) {\n    free(g->edge_neighbors[i]);\n    free(g->edge_faces[i]);\n  }\n  free(g->edge_neighbors);\n  free(g->edge_faces);\n\n  free(g);\n}\n\n\nint meshgraph_find_edge(meshgraph_t *g, int i, int j)\n{\n  int n;\n  for (n = 0; n < g->nvn[i]; n++)\n    if (g->vertex_neighbors[i][n] == j)\n      return g->vertex_edges[i][n];\n\n  return -1;\n}\n\n\nint meshgraph_find_face(meshgraph_t *g, int i, int j, int k)\n{\n  int e = meshgraph_find_edge(g, i, j);\n  if (e < 0)\n    return -1;\n\n  int n;\n  for (n = 0; n < g->nen[e]; n++)\n    if (g->edge_neighbors[e][n] == k)\n      return g->edge_faces[e][n];\n\n  return -1;\n}\n\n\nstatic inline int meshgraph_add_vertex_neighbor(meshgraph_t *g, int i, int vertex, int edge)\n{\n  int n = g->nvn[i];\n  if (n == g->_vncap[i]) {\n    g->_vncap[i] *= 2;\n    safe_realloc(g->vertex_neighbors[i], g->_vncap[i], int);\n    safe_realloc(g->vertex_edges[i], g->_vncap[i], int);\n  }\n  g->vertex_neighbors[i][n] = vertex;\n  g->vertex_edges[i][n] = edge;\n  g->nvn[i]++;\n\n  return n;\n}\n\n\nint meshgraph_add_edge(meshgraph_t *g, int i, int j)\n{\n  //printf(\"meshgraph_add_edge(%d, %d)\\n\", i, j);\n\n  int edge = meshgraph_find_edge(g, i, j);\n  if (edge >= 0)\n    return edge;\n\n  //printf(\"  break 1\\n\");\n\n  // add the edge\n  if (g->ne == g->_ecap) {\n    int old_ecap = g->_ecap;\n    g->_ecap *= 2;\n    safe_realloc(g->edges, g->_ecap, edge_t);\n    safe_realloc(g->edge_neighbors, g->_ecap, int *);\n    safe_realloc(g->edge_faces, g->_ecap, int *);\n    safe_realloc(g->nen, g->_ecap, int);\n    safe_realloc(g->_encap, g->_ecap, int);\n\n    //printf(\"  break 1.1\\n\");\n\n    int e;\n    for (e = old_ecap; e < g->_ecap; e++) {\n      //printf(\"    e = %d\\n\", e);\n      g->nen[e] = 0;\n      int dcap = g->_encap[0];\n\n      //printf(\"    dcap = %d\\n\", dcap);\n\n      safe_malloc(g->edge_neighbors[e], dcap, int);\n\n      //printf(\"    break 1.1.1\\n\");\n\n      safe_malloc(g->edge_faces[e], dcap, int);\n\n      //printf(\"    break 1.1.2\\n\");\n\n      g->_encap[e] = dcap;\n    }\n  }\n\n  //printf(\"  break 2\\n\");\n\n  edge = g->ne;\n  g->edges[edge].i = i;\n  g->edges[edge].j = j;\n  g->ne++;\n\n  //printf(\"  break 3\\n\");\n\n  // add the vertex neighbors\n  meshgraph_add_vertex_neighbor(g, i, j, edge);\n  meshgraph_add_vertex_neighbor(g, j, i, edge);\n\n  //printf(\"  break 4\\n\");\n\n  return edge;\n}\n\n\nstatic inline int meshgraph_add_edge_neighbor(meshgraph_t *g, int i, int vertex, int face)\n{\n  int n = g->nen[i];\n\n  //printf(\"g->nen[%d] = %d, g->_encap[%d] = %d\\n\", i, n, i, g->_encap[i]);\n\n  if (n == g->_encap[i]) {\n\n    //printf(\"n == g->_encap[%d]\\n\", i);\n\n    g->_encap[i] *= 2;\n    safe_realloc(g->edge_neighbors[i], g->_encap[i], int);\n    safe_realloc(g->edge_faces[i], g->_encap[i], int);\n  }\n\n  //printf(\"  break 1\\n\");\n\n  g->edge_neighbors[i][n] = vertex;\n\n  //printf(\"  break 2\\n\");\n\n  g->edge_faces[i][n] = face;\n\n  //printf(\"  break 3\\n\");\n\n  g->nen[i]++;\n\n  return n;\n}\n\n\nint meshgraph_add_face(meshgraph_t *g, int i, int j, int k)\n{\n  //printf(\"meshgraph_add_face(%d, %d, %d)\\n\", i, j, k);\n\n  int face = meshgraph_find_face(g, i, j, k);\n  if (face >= 0)\n    return face;\n\n  //printf(\"  break 1\\n\");\n\n  // add the edges\n  int edge_ij = meshgraph_add_edge(g, i, j);\n  int edge_ik = meshgraph_add_edge(g, i, k);\n  int edge_jk = meshgraph_add_edge(g, j, k);\n\n  //printf(\"  break 2\\n\");\n\n  // add the face\n  //printf(\"g->nf = %d, g->_fcap = %d\\n\", g->nf, g->_fcap);\n\n  if (g->nf == g->_fcap) {\n    g->_fcap *= 2;\n    safe_realloc(g->faces, g->_fcap, face_t);\n  }\n  face = g->nf;\n  g->faces[face].i = i;\n  g->faces[face].j = j;\n  g->faces[face].k = k;\n  g->nf++;\n\n  //printf(\"  break 3\\n\");\n\n  // add the edge neighbors\n  meshgraph_add_edge_neighbor(g, edge_ij, k, face);\n  meshgraph_add_edge_neighbor(g, edge_ik, j, face);\n  meshgraph_add_edge_neighbor(g, edge_jk, i, face);\n\n  //printf(\"  break 4\\n\");\n\n  return face;\n}\n\n\nstatic int _sortable_cmp(const void *x1, const void *x2)\n{\n  double v1 = ((sortable_t *)x1)->value;\n  double v2 = ((sortable_t *)x2)->value;\n\n  if (v1 == v2)\n    return 0;\n\n  if (v1 < v2 || isnan(v1))\n    return -1;\n\n  return 1;\n}\n\n// sort an array of weighted data using qsort\nvoid sort_data(sortable_t *x, size_t n)\n{\n  qsort(x, n, sizeof(sortable_t), _sortable_cmp);\n}\n\n\n// sort the indices of x (leaving x unchanged)\nvoid sort_indices(double *x, int *idx, int n)\n{\n  int i;\n  sortable_t *s;\n  int *xi;\n  safe_malloc(s, n, sortable_t);\n  safe_malloc(xi, n, int);\n\n  for (i = 0; i < n; i++) {\n    xi[i] = i;\n    s[i].value = x[i];\n    s[i].data = (void *)(&xi[i]);\n  }\n\n  sort_data(s, n);\n\n  for (i = 0; i < n; i++)\n    idx[i] = *(int *)(s[i].data);\n\n  free(s);\n  free(xi);\n}\n\n\n/*\n * fills idx with the indices of the k min entries of x\n *   --> works by maintaining the invariant that idx[0] always has the\n *       largest x value of the min k found so far\n */       \nvoid mink(double *x, int *idx, int n, int k)\n{\n  int i, j;\n\n  // initialize idx with 1:k\n  for (i = 0; i < k; i++)\n    idx[i] = i;\n\n  // maintain invariant\n  for (i = 1; i < k; i++) {\n    if (x[idx[i]] > x[idx[0]]) {\n      int tmp = idx[i];\n      idx[i] = idx[0];\n      idx[0] = tmp;\n    }\n  }\n\n  // process the rest of x\n  for (i = k; i < n; i++) {\n    if (x[i] < x[idx[0]]) {\n      idx[0] = i;\n\n      // maintain invariant\n      for (j = 1; j < k; j++) {\n\tif (x[idx[j]] > x[idx[0]]) {\n\t  int tmp = idx[j];\n\t  idx[j] = idx[0];\n\t  idx[0] = tmp;\n\t}\n      }\n    }\n  }\n\n  // sort the min k values\n  double xmink[k];\n  int idx2[k];\n  for (i = 0; i < k; i++)\n    xmink[i] = x[idx[i]];\n  sort_indices(xmink, idx2, k);\n  for (i = 0; i < k; i++)\n    idx2[i] = idx[idx2[i]];\n  for (i = 0; i < k; i++)\n    idx[i] = idx2[i];\n}\n\nshort double_is_equal(double a, double b)\n{\n  return fabs(a - b) < 0.00001;\n}\n\n// fast select algorithm\nint qselect(double *x, int n, int k)\n{\n  if (n == 1)\n    return 0;\n\n  double pivot = x[k];\n\n  // partition x into y < pivot, z > pivot\n  int i, ny=0, nz=0;\n  for (i = 0; i < n; i++) {\n    if (x[i] < pivot)\n      ny++;\n    else if (x[i] > pivot)\n      nz++;\n  }\n\n  if (k < ny) {\n    double *y;\n    int *yi;\n    safe_calloc(y, ny, double);\n    safe_calloc(yi, ny, int);\n    ny = 0;\n    for (i = 0; i < n; i++) {\n      if (x[i] < pivot) {\n\tyi[ny] = i;\n\ty[ny++] = x[i];\n      }\n    }\n    i = yi[qselect(y, ny, k)];\n    free(y);\n    free(yi);\n    return i;\n  }\n\n  else if (k >= n - nz) {\n    double *z;\n    int *zi;\n    safe_calloc(z, nz, double);\n    safe_calloc(zi, nz, int);\n    nz = 0;\n    for (i = 0; i < n; i++) {\n      if (x[i] > pivot) {\n\tzi[nz] = i;\n\tz[nz++] = x[i];\n      }\n    }\n    i = zi[qselect(z, nz, k-(n-nz))];\n    free(z);\n    free(zi);\n    return i;\n  }\n\n  return k;\n}\n\n\nstatic kdtree_t *build_kdtree(double **X, int *xi, int n, int d, int depth)\n{\n  if (n == 0)\n    return NULL;\n\n  int i, axis = depth % d;\n  kdtree_t *node;\n  safe_calloc(node, 1, kdtree_t);\n  node->axis = axis;\n\n  double *x;\n  safe_calloc(x, n, double);\n  for (i = 0; i < n; i++)\n    x[i] = X[i][axis];\n\n  int median = qselect(x, n, n/2);\n\n  // node location\n  node->i = xi[median];\n  node->d = d;\n  safe_malloc(node->x, d, double);\n  memcpy(node->x, X[median], d*sizeof(double));\n\n  // node bbox init:  bbox_min = bbox_max = x\n  safe_malloc(node->bbox_min, d, double);\n  safe_malloc(node->bbox_max, d, double);\n  memcpy(node->bbox_min, node->x, d*sizeof(double));\n  memcpy(node->bbox_max, node->x, d*sizeof(double));\n\n  // partition x into y < pivot, z > pivot\n  double pivot = x[median];\n  int ny=0, nz=0;\n  for (i = 0; i < n; i++) {\n    if (i == median)\n      continue;\n    if (x[i] <= pivot)\n      ny++;\n    else if (x[i] > pivot)\n      nz++;\n  }\n\n  //printf(\"n = %d, d = %d, depth = %d, axis = %d --> median = %d, X[median] = (%f, %f, %f), ny = %d, nz = %d\\n\",\n  //\t n, d, depth, axis, median, X[median][0], X[median][1], X[median][2], ny, nz);\n\n\n  if (ny > 0) {\n    double **Y = new_matrix2(ny, d);\n    int *yi;\n    safe_calloc(yi, ny, int);\n    ny = 0;\n    for (i = 0; i < n; i++) {\n      if (i == median)\n\tcontinue;\n      if (x[i] <= pivot) {\n\tyi[ny] = xi[i];\n\tmemcpy(Y[ny], X[i], d*sizeof(double));\n\tny++;\n      }\n    }\n    node->left = build_kdtree(Y, yi, ny, d, depth+1);\n\n    // update bbox\n    for (i = 0; i < d; i++) {\n      if (node->left->bbox_min[i] < node->bbox_min[i])\n\tnode->bbox_min[i] = node->left->bbox_min[i];\n      if (node->left->bbox_max[i] > node->bbox_max[i])\n\tnode->bbox_max[i] = node->left->bbox_max[i];\n    }\n\n    free_matrix2(Y);\n    free(yi);\n  }\n\n  if (nz > 0) {\n    double **Z = new_matrix2(nz, d);\n    int *zi;\n    safe_calloc(zi, nz, int);\n    nz = 0;\n    for (i = 0; i < n; i++) {\n      if (i == median)\n\tcontinue;\n      if (x[i] > pivot) {\n\tzi[nz] = xi[i];\n\tmemcpy(Z[nz], X[i], d*sizeof(double));\n\tnz++;\n      }\n    }\n    node->right = build_kdtree(Z, zi, nz, d, depth+1);\n\n    // update bbox\n    for (i = 0; i < d; i++) {\n      if (node->right->bbox_min[i] < node->bbox_min[i])\n\tnode->bbox_min[i] = node->right->bbox_min[i];\n      if (node->right->bbox_max[i] > node->bbox_max[i])\n\tnode->bbox_max[i] = node->right->bbox_max[i];\n    }\n\n    free_matrix2(Z);\n    free(zi);\n  }\n\n  free(x);\n  return node;\n}\n\n\nkdtree_t *kdtree(double **X, int n, int d)\n{\n  int i, *xi;\n  safe_malloc(xi, n, int);\n  for (i = 0; i < n; i++)\n    xi[i] = i;\n\n  kdtree_t *tree = build_kdtree(X, xi, n, d, 0);\n\n  free(xi);\n  return tree;\n}\n\n\nstatic kdtree_t *kdtree_NN_node(kdtree_t *tree, double *x, kdtree_t *best)\n{\n  if (tree == NULL)\n    return best;\n\n  //printf(\"node %d\", tree->i);\n\n  int i, d = tree->d;\n  double dbest = (best ? dist(x, best->x, d) : DBL_MAX);\n\n  // first, check if any node in tree can possibly be better than 'best'\n  if (best) {\n    double y[d];  // closest point on the tree's bbox to x\n    for (i = 0; i < d; i++) {\n      if (x[i] < tree->bbox_min[i])\n\ty[i] = tree->bbox_min[i];\n      else if (x[i] > tree->bbox_max[i])\n\ty[i] = tree->bbox_max[i];\n      else\n\ty[i] = x[i];\n    }\n    if (dist(y, x, d) >= dbest) {  // 'best' is closer than the closest possible point in tree, so return\n      //printf(\"  --> pruned!\\n\");\n      return best;\n    }\n  }\n\n  int axis = tree->axis;\n  kdtree_t *nn = best;\n\n  // compare with the node itself\n  double dtree = dist(x, tree->x, d);\n  //printf(\" (%f)\", dtree);\n  if (dtree < dbest) {\n    nn = tree;\n    dbest = dtree;\n    //printf(\" --> new best\");\n  }\n  //printf(\"\\n\");\n\n  // compare with the NN in each sub-tree\n  if (x[axis] <= tree->x[axis]) {\n    nn = kdtree_NN_node(tree->left, x, nn);\n    nn = kdtree_NN_node(tree->right, x, nn);\n  }\n  else if (x[axis] > tree->x[axis]) {\n    nn = kdtree_NN_node(tree->right, x, nn);\n    nn = kdtree_NN_node(tree->left, x, nn);\n  }\n\n  //dbest = dist(x, nn->x, d);\n  //printf(\" ... return %d (%f)\\n\", nn->i, dbest);\n\n  return nn;\n}\n\nint kdtree_NN(kdtree_t *tree, double *x)\n{\n  kdtree_t *nn = kdtree_NN_node(tree, x, NULL);\n  return (nn ? nn->i : -1);\n}\n\n\nvoid kdtree_free(kdtree_t *tree)\n{\n  if (tree == NULL)\n    return;\n\n  kdtree_free(tree->left);\n  kdtree_free(tree->right);\n\n  free(tree->x);\n  free(tree->bbox_min);\n  free(tree->bbox_max);\n\n  free(tree);\n}\n\n// RGB to CIELAB color space\nvoid rgb2lab(double lab[], double rgb[])\n{\n  double R = rgb[0];\n  double G = rgb[1];\n  double B = rgb[2];\n\n  //if (R > 1.0 || G > 1.0 || B > 1.0) {\n  R /= 255.0;\n  G /= 255.0;\n  B /= 255.0;\n  //}\n  \n  // set a threshold\n  double T = 0.008856;\n  \n  // RGB to XYZ\n  double X = 0.412453*R + 0.357580*G + 0.180423*B;\n  double Y = 0.212671*R + 0.715160*G + 0.072169*B;\n  double Z = 0.019334*R + 0.119193*G + 0.950227*B;\n\n  // normalize for D65 white point\n  X /= 0.950456;\n  Z /= 1.088754;\n\n  double X3 = pow(X, 1/3.);\n  double Y3 = pow(Y, 1/3.);\n  double Z3 = pow(Z, 1/3.);\n\n  double fX = (X>T ? X3 : 7.787*X + 16/116.);\n  double fY = (Y>T ? Y3 : 7.787*Y + 16/116.);\n  double fZ = (Z>T ? Z3 : 7.787*Z + 16/116.);\n\n  lab[0] = (Y>T ? 116*Y3 - 16.0 : 903.3*Y);\n  lab[1] = 500*(fX - fY);\n  lab[2] = 200*(fY - fZ);\n}\n\n// CIELAB to RGB color space\nvoid lab2rgb(double rgb[], double lab[])\n{\n  // Thresholds\n  double T1 = 0.008856;\n  double T2 = 0.206893;\n\n  double L = lab[0];\n  double a = lab[1];\n  double b = lab[2];\n\n  // Compute Y\n  double fY = pow((L + 16) / 116., 3);\n  int YT = (fY > T1);\n  if (!YT)\n    fY = L / 903.3;\n  double Y = fY;\n\n  // Alter fY slightly for further calculations\n  fY = (YT ? pow(fY, 1/3.) : 7.787 * fY + 16/116.);\n\n  // Compute X\n  double fX = a / 500. + fY;\n  int XT = fX > T2;\n  double X = (XT ? pow(fX, 3) : (fX - 16/116.) / 7.787);\n\n  // Compute Z\n  double fZ = fY - b / 200.;\n  int ZT = fZ > T2;\n  double Z = (ZT ? pow(fZ, 3) : (fZ - 16/116.) / 7.787);\n\n  // Normalize for D65 white point\n  X = X * 0.950456;\n  Z = Z * 1.088754;\n\n  // XYZ to RGB\n  double R =  3.240479*X - 1.537150*Y - 0.498535*Z;\n  double G = -0.969256*X + 1.875992*Y + 0.041556*Z;\n  double B =  0.055648*X - 0.204043*Y + 1.057311*Z;\n\n  rgb[0] = 255*MAX(MIN(R, 1.0), 0.0);\n  rgb[1] = 255*MAX(MIN(G, 1.0), 0.0);\n  rgb[2] = 255*MAX(MIN(B, 1.0), 0.0);\n}\n", "meta": {"hexsha": "f4b775f3cf1ff6f52d0da2df746cf0309c91df7f", "size": 75731, "ext": "c", "lang": "C", "max_stars_repo_path": "c/util.c", "max_stars_repo_name": "adamconkey/bingham", "max_stars_repo_head_hexsha": "a3948cba29bb1288c3ab97141479273d493a139a", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 35.0, "max_stars_repo_stars_event_min_datetime": "2015-06-23T02:49:27.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-11T14:19:23.000Z", "max_issues_repo_path": "c/util.c", "max_issues_repo_name": "adamconkey/bingham", "max_issues_repo_head_hexsha": "a3948cba29bb1288c3ab97141479273d493a139a", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 11.0, "max_issues_repo_issues_event_min_datetime": "2015-06-10T08:13:05.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-27T22:38:55.000Z", "max_forks_repo_path": "c/util.c", "max_forks_repo_name": "adamconkey/bingham", "max_forks_repo_head_hexsha": "a3948cba29bb1288c3ab97141479273d493a139a", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 27.0, "max_forks_repo_forks_event_min_datetime": "2015-06-12T18:28:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-21T22:05:44.000Z", "avg_line_length": 20.4678378378, "max_line_length": 838, "alphanum_fraction": 0.508167065, "num_tokens": 30542, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.34510528442897664, "lm_q2_score": 0.01971912709919374, "lm_q1q2_score": 0.006805174966258397}}
{"text": "/*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*\n**                                                                                  **\n** This file forms part of the Underworld geophysics modelling application.         **\n**                                                                                  **\n** For full license and copyright information, please refer to the LICENSE.md file  **\n** located at the project root, or contact the authors.                             **\n**                                                                                  **\n**~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*/\n\n#include <mpi.h>\n#include <StGermain/StGermain.h>\n#include <StgDomain/StgDomain.h>\n#include <StgFEM/StgFEM.h>\n#include <petsc.h>\n\n#include \"types.h\"\n#include \"SemiLagrangianIntegrator.h\"\n\n#include <assert.h>\n\n/** Textual name of this class */\nconst Type SemiLagrangianIntegrator_Type = \"SemiLagrangianIntegrator\";\n\nSemiLagrangianIntegrator* _SemiLagrangianIntegrator_New(  SEMILAGRANGIANINTEGRATOR_DEFARGS  )\n{\n   SemiLagrangianIntegrator*\t\tself;\n\n   /* Allocate memory */\n   assert( _sizeOfSelf >= sizeof(SemiLagrangianIntegrator) );\n   /* The following terms are parameters that have been passed into this function but are being set before being passed onto the parent */\n   /* This means that any values of these parameters that are passed into this function are not passed onto the parent function\n      and so should be set to ZERO in any children of this class. */\n   nameAllocationType = NON_GLOBAL;\n\n   self = (SemiLagrangianIntegrator*) _Stg_Component_New(  STG_COMPONENT_PASSARGS  );\n\n   /* General info */\n   self->variableList = Stg_ObjectList_New();\n   self->varStarList  = Stg_ObjectList_New();\n   self->varOldList   = Stg_ObjectList_New();\n\n   return self;\n}\n\nvoid* _SemiLagrangianIntegrator_Copy( void* slIntegrator, void* dest, Bool deep, Name nameExt, PtrMap* ptrMap ) {\n   SemiLagrangianIntegrator*\t\tself = (SemiLagrangianIntegrator*)slIntegrator;\n   SemiLagrangianIntegrator*\t\tnewSemiLagrangianIntegrator;\n   PtrMap*\t\t\tmap = ptrMap;\n   Bool\t\t\townMap = False;\n\n   if( !map ) {\n      map = PtrMap_New( 10 );\n      ownMap = True;\n   }\n\n   newSemiLagrangianIntegrator = _Stg_Component_Copy( self, dest, deep, nameExt, map );\n\n   if( deep ) {\n      if( (newSemiLagrangianIntegrator->velocityField = PtrMap_Find( map, self->velocityField )) == NULL ) {\n         newSemiLagrangianIntegrator->velocityField = Stg_Class_Copy( self->velocityField, NULL, deep, nameExt, map );\n         PtrMap_Append( map, self->velocityField, newSemiLagrangianIntegrator->velocityField );\n      }\n   }\n   else {\n      newSemiLagrangianIntegrator->velocityField = Stg_Class_Copy( self->velocityField, NULL, deep, nameExt, map );\n   }\n\n   if( ownMap ) {\n      Stg_Class_Delete( map );\n   }\n\n   return (void*)newSemiLagrangianIntegrator;\n}\n\n\nvoid _SemiLagrangianIntegrator_Delete( void* slIntegrator ) {\n   SemiLagrangianIntegrator*\t\tself = (SemiLagrangianIntegrator*)slIntegrator;\n   Stg_Class_Delete( self->variableList );\n   Stg_Class_Delete( self->varStarList );\n   Stg_Class_Delete( self->varOldList );\n}\n\nvoid _SemiLagrangianIntegrator_Print( void* slIntegrator, Stream* stream ) {\n   SemiLagrangianIntegrator*\t\tself = (SemiLagrangianIntegrator*)slIntegrator;\n\n   _Stg_Component_Print( self, stream );\n\n   Journal_PrintPointer( stream, self->velocityField );\n}\n\nvoid* _SemiLagrangianIntegrator_DefaultNew( Name name ) {\n   /* Variables set in this function */\n   SizeT                                              _sizeOfSelf = sizeof(SemiLagrangianIntegrator);\n   Type                                                      type = SemiLagrangianIntegrator_Type;\n   Stg_Class_DeleteFunction*                              _delete = _SemiLagrangianIntegrator_Delete;\n   Stg_Class_PrintFunction*                                _print = _SemiLagrangianIntegrator_Print;\n   Stg_Class_CopyFunction*                                  _copy = _SemiLagrangianIntegrator_Copy;\n   Stg_Component_DefaultConstructorFunction*  _defaultConstructor = _SemiLagrangianIntegrator_DefaultNew;\n   Stg_Component_ConstructFunction*                    _construct = _SemiLagrangianIntegrator_AssignFromXML;\n   Stg_Component_BuildFunction*                            _build = _SemiLagrangianIntegrator_Build;\n   Stg_Component_InitialiseFunction*                  _initialise = _SemiLagrangianIntegrator_Initialise;\n   Stg_Component_ExecuteFunction*                        _execute = _SemiLagrangianIntegrator_Execute;\n   Stg_Component_DestroyFunction*                        _destroy = _SemiLagrangianIntegrator_Destroy;\n\n   /* Variables that are set to ZERO are variables that will be set either by the current _New function or another parent _New function further up the hierachy */\n   AllocationType  nameAllocationType = NON_GLOBAL /* default value NON_GLOBAL */;\n\n   return (void*)_SemiLagrangianIntegrator_New(  SEMILAGRANGIANINTEGRATOR_PASSARGS  );\n}\n\nvoid _SemiLagrangianIntegrator_AssignFromXML( void* slIntegrator, Stg_ComponentFactory* cf, void* data ) {\n   SemiLagrangianIntegrator*\tself \t\t= (SemiLagrangianIntegrator*)slIntegrator;\n   Dictionary*\t\t\tdict;\n   Dictionary_Entry_Value*\t\tdev;\n   unsigned\t\t\tfield_i;\n   Name\t\t\t\tfieldName;\n   FeVariable*\t   feVariable;\n\n   Stg_Component_AssignFromXML( self, cf, data, False );\n\n   self->context = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)\"Context\", FiniteElementContext, False, data );\n   if( !self->context  )\n      self->context = Stg_ComponentFactory_ConstructByName( cf, (Name)\"context\", FiniteElementContext, True, data  );\n\n   self->velocityField = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)\"VelocityField\", FeVariable, False, NULL  );\n   self->advectedField = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)\"AdvectedField\", FeVariable, False, NULL  );\n\n   dict = Dictionary_Entry_Value_AsDictionary( Dictionary_Get( cf->componentDict, (Dictionary_Entry_Key)self->name )  );\n   dev  = Dictionary_Get( dict, (Dictionary_Entry_Key)\"fields\" );\n   for( field_i = 0; field_i < Dictionary_Entry_Value_GetCount( dev ); field_i += 3  ) {\n      fieldName = Dictionary_Entry_Value_AsString( Dictionary_Entry_Value_GetElement( dev, field_i ) );\n      feVariable = Stg_ComponentFactory_ConstructByName( cf, (Name)fieldName, FeVariable, True, data  );\n      Stg_ObjectList_Append( self->variableList, feVariable );\n\n      /* the corresponding _* field */\n      fieldName = Dictionary_Entry_Value_AsString( Dictionary_Entry_Value_GetElement( dev, field_i + 1 ) );\n      feVariable = Stg_ComponentFactory_ConstructByName( cf, (Name)fieldName, FeVariable, True, data  );\n      Stg_ObjectList_Append( self->varStarList, feVariable );\n\n      /* the corresponding old field */\n      fieldName = Dictionary_Entry_Value_AsString( Dictionary_Entry_Value_GetElement( dev, field_i + 2 ) );\n      feVariable = Stg_ComponentFactory_ConstructByName( cf, (Name)fieldName, FeVariable, True, data  );\n      Stg_ObjectList_Append( self->varOldList, feVariable );\n   }\n\n//   self->sle = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)\"SLE\", Energy_SLE, False, NULL  );\n\n   /* for problems with temporally evolving velocity */\n   self->prevVelField = Stg_ComponentFactory_ConstructByKey( cf, self->name, (Dictionary_Entry_Key)\"PreviousTimeStepVelocityField\", FeVariable, False, data );\n   if( self->prevVelField  ) {\n      EP_AppendClassHook( Context_GetEntryPoint( self->context, AbstractContext_EP_UpdateClass ), SemiLagrangianIntegrator_UpdatePreviousVelocityField, self );\n      EP_InsertClassHookAfter( Context_GetEntryPoint( self->context, AbstractContext_EP_UpdateClass ), \"SemiLagrangianIntegrator_UpdatePreviousVelocityField\", SemiLagrangianIntegrator_InitSolve, self );\n   } else {\n      EP_AppendClassHook( Context_GetEntryPoint( self->context, AbstractContext_EP_UpdateClass ), SemiLagrangianIntegrator_InitSolve, self );\n   }\n\n//   if( self->sle ) {\n//      /** also set sle to run where required */\n//      EP_InsertClassHookAfter( Context_GetEntryPoint( self->context, AbstractContext_EP_UpdateClass ), \"SemiLagrangianIntegrator_InitSolve\", SystemLinearEquations_GetRunEPFunction(), self->sle );\n//      /** remember to disable the standard run at execute */\n//      SystemLinearEquations_SetRunDuringExecutePhase( self->sle, False);\n//   }\n\n   self->isConstructed = True;\n}\n\nvoid _SemiLagrangianIntegrator_Build( void* slIntegrator, void* data ) {\n   SemiLagrangianIntegrator*\tself \t\t= (SemiLagrangianIntegrator*)slIntegrator;\n   FeVariable*\t\t\tfeVariable;\n   FeVariable*\t\t\tfeVarOld;\n   FeVariable*\t\t\tfeVarStar;\n   unsigned\t\t\t   field_i;\n\n   if(self->velocityField) Stg_Component_Build(self->velocityField, data, False);\n   if(self->advectedField) Stg_Component_Build(self->advectedField, data, False);\n   if(self->prevVelField)  Stg_Component_Build(self->prevVelField , data, False);\n\n   for( field_i = 0; field_i < self->variableList->count; field_i++ ) {\n      feVariable = (FeVariable*) self->variableList->data[field_i];\n      feVarOld   = (FeVariable*) self->varOldList->data[field_i];\n      feVarStar  = (FeVariable*) self->varStarList->data[field_i];\n      if(feVariable) Stg_Component_Build(feVariable, data, False);\n      if(feVarOld  ) Stg_Component_Build(feVarOld  , data, False);\n      if(feVarStar ) Stg_Component_Build(feVarStar , data, False);\n   }\n}\n\nvoid _SemiLagrangianIntegrator_Initialise( void* slIntegrator, void* data ) {\n   SemiLagrangianIntegrator*\tself \t\t= (SemiLagrangianIntegrator*)slIntegrator;\n   FeVariable*\t\t\tfeVariable;\n   FeVariable*\t\t\tfeVarOld;\n   FeVariable*\t\t\tfeVarStar;\n   unsigned\t\t\t   field_i;\n\n   if(self->velocityField) Stg_Component_Initialise(self->velocityField, data, False);\n   if(self->advectedField) Stg_Component_Initialise(self->advectedField, data, False);\n   if(self->prevVelField) {\n      Stg_Component_Initialise(self->prevVelField , data, False);\n      SemiLagrangianIntegrator_UpdatePreviousVelocityField( slIntegrator, NULL );\n   }\n\n   for( field_i = 0; field_i < self->variableList->count; field_i++ ) {\n      feVariable = (FeVariable*) self->variableList->data[field_i];\n      feVarOld   = (FeVariable*) self->varOldList->data[field_i];\n      feVarStar  = (FeVariable*) self->varStarList->data[field_i];\n      if(feVariable) Stg_Component_Initialise(feVariable, data, False);\n      if(feVarOld  ) Stg_Component_Initialise(feVarOld  , data, False);\n      if(feVarStar ) Stg_Component_Initialise(feVarStar , data, False);\n   }\n}\n\nvoid _SemiLagrangianIntegrator_Execute( void* slIntegrator, void* data ) {\n}\n\nvoid _SemiLagrangianIntegrator_Destroy( void* slIntegrator, void* data ) {\n   SemiLagrangianIntegrator*\tself \t= (SemiLagrangianIntegrator*)slIntegrator;\n   FeVariable*\t\t\tfeVariable;\n   FeVariable*\t\t\tfeVarOld;\n   FeVariable*\t\t\tfeVarStar;\n   unsigned\t\t\t   field_i;\n\n   if(self->velocityField) Stg_Component_Destroy(self->velocityField, data, False);\n   if(self->advectedField) Stg_Component_Destroy(self->advectedField, data, False);\n   if(self->prevVelField)  Stg_Component_Destroy(self->prevVelField , data, False);\n\n   for( field_i = 0; field_i < self->variableList->count; field_i++ ) {\n      feVariable = (FeVariable*) self->variableList->data[field_i];\n      feVarOld   = (FeVariable*) self->varOldList->data[field_i];\n      feVarStar  = (FeVariable*) self->varStarList->data[field_i];\n      if(feVariable) Stg_Component_Destroy(feVariable, data, False);\n      if(feVarOld  ) Stg_Component_Destroy(feVarOld  , data, False);\n      if(feVarStar ) Stg_Component_Destroy(feVarStar , data, False);\n   }\n}\n\nvoid SemiLagrangianIntegrator_InitSolve( void* _self, void* _context ) {\n   SemiLagrangianIntegrator*\tself\t\t\t= (SemiLagrangianIntegrator*) _self;\n   unsigned\t\t\t   field_i, node_i;\n   FeVariable*\t\t\tfeVariable;\n   FeVariable*\t\t\tfeVarOld;\n   FeVariable*\t\t\tfeVarStar;\n   double            phi[3];\n   unsigned\t\t\t   lMeshSize;\n   FeMesh*\t\t\t\tmesh;\n\n   for( field_i = 0; field_i < self->variableList->count; field_i++ ) {\n      feVariable = (FeVariable*) self->variableList->data[field_i];\n      feVarStar  = (FeVariable*) self->varStarList->data[field_i];\n      feVarOld   = (FeVariable*) self->varOldList->data[field_i];\n\n      /* we're assuming that the solution vector has already been updated onto the FeVariable (in the SLE class) */\n      mesh = feVariable->feMesh;\n      lMeshSize = Mesh_GetLocalSize( mesh, MT_VERTEX );\n      for( node_i = 0; node_i < lMeshSize; node_i++ ) {\n         FeVariable_GetValueAtNode( feVariable, node_i, phi );\n         FeVariable_SetValueAtNode( feVarOld, node_i, phi );\n      }\n      FeVariable_SyncShadowValues( feVarOld );\n\n      /* generate the _* field */\n      SemiLagrangianIntegrator_Solve( self, feVarOld, feVarStar );\n   }\n}\n\n#define INV6 0.166666666667\n\nvoid IntegrateRungeKutta( FeVariable* velocityField, double dt, double* origin, double* position ) {\n   unsigned\t\tndims\t\t     = Mesh_GetDimSize( velocityField->feMesh );\n   unsigned\t\tdim_i;\n   double\t\t\tmin[3], max[3];\n   double\t\t\tk[4][3];\n   double\t\t\tcoordPrime[3];\n   unsigned*\t\tperiodic\t     = ((CartesianGenerator*)velocityField->feMesh->generator)->periodic;\n\n   Mesh_GetGlobalCoordRange( velocityField->feMesh, min, max );\n\n   FieldVariable_InterpolateValueAt( velocityField, origin, k[0] );\n   for( dim_i = 0; dim_i < ndims; dim_i++ ) {\n      coordPrime[dim_i] = origin[dim_i] - 0.5 * dt * k[0][dim_i];\n      PeriodicUpdate( coordPrime, min, max, dim_i, periodic[dim_i] );\n   }\n   FieldVariable_InterpolateValueAt( velocityField, coordPrime, k[1] );\n\n   for( dim_i = 0; dim_i < ndims; dim_i++ ) {\n      coordPrime[dim_i] = origin[dim_i] - 0.5 * dt * k[1][dim_i];\n      PeriodicUpdate( coordPrime, min, max, dim_i, periodic[dim_i] );\n   }\n   FieldVariable_InterpolateValueAt( velocityField, coordPrime, k[2] );\n\n   for( dim_i = 0; dim_i < ndims; dim_i++ ) {\n      coordPrime[dim_i] = origin[dim_i] - dt * k[2][dim_i];\n      PeriodicUpdate( coordPrime, min, max, dim_i, periodic[dim_i] );\n   }\n   FieldVariable_InterpolateValueAt( velocityField, coordPrime, k[3] );\n\n   for( dim_i = 0; dim_i < ndims; dim_i++ ) {\n      position[dim_i] = origin[dim_i] -\n         INV6 * dt * ( k[0][dim_i] + 2.0 * k[1][dim_i] + 2.0 * k[2][dim_i] + k[3][dim_i] );\n      PeriodicUpdate( position, min, max, dim_i, periodic[dim_i] );\n   }\n}\n\n/* 2nd order acurate runge kutta algorithm for interpolating backwards in time through a temporally evolving velocity field\n   Durran, D. \"Numerical Methods for Wave Equations in Geophysical Fluid Dynamics\" (1999), pages 310-313\n\n   u(t^(n+0.5)) = 1.5u(t^n) - 0.5u(t^(n-1))\n   x_* = x^(n+1) - 0.5*dt*u(x^(n+1),t^n)\n   x_j^n = x^(n+1) - dt*u(x_*,t^(n+0.5))\n\n   Force term:\n      F = 0.5*[3*S(x_j^n,t^n) - S(x_j^(n-1),t^(n-1))]\n */\nvoid IntegrateRungeKutta_StgVariableVelocity( FeVariable* currVelField, FeVariable* interVelField, double dt, double* origin, double* position ) {\n   unsigned\t\tnDims\t\t     = Mesh_GetDimSize( currVelField->feMesh );\n   unsigned\t\tdim_i;\n   double\t\t\tmin[3], max[3];\n   double\t\t\tmidPoint[3];\n   double\t\t\tvelCurr[3], velInter[3];\n   CartesianGenerator*\tgen\t\t     = (CartesianGenerator*)currVelField->feMesh->generator;\n\n   Mesh_GetGlobalCoordRange( currVelField->feMesh, min, max );\n\n   FieldVariable_InterpolateValueAt( currVelField, origin, velCurr );\n   for( dim_i = 0; dim_i < nDims; dim_i++ ) {\n      midPoint[dim_i] = origin[dim_i] - 0.5 * dt * velCurr[dim_i];\n      PeriodicUpdate( midPoint, min, max, dim_i, gen->periodic[dim_i] );\n   }\n\n   FieldVariable_InterpolateValueAt( interVelField, midPoint, velInter );\n\n   /* 2nd order approximation of velocity at time current + dt/2 */\n   for( dim_i = 0; dim_i < nDims; dim_i++ ) {\n      position[dim_i] = origin[dim_i] - dt * velInter[dim_i];\n      PeriodicUpdate( position, min, max, dim_i, gen->periodic[dim_i] );\n   }\n}\n\n/* for case of temporally evolving velocity field, when we need to integrate backwards in time\n * throught this to find our take off point */\nvoid SemiLagrangianIntegrator_UpdatePreviousVelocityField( void* _self, void* _context ) {\n   SemiLagrangianIntegrator*\tself\t\t= (SemiLagrangianIntegrator*) _self;\n   FeVariable*\t\t\tcurrVelField\t= self->velocityField;\n   FeVariable*\t\t\tprevVelField\t= self->prevVelField;\n   unsigned\t\t\tnode_i;\n   double\t\t\t\tvel[3];\n\n   for( node_i = 0; node_i < Mesh_GetLocalSize( currVelField->feMesh, MT_VERTEX ); node_i++ ) {\n      FeVariable_GetValueAtNode( currVelField, node_i, vel );\n      FeVariable_SetValueAtNode( prevVelField, node_i, vel );\n   }\n\n   FeVariable_SyncShadowValues( currVelField );\n   FeVariable_SyncShadowValues( prevVelField );\n}\n\n/* cubic Lagrangian interpoation in 1-D */\nvoid InterpLagrange( double x, double* coords, double (*values)[3], unsigned numdofs, double* result ) {\n   unsigned\tnode_i, dof_i;\n   unsigned\totherIndices[3];\n   unsigned\totherIndexCount, otherIndex_i;\n   double\t\tfactor;\n\n   for( dof_i = 0; dof_i < numdofs; dof_i++ )\n      result[dof_i] = 0.0;\n\n   for( node_i = 0; node_i < 4; node_i++ ) {\n      otherIndexCount = 0;\n      for( otherIndex_i = 0; otherIndex_i < 4; otherIndex_i++ )\n         if( otherIndex_i != node_i )\n            otherIndices[otherIndexCount++] = otherIndex_i;\n\n      factor = 1.0;\n      for( otherIndex_i = 0; otherIndex_i < 3; otherIndex_i++ )\n         factor *= ( x - coords[otherIndices[otherIndex_i]] ) / ( coords[node_i] - coords[otherIndices[otherIndex_i]] );\n\n      for( dof_i = 0; dof_i < numdofs; dof_i++ ) {\n         result[dof_i] += ( values[node_i][dof_i] * factor );\n      }\n   }\n}\n\nBool PeriodicUpdate( double* pos, double* min, double* max, unsigned dim, Bool isPeriodic ) {\n  if( pos[dim] < min[dim] ) {\n    pos[dim] = (isPeriodic) ? max[dim] - min[dim] + pos[dim] : min[dim];\n    return True;\n  }\n  if( pos[dim] > max[dim] ) {\n    pos[dim] = (isPeriodic) ? min[dim] - max[dim] + pos[dim] : max[dim];\n    return True;\n  }\n\n  return False;\n}\n\nBool BicubicInterpolatorNew( FeVariable* feVariable, FeVariable* stencilField, double* position, unsigned* sizes, double* result ) {\n  /* Calculated the BicubicInterpolation of the feVariable at position\n   *\n   * Input Args:\n   *   feVariable: the field to be interpolated at `position`.\n   *   stencilField: the field of initial spline stencils for each node.\n   *   position:   the position of interpolatation.\n   *   sizes:      memory chunk of size = sizeof(double)*dim.\n   *   results:    the interpolated value.\n   *\n   *\n   * Returns Values:\n   *  True: if interpolation successful\n   *  False: position is not in 'domain' of local processor\n   */\n\n   FeMesh*\tfeMesh = feVariable->feMesh;\n   unsigned\tnInc ;\n   int    ijk[3];\n   int\t\tx_i, y_i, z_i, *inc;\n   double localMin[3], localMax[3], double_ijk[3];\n   Index  gNode_I, lNode_I, elementIndex;\n   double px[4], py[4], pz[4];\n   unsigned\tnodeIndex[4][4];\n   unsigned\tnode_I3D[4][4][4];\n   unsigned\tnDims   = Mesh_GetDimSize( feMesh );\n   unsigned\tnumdofs = feVariable->dofLayout->dofCounts[0];\n   double   ptsX[4][3], ptsY[4][3], ptsZ[4][3];\n   Bool     inDomain  = True;\n\n   inDomain = Mesh_SearchElements( feMesh, position, &elementIndex ); // get the element id\n\n   if (!inDomain) return False;\n\n   FeMesh_GetElementNodes( feMesh, elementIndex, feVariable->inc ); // get the incidence graph (inc.) of nodes on the element\n   nInc = IArray_GetSize( feVariable->inc );                        // from inc. get the number of nodes on the element\n   inc = IArray_GetPtr( feVariable->inc );                          // get the node ids from inc.\n\n   FeVariable_GetValueAtNode( stencilField, inc[0], &(double_ijk[0]) );\n   ijk[0] = lround(double_ijk[0]);\n   ijk[1] = lround(double_ijk[1]);\n   ijk[2] = lround(double_ijk[2]);\n\n   /* interpolate using Lagrange's formula */\n   if( nDims == 2 ) {\n      for( y_i = 0; y_i < 4; y_i++ )\n         for( x_i = 0; x_i < 4; x_i++ ) {\n            gNode_I = ijk[0] + x_i + ( ijk[1] + y_i ) * sizes[0];\n            if( !Mesh_GlobalToDomain( feMesh, MT_VERTEX, gNode_I, &lNode_I ) ){\n              printf(\"Error in %s, trying to build an interpolation to position (%g, %g) using node %d, a non domain node, in interpolator.\\n\", __func__, position[0], position[1], gNode_I);\n              abort();\n            }\n            else\n               nodeIndex[x_i][y_i] = lNode_I;\n         }\n   }\n   else {\n      for( z_i = 0; z_i < 4; z_i++ )\n         for( y_i = 0; y_i < 4; y_i++ )\n            for( x_i = 0; x_i < 4; x_i++ ) {\n               gNode_I = ijk[0] + x_i + ( ijk[1] + y_i ) * sizes[0] + ( ijk[2] + z_i ) * sizes[0] * sizes[1];\n               if( !Mesh_GlobalToDomain( feMesh, MT_VERTEX, gNode_I, &lNode_I ) ) {\n                 printf(\"Error in %s, trying to build an interpolation to position (%g, %g, %g) using node %d, a non domain node, in interpolator.\\n\", __func__, position[0], position[1], position[2], gNode_I);\n                 abort();\n               }\n               else\n                  node_I3D[x_i][y_i][z_i] = lNode_I;\n            }\n   }\n\n   if( nDims == 3 ) {\n      for( x_i = 0; x_i < 4; x_i++ )\n         px[x_i] = Mesh_GetVertex( feMesh, node_I3D[x_i][0][0] )[0];\n      for( y_i = 0; y_i < 4; y_i++ )\n         py[y_i] = Mesh_GetVertex( feMesh, node_I3D[0][y_i][0] )[1];\n      for( z_i = 0; z_i < 4; z_i++ )\n         pz[z_i] = Mesh_GetVertex( feMesh, node_I3D[0][0][z_i] )[2];\n\n      for( z_i = 0; z_i < 4; z_i++ ) {\n         for( y_i = 0; y_i < 4; y_i++ ) {\n            for( x_i = 0; x_i < 4; x_i++ )\n               FeVariable_GetValueAtNode( feVariable, node_I3D[x_i][y_i][z_i], ptsX[x_i] );\n\n            InterpLagrange( position[0], px, ptsX, numdofs, ptsY[y_i] );\n         }\n\n         InterpLagrange( position[1], py, ptsY, numdofs, ptsZ[z_i] );\n      }\n\n      InterpLagrange( position[2], pz, ptsZ, numdofs, result );\n   }\n   else {\n      for( x_i = 0; x_i < 4; x_i++ )\n         px[x_i] = Mesh_GetVertex( feMesh, nodeIndex[x_i][0] )[0];\n      for( y_i = 0; y_i < 4; y_i++ )\n         py[y_i] = Mesh_GetVertex( feMesh, nodeIndex[0][y_i] )[1];\n\n      for( y_i = 0; y_i < 4; y_i++ ) {\n         for( x_i = 0; x_i < 4; x_i++ )\n            FeVariable_GetValueAtNode( feVariable, nodeIndex[x_i][y_i], ptsX[x_i] );\n\n         InterpLagrange( position[0], px, ptsX, numdofs, ptsY[y_i] );\n      }\n\n      InterpLagrange( position[1], py, ptsY, numdofs, result );\n   }\n\n   return True;\n}\n\n\n\nBool SemiLagrangianIntegrator_PointsAreClose( double* p1, double* p2, int dim, double rtol, double atol ) {\n  /* check if two points are within rtol (relative tolerance) \n   * or atol (absolute tolerance)\n   * \n   * Intput Parameters:\n   *  p1   : point 1\n   *  p2   : point 2\n   *  dim  : the dimensions of points\n   *  rtol : the relative tolerance\n   *  atol : the absolute tolerance\n   *\n   * Return Values:\n   *  True:  if points are close\n   *  False: if points are not close \n   */\n\n  double disp[3], p2_norm, length;\n\n  StGermain_VectorSubtraction(disp, p1, p2, dim); // displacement vector\n  length  = StGermain_VectorMagnitude(disp, dim); // length of vector\n  p2_norm = StGermain_VectorMagnitude(p2, dim);   // original size of p2\n\n  if (length < rtol*p2_norm + atol) return True;\n\n  return False;\n}\n\nvoid SemiLagrangianIntegrator_BuildStaticStencils( FeVariable* stencilField ) {\n  /* Function to build the node indices for cubic interpolation.\n   * The idea is to find a record the starting node indices (ijk) for each interpolant stencil.\n   *\n   * **NOTE**: We never want to Sync the stencilField FeVariable shadow values, ie.\n   *  FeVariable_SyncShadowValues( stencilField ), because the field contains processor\n   *  specific ordering and Syncing with shadow space will produce erroroneous starting indicies\n   *\n   */\n\n  FeMesh* feMesh = stencilField->feMesh;\n  Grid **grid;\n  int d_i,ijk[3];\n  double double_ijk[3];\n  unsigned *sizes,try,nDims,n_i, nNodes;\n  Index gNode_I;\n\n  nDims = Mesh_GetDimSize( feMesh );\n  nNodes = Mesh_GetDomainSize( feMesh, MT_VERTEX );\n  grid = (Grid**)ExtensionManager_Get( feMesh->info, feMesh, feMesh->vertGridId  );\n  sizes = Grid_GetSizes(*grid);\n\n  for( n_i=0; n_i<nNodes; n_i++) {\n    /* For every domain node, build the stencil starting location, ijk */\n    gNode_I = Mesh_DomainToGlobal( feMesh, MT_VERTEX, n_i );\n    Grid_Lift( *grid, gNode_I, ijk );\n\n    /* for every dim try go one node back */\n    for(d_i=0; d_i<nDims; d_i++) {\n      if( ijk[d_i] == 0 ) { continue; } // skip if at 0\n      ijk[d_i]--;\n      try = Grid_Project( *grid, ijk );\n      // if not in domain space don't go back one\n      if( !Mesh_GlobalToDomain( feMesh, MT_VERTEX, try, &try ) ) {\n        ijk[d_i]++;\n      }\n    }\n\n    /* for every dim try go 3 forward */\n    for(d_i=0; d_i<nDims; d_i++) {\n      ijk[d_i]+=3;\n\n      // if we go off the edge, go back one\n      if( ijk[d_i] >= sizes[d_i] ) {\n        ijk[d_i] -= 4;\n        continue;\n      }\n      try = Grid_Project( *grid, ijk );\n      // if not in domain space go back one, else reset\n      if( !Mesh_GlobalToDomain( feMesh, MT_VERTEX, try, &try ) ) {\n        ijk[d_i]-=4;\n      } else {\n        ijk[d_i]-=3;\n      }\n    }\n\n    double_ijk[0] = (double)ijk[0];\n    double_ijk[1] = (double)ijk[1];\n    double_ijk[2] = (double)ijk[2];\n\n    // save ijk as the starting point\n    FeVariable_SetValueAtNode( stencilField, n_i, &(double_ijk[0]) );\n   }\n}\n\n\nvoid SemiLagrangianIntegrator_SolveNew( FeVariable* variableField, double dt, FeVariable* velocityField, FeVariable* varStarField, FeVariable* stencilField ) {\n  /* Function evaluates varStarField - an interpolation of variableField taken at the departure points.\n   * Departure points are positions taken from the nodes and advected backwards along the characteristic curves.\n   * The interpolation method used is a cubic spline and the implementation is only compatible with orthogonal meshes.\n   *\n   * Input Args:\n   *   feVariable:    the original field to be interpolated.\n   *   dt:            the time step size to go backwards along the characteristic, it should NOT be > CFL condition. \n   *   velocityField: the velocity field used to go backward.\n   *   stencilField:  the field of initial spline stencils for each node.\n   *   varStarField:  the resultant field of interpolated variableField taken at the departure points.\n   *\n   */\n\n\n   FeMesh*   feMesh   = variableField->feMesh;\n   unsigned  meshSize = Mesh_GetLocalSize( feMesh, MT_VERTEX );\n   unsigned  nDims    = Mesh_GetDimSize( feMesh );\n   Grid**    nodegrid = (Grid**) Mesh_GetExtension( feMesh, Grid*,  feMesh->vertGridId );\n   unsigned* sizes    = Grid_GetSizes( *nodegrid );\n\n   unsigned  node_I;\n   double    var[3], x_i[3], delta[3], minLength, *x_0;\n   Bool      result;\n   \n   Mesh_GetMinimumSeparation( feMesh, &minLength, delta );\n\n   /* sync parallel field variables to get shadow values */\n   FeVariable_SyncShadowValues( velocityField );\n   FeVariable_SyncShadowValues( variableField );\n   \n   /* assume that the variable mesh is the same as the velocity mesh */\n   for( node_I = 0; node_I < meshSize; node_I++ ) {\n      /* find the position back in time (u*), x_i */\n      x_0 = Mesh_GetVertex(feMesh, node_I);\n      IntegrateRungeKutta( velocityField, dt, x_0, x_i );\n\n      /* if the new x_i is \"close\" to original node, don't Bicubuic Interpolate, take original node value */\n      if( SemiLagrangianIntegrator_PointsAreClose(x_i, x_0, nDims, 0, 1e-6*minLength) ) {\n        FeVariable_GetValueAtNode( variableField, node_I, var );\n      } else {\n        result = BicubicInterpolatorNew(variableField, stencilField, x_i, sizes, var);\n\n        /* if BicubicInerpolator returns false, x_i was not found in domain space.\n         * Fallback to using the node value. */\n        if(result == False) { FeVariable_GetValueAtNode( variableField, node_I, var ); }\n      }\n\n      FeVariable_SetValueAtNode( varStarField, node_I, var );\n   } \n\n   /* sync interpolated values */\n   FeVariable_SyncShadowValues( varStarField );\n}\n\nBool BicubicInterpolator( FeVariable* feVariable, double* position, double* delta, unsigned* nNodes, double* result ) {\n  /* Calculated the BicubicInterpolation of the feVariable at position\n   *\n   * Input Args:\n   *   feVariable: the field to be interpolated at `position`.\n   *   position:   the position of interpolatation.\n   *   delta:      memory chunk of size = sizeof(double)*dim.\n   *   nNodes:     numbers of nodes in ijk representation.\n   *   results:    the interpolated value.\n   *\n   *\n   * Returns Values:\n   *  True: if interpolation successful\n   *  False: position is not in 'domain' of local processor\n   */\n\n   FeMesh*\tfeMesh\t\t\t= feVariable->feMesh;\n   unsigned\tnInc ;\n   int    ijk[3];\n   int\t\tx_i, y_i, z_i, *inc;\n   double localMin[3], localMax[3];\n   Index  gNode_I, lNode_I, elementIndex;\n   double px[4], py[4], pz[4];\n   unsigned\tnodeIndex[4][4];\n   unsigned\tnode_I3D[4][4][4];\n   unsigned\tnDims   = Mesh_GetDimSize( feMesh );\n   unsigned\tnumdofs = feVariable->dofLayout->dofCounts[0];\n   double   ptsX[4][3], ptsY[4][3], ptsZ[4][3];\n   Bool     inDomain  = True;\n\n   inDomain = Mesh_SearchElements( feMesh, position, &elementIndex ); // get the element id\n\n   if (!inDomain) return False;\n\n   FeMesh_GetElementNodes( feMesh, elementIndex, feVariable->inc ); // get the incidence graph (inc.) of nodes on the element\n   nInc = IArray_GetSize( feVariable->inc );                        // from inc. get the number of nodes on the element\n   inc = IArray_GetPtr( feVariable->inc );                          // get the node ids from inc.\n\n   if( nInc % 3 == 0 ) /* quadratic elements */ {\n      delta[0] = Mesh_GetVertex( feMesh, inc[1] )[0] - Mesh_GetVertex( feMesh, inc[0] )[0];\n      delta[1] = Mesh_GetVertex( feMesh, inc[3] )[1] - Mesh_GetVertex( feMesh, inc[0] )[1];\n      if( nDims == 3 )\n         delta[2] = Mesh_GetVertex( feMesh, inc[9] )[2] - Mesh_GetVertex( feMesh, inc[0] )[2];\n   }\n   else {\n      delta[0] = Mesh_GetVertex( feMesh, inc[1] )[0] - Mesh_GetVertex( feMesh, inc[0] )[0];\n      delta[1] = Mesh_GetVertex( feMesh, inc[2] )[1] - Mesh_GetVertex( feMesh, inc[0] )[1];\n      if( nDims == 3 )\n         delta[2] = Mesh_GetVertex( feMesh, inc[4] )[2] - Mesh_GetVertex( feMesh, inc[0] )[2];\n   }\n\n   Mesh_GetLocalCoordRange( feMesh, localMin, localMax );\n   gNode_I = Mesh_DomainToGlobal( feMesh, MT_VERTEX, inc[0] );\n\n   {\n    Grid **grid;\n    int d_i;\n    unsigned *sizes;\n    grid = (Grid**)ExtensionManager_Get( feMesh->info, feMesh, feMesh->vertGridId  );\n    Grid_Lift( *grid, gNode_I, ijk );\n    sizes = Grid_GetSizes(*grid);\n\n    if( nInc % 2 == 0 ) {\n      unsigned try;\n      /* for every dim try go one node back */\n      for(d_i=0; d_i<nDims; d_i++) {\n        if( ijk[d_i] == 0 ) { continue; } // skip if at 0\n        ijk[d_i]--;\n        try = Grid_Project( *grid, ijk );\n        // if not in domain space don't go back one\n        if( !Mesh_GlobalToDomain( feMesh, MT_VERTEX, try, &try ) ) {\n          ijk[d_i]++;\n        }\n      }\n      /* for every dim try go 3 forward */\n      for(d_i=0; d_i<nDims; d_i++) {\n        ijk[d_i]+=3;\n\n        // if we go off the edge, go back one\n        if( ijk[d_i] >= sizes[d_i] ) {\n          ijk[d_i] -= 4;\n          continue;\n        }\n        try = Grid_Project( *grid, ijk );\n        // if not in domain space go back one, else reset\n        if( !Mesh_GlobalToDomain( feMesh, MT_VERTEX, try, &try ) ) {\n          ijk[d_i]-=4;\n        } else {\n          ijk[d_i]-=3;\n        }\n      }\n    }\n   }\n\n   /* interpolate using Lagrange's formula */\n   if( nDims == 2 ) {\n      for( y_i = 0; y_i < 4; y_i++ )\n         for( x_i = 0; x_i < 4; x_i++ ) {\n            gNode_I = ijk[0] + x_i + ( ijk[1] + y_i ) * nNodes[0];\n            if( !Mesh_GlobalToDomain( feMesh, MT_VERTEX, gNode_I, &lNode_I ) ){\n              printf(\"Error in BicubicInterpolator(), trying to build an interpolation to position (%g, %g) using node %d, a non domain node, in interpolator.\\n\", position[0], position[1], gNode_I);\n              abort();\n            }\n            else\n               nodeIndex[x_i][y_i] = lNode_I;\n         }\n   }\n   else {\n      for( z_i = 0; z_i < 4; z_i++ )\n         for( y_i = 0; y_i < 4; y_i++ )\n            for( x_i = 0; x_i < 4; x_i++ ) {\n               gNode_I = ijk[0] + x_i + ( ijk[1] + y_i ) * nNodes[0] + ( ijk[2] + z_i ) * nNodes[0] * nNodes[1];\n               if( !Mesh_GlobalToDomain( feMesh, MT_VERTEX, gNode_I, &lNode_I ) ) {\n                 printf(\"Error in BicubicInterpolator(), trying to build an interpolation to position (%g, %g, %g) using node %d, a non domain node, in interpolator.\\n\", position[0], position[1], position[2], gNode_I);\n                 abort();\n               }\n               else\n                  node_I3D[x_i][y_i][z_i] = lNode_I;\n            }\n   }\n\n   if( nDims == 3 ) {\n      for( x_i = 0; x_i < 4; x_i++ )\n         px[x_i] = Mesh_GetVertex( feMesh, node_I3D[x_i][0][0] )[0];\n      for( y_i = 0; y_i < 4; y_i++ )\n         py[y_i] = Mesh_GetVertex( feMesh, node_I3D[0][y_i][0] )[1];\n      for( z_i = 0; z_i < 4; z_i++ )\n         pz[z_i] = Mesh_GetVertex( feMesh, node_I3D[0][0][z_i] )[2];\n\n      for( z_i = 0; z_i < 4; z_i++ ) {\n         for( y_i = 0; y_i < 4; y_i++ ) {\n            for( x_i = 0; x_i < 4; x_i++ )\n               FeVariable_GetValueAtNode( feVariable, node_I3D[x_i][y_i][z_i], ptsX[x_i] );\n\n            InterpLagrange( position[0], px, ptsX, numdofs, ptsY[y_i] );\n         }\n\n         InterpLagrange( position[1], py, ptsY, numdofs, ptsZ[z_i] );\n      }\n\n      InterpLagrange( position[2], pz, ptsZ, numdofs, result );\n   }\n   else {\n      for( x_i = 0; x_i < 4; x_i++ )\n         px[x_i] = Mesh_GetVertex( feMesh, nodeIndex[x_i][0] )[0];\n      for( y_i = 0; y_i < 4; y_i++ )\n         py[y_i] = Mesh_GetVertex( feMesh, nodeIndex[0][y_i] )[1];\n\n      for( y_i = 0; y_i < 4; y_i++ ) {\n         for( x_i = 0; x_i < 4; x_i++ )\n            FeVariable_GetValueAtNode( feVariable, nodeIndex[x_i][y_i], ptsX[x_i] );\n\n         InterpLagrange( position[0], px, ptsX, numdofs, ptsY[y_i] );\n      }\n\n      InterpLagrange( position[1], py, ptsY, numdofs, result );\n   }\n\n   return True;\n}\n\n\nvoid SemiLagrangianIntegrator_Solve( void* slIntegrator, FeVariable* variableField, FeVariable* varStarField ) {\n   SemiLagrangianIntegrator*\tself \t\t     = (SemiLagrangianIntegrator*)slIntegrator;\n   FiniteElementContext*\t\tcontext\t\t     = self->context;\n   unsigned\t\t\tnode_I;\n   FeMesh*\t\t\tfeMesh\t\t     = variableField->feMesh;\n   unsigned\t\t\tmeshSize\t     = Mesh_GetLocalSize( feMesh, MT_VERTEX );\n   FeVariable*\t\t\tvelocityField\t     = self->velocityField;\n   double\t\t\t\tdt\t\t     = AbstractContext_Dt( context );\n   unsigned\t\t\tdim_I;\n   unsigned\t\t\tnDims\t\t     = Mesh_GetDimSize( feMesh );\n   double\t\t\t\tposition[3];\n   double\t\t\t\tvar[3];\n   Grid**\t\t\t\tgrid\t\t     = (Grid**) Mesh_GetExtension( feMesh, Grid*,  feMesh->elGridId );\n   unsigned*    sizes\t\t     = Grid_GetSizes( *grid );\n   unsigned\t\t\tnNodes[3];\n   double\t\t\t\tdelta[3];\n   unsigned\t\t\tnInc;\n   int*         inc;\n\n   FeMesh_GetElementNodes( variableField->feMesh, 0, variableField->inc );\n   nInc = IArray_GetSize( variableField->inc );\n   inc = IArray_GetPtr( variableField->inc );\n\n   delta[0] = Mesh_GetVertex( feMesh, inc[1] )[0] - Mesh_GetVertex( feMesh, inc[0] )[0];\n   if( nInc % 3 == 0 ) /* quadratic elements */ {\n      delta[1] = Mesh_GetVertex( feMesh, inc[3] )[1] - Mesh_GetVertex( feMesh, inc[0] )[1];\n      if( nDims == 3 )\n         delta[2] = Mesh_GetVertex( feMesh, inc[9] )[2] - Mesh_GetVertex( feMesh, inc[0] )[2];\n      for( dim_I = 0; dim_I < nDims; dim_I++ )\n         nNodes[dim_I] = 2 * sizes[dim_I] + 1;\n   }\n   else {\n      delta[1] = Mesh_GetVertex( feMesh, inc[2] )[1] - Mesh_GetVertex( feMesh, inc[0] )[1];\n      if( nDims == 3 )\n         delta[2] = Mesh_GetVertex( feMesh, inc[4] )[2] - Mesh_GetVertex( feMesh, inc[0] )[2];\n\n      for( dim_I = 0; dim_I < nDims; dim_I++ )\n         nNodes[dim_I] = sizes[dim_I] + 1;\n   }\n\n   FeVariable_SyncShadowValues( velocityField );\n   FeVariable_SyncShadowValues( variableField );\n\n   /* assume that the variable mesh is the same as the velocity mesh */\n   for( node_I = 0; node_I < meshSize; node_I++ ) {\n      /* find the position back in time (u*) */\n      IntegrateRungeKutta( velocityField, dt, Mesh_GetVertex(feMesh, node_I), position );\n\n      /* create a bicubic interpolation of variableField at u* */\n      BicubicInterpolator( variableField, position, delta, nNodes, var );\n\n      FeVariable_SetValueAtNode( varStarField, node_I, var );\n   }\n   FeVariable_SyncShadowValues( varStarField );\n}\n", "meta": {"hexsha": "74449ba60667dca412a76ec8b162cacbb104dcea", "size": 36483, "ext": "c", "lang": "C", "max_stars_repo_path": "underworld/libUnderworld/StgFEM/Utils/src/SemiLagrangianIntegrator.c", "max_stars_repo_name": "longgangfan/underworld2", "max_stars_repo_head_hexsha": "5c8acc17fa4d97e86a62b13b8bfb2af6e81a8ee4", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 116.0, "max_stars_repo_stars_event_min_datetime": "2015-09-28T10:30:55.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-22T04:12:38.000Z", "max_issues_repo_path": "underworld/libUnderworld/StgFEM/Utils/src/SemiLagrangianIntegrator.c", "max_issues_repo_name": "longgangfan/underworld2", "max_issues_repo_head_hexsha": "5c8acc17fa4d97e86a62b13b8bfb2af6e81a8ee4", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 561.0, "max_issues_repo_issues_event_min_datetime": "2015-09-29T06:05:50.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-22T23:37:29.000Z", "max_forks_repo_path": "underworld/libUnderworld/StgFEM/Utils/src/SemiLagrangianIntegrator.c", "max_forks_repo_name": "longgangfan/underworld2", "max_forks_repo_head_hexsha": "5c8acc17fa4d97e86a62b13b8bfb2af6e81a8ee4", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 68.0, "max_forks_repo_forks_event_min_datetime": "2015-12-14T21:57:46.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-25T04:54:26.000Z", "avg_line_length": 41.8383027523, "max_line_length": 218, "alphanum_fraction": 0.6416687224, "num_tokens": 10937, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.25386099567919973, "lm_q2_score": 0.026759282700350304, "lm_q1q2_score": 0.006793138149972113}}
{"text": "/*\nCopyright (c) 2015, Patrick Weltevrede\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <gsl/gsl_sort_float.h>\n#include <gsl/gsl_statistics_float.h>\n#include <gsl/gsl_integration.h>\n#include \"psrsalsa.h\"\nint filterPApoints(datafile_definition *datafile, verbose_definition verbose)\n{\n  int dPa_polnr;\n  long i, j, nrpoints;\n  float *olddata;\n  if(datafile->poltype != POLTYPE_ILVPAdPA && datafile->poltype != POLTYPE_PAdPA && datafile->poltype != POLTYPE_ILVPAdPATEldEl) {\n    printerror(verbose.debug, \"ERROR filterPApoints: Data doesn't appear to have poltype ILVPAdPA, PAdPA or ILVPAdPATEldEl.\");\n    return -1;\n  }\n  if(datafile->poltype == POLTYPE_ILVPAdPA && datafile->NrPols != 5) {\n    printerror(verbose.debug, \"ERROR filterPApoints: 5 polarization channels were expected, but there are only %ld.\", datafile->NrPols);\n    return -1;\n  }else if(datafile->poltype == POLTYPE_ILVPAdPATEldEl && datafile->NrPols != 8) {\n    printerror(verbose.debug, \"ERROR filterPApoints: 8 polarization channels were expected, but there are only %ld.\", datafile->NrPols);\n    return -1;\n  }else if(datafile->poltype == POLTYPE_PAdPA && datafile->NrPols != 2) {\n    printerror(verbose.debug, \"ERROR filterPApoints: 2 polarization channels were expected, but there are only %ld.\", datafile->NrPols);\n    return -1;\n  }\n  if(datafile->NrSubints > 1 || datafile->NrFreqChan > 1) {\n    printerror(verbose.debug, \"ERROR filterPApoints: Can only do this opperation if there is one subint and one frequency channel.\");\n    return -1;\n  }\n  if(datafile->tsampMode != TSAMPMODE_LONGITUDELIST) {\n    printerror(verbose.debug, \"ERROR filterPApoints: Expected pulse longitudes to be defined.\");\n    return -1;\n  }\n  if(datafile->poltype == POLTYPE_ILVPAdPA || datafile->poltype == POLTYPE_ILVPAdPATEldEl) {\n    dPa_polnr = 4;\n  }else if(datafile->poltype == POLTYPE_PAdPA) {\n    dPa_polnr = 1;\n  }\n  nrpoints = 0;\n  for(i = 0; i < datafile->NrBins; i++) {\n    if(datafile->data[i+dPa_polnr*datafile->NrBins] > 0 && isfinite(datafile->data[i+dPa_polnr*datafile->NrBins])) {\n      nrpoints++;\n    }\n  }\n  if(verbose.verbose)\n    printf(\"Keeping %ld significant PA points\\n\", nrpoints);\n  olddata = datafile->data;\n  datafile->data = (float *)malloc(nrpoints*datafile->NrPols*sizeof(float));\n  if(datafile->data == NULL) {\n    printerror(verbose.debug, \"ERROR filterPApoints: Memory allocation error.\");\n    return -1;\n  }\n  j = 0;\n  for(i = 0; i < datafile->NrBins; i++) {\n    if(olddata[i+dPa_polnr*datafile->NrBins] > 0 && isfinite(olddata[i+dPa_polnr*datafile->NrBins])) {\n      if(datafile->poltype == POLTYPE_ILVPAdPA) {\n datafile->data[j+0*nrpoints] = olddata[i+0*datafile->NrBins];\n datafile->data[j+1*nrpoints] = olddata[i+1*datafile->NrBins];\n datafile->data[j+2*nrpoints] = olddata[i+2*datafile->NrBins];\n datafile->data[j+3*nrpoints] = olddata[i+3*datafile->NrBins];\n datafile->data[j+4*nrpoints] = olddata[i+4*datafile->NrBins];\n      }else if(datafile->poltype == POLTYPE_ILVPAdPATEldEl) {\n datafile->data[j+0*nrpoints] = olddata[i+0*datafile->NrBins];\n datafile->data[j+1*nrpoints] = olddata[i+1*datafile->NrBins];\n datafile->data[j+2*nrpoints] = olddata[i+2*datafile->NrBins];\n datafile->data[j+3*nrpoints] = olddata[i+3*datafile->NrBins];\n datafile->data[j+4*nrpoints] = olddata[i+4*datafile->NrBins];\n datafile->data[j+5*nrpoints] = olddata[i+5*datafile->NrBins];\n datafile->data[j+6*nrpoints] = olddata[i+6*datafile->NrBins];\n datafile->data[j+7*nrpoints] = olddata[i+7*datafile->NrBins];\n      }else {\n datafile->data[j+0*nrpoints] = olddata[i+0*datafile->NrBins];\n datafile->data[j+1*nrpoints] = olddata[i+1*datafile->NrBins];\n      }\n      datafile->tsamp_list[j] = datafile->tsamp_list[i];\n      j++;\n    }\n  }\n  free(olddata);\n  datafile->NrBins = nrpoints;\n  return datafile->NrBins;\n}\nint make_paswing_fromIQUV_remove_lowS2N_points_sp_isLsignificant(float sigma_limit, int sigmaI, float dataL, float rmsI, float rmsL, verbose_definition verbose)\n{\n  if(sigmaI == 0) {\n    if(dataL < sigma_limit*rmsL) {\n      return 0;\n    }\n    return 1;\n  }else {\n    if(dataL < sigma_limit*rmsI) {\n      return 0;\n    }\n    return 1;\n  }\n}\nint make_paswing_fromIQUV_remove_lowS2N_points_sp_isPsignificant(float sigma_limit, int sigmaI, float dataP, float rmsI, float rmsP, verbose_definition verbose)\n{\n  if(sigmaI == 0) {\n    if(dataP < sigma_limit*rmsP) {\n      return 0;\n    }\n    return 1;\n  }else {\n    if(dataP < sigma_limit*rmsI) {\n      return 0;\n    }\n    return 1;\n  }\n}\nint make_paswing_fromIQUV_remove_lowS2N_points_sp_isVsignificant(float sigma_limit, int sigmaI, float dataV, float rmsI, float rmsV, verbose_definition verbose)\n{\n  if(sigmaI == 0) {\n    if(fabs(dataV) < sigma_limit*rmsV) {\n      return 0;\n    }\n    return 1;\n  }else {\n    if(fabs(dataV) < sigma_limit*rmsI) {\n      return 0;\n    }\n    return 1;\n  }\n}\nvoid make_paswing_fromIQUV_remove_lowS2N_points_sp(float sigma_limit, int sigmaI, int nrBins, float *dataL, float *dataP, float *dataPA, float *dataPaErr, float *dataEll, float *dataEllErr, float rmsI, float rmsL, float rmsP, pulselongitude_regions_definition *onpulse, verbose_definition verbose)\n{\n  long j;\n  if(sigma_limit < 0) {\n    return;\n  }\n  for(j = 0; j < nrBins; j++) {\n    int issignificant;\n    issignificant = 1;\n    if(onpulse != NULL) {\n      if(checkRegions(j, onpulse, 0, verbose) == 0) {\n issignificant = 0;\n      }\n    }\n    if(dataL != NULL && (dataPA != NULL || dataPaErr != NULL)) {\n      if(issignificant == 0 || make_paswing_fromIQUV_remove_lowS2N_points_sp_isLsignificant(sigma_limit, sigmaI, dataL[j], rmsI, rmsL, verbose) == 0) {\n if(dataPA != NULL) {\n   dataPA[j] = 0;\n }\n if(dataPaErr != NULL) {\n   dataPaErr[j] = -1;\n }\n      }\n    }\n    if(dataP != NULL && (dataEll != NULL || dataEllErr != NULL)) {\n      if(issignificant == 0 || make_paswing_fromIQUV_remove_lowS2N_points_sp_isPsignificant(sigma_limit, sigmaI, dataP[j], rmsI, rmsP, verbose) == 0) {\n if(dataEll != NULL) {\n   dataEll[j] = 0;\n }\n if(dataEllErr != NULL) {\n   dataEllErr[j] = -1;\n }\n      }\n    }\n  }\n}\nint make_paswing_fromIQUV_sp(float *dataI, float *dataQ, float *dataU, float *dataV, int nrBins, float *dataL, float *dataP, float *dataPA, float *dataPaErr, float *dataEll, float *dataEllErr, float *baseline_intensity, float *rmsI, float *rmsQ, float *rmsU, float *rmsV, float *rmsL, float *rmsP, float *medianL, float *medianP, pulselongitude_regions_definition onpulse, int normalize, int correctLbias, int correctPbias, float correctQV, float correctV, float paoffset, int rms_file_nrBins, float *rms_file_I, float *rms_file_Q, float *rms_file_U, float *rms_file_V, float rebin_factor, verbose_definition verbose)\n{\n  int rms_file_specified;\n  float *Loffpulse, *Poffpulse, median_L, median_P;\n  double ymax, avrgI, RMSI, RMSQ, RMSU, RMSV, RMSL, RMSP;\n  long i, nrOffpulseBins;\n  rms_file_specified = 1;\n  if(rms_file_I == NULL) {\n    rms_file_I = dataI;\n    rms_file_Q = dataQ;\n    rms_file_U = dataU;\n    rms_file_V = dataV;\n    rms_file_nrBins = nrBins;\n    rms_file_specified = 0;\n  }\n  Loffpulse = (float *)malloc(rms_file_nrBins*sizeof(float));\n  Poffpulse = (float *)malloc(rms_file_nrBins*sizeof(float));\n  if(Loffpulse == NULL || Poffpulse == NULL) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR make_paswing_fromIQUV_sp: Memory allocation error.\");\n    return 0;\n  }\n  if(normalize == 0) {\n    ymax = 1;\n  }else {\n    ymax = dataI[0];\n    for(i = 1; i < nrBins; i++) {\n      if(dataI[i] > ymax) {\n ymax = dataI[i];\n      }\n    }\n    if(ymax == 0) {\n      ymax = 1;\n    }\n  }\n  if(ymax != 1.0 || correctQV != 1.0 || correctV != 1.0) {\n    for(i = 0; i < nrBins; i++) {\n      dataI[i] /= ymax;\n      dataQ[i] /= correctQV*ymax;\n      dataU[i] /= ymax;\n      dataV[i] /= correctV*correctQV*ymax;\n    }\n    if(rms_file_specified) {\n      for(i = 0; i < rms_file_nrBins; i++) {\n rms_file_I[i] /= ymax;\n rms_file_Q[i] /= correctQV*ymax;\n rms_file_U[i] /= ymax;\n rms_file_V[i] /= correctV*correctQV*ymax;\n      }\n    }\n  }\n  nrOffpulseBins = 0;\n  avrgI = 0;\n  RMSI = 0;\n  RMSQ = 0;\n  RMSU = 0;\n  RMSV = 0;\n  RMSL = 0;\n  RMSP = 0;\n  for(i = 0; i < rms_file_nrBins; i++) {\n    if(checkRegions(i, &onpulse, 0, verbose) == 0) {\n      double sampleI2, sampleQ2, sampleU2, sampleV2;\n      avrgI += rms_file_I[i];\n      sampleI2 = rms_file_I[i]*rms_file_I[i];\n      sampleQ2 = rms_file_Q[i]*rms_file_Q[i];\n      sampleU2 = rms_file_U[i]*rms_file_U[i];\n      sampleV2 = rms_file_V[i]*rms_file_V[i];\n      RMSI += sampleI2;\n      RMSQ += sampleQ2;\n      RMSU += sampleU2;\n      RMSV += sampleV2;\n      RMSL += sampleQ2+sampleU2;\n      RMSP += sampleQ2+sampleU2+sampleV2;\n      Loffpulse[nrOffpulseBins] = sqrt(sampleQ2+sampleU2);\n      Poffpulse[nrOffpulseBins] = sqrt(sampleQ2+sampleU2+sampleV2);\n      nrOffpulseBins++;\n    }\n  }\n  avrgI /= (double)nrOffpulseBins;\n  RMSI = sqrt(RMSI/(double)nrOffpulseBins);\n  RMSQ = sqrt(RMSQ/(double)nrOffpulseBins);\n  RMSU = sqrt(RMSU/(double)nrOffpulseBins);\n  RMSV = sqrt(RMSV/(double)nrOffpulseBins);\n  RMSL = sqrt(RMSL/(double)nrOffpulseBins);\n  RMSP = sqrt(RMSP/(double)nrOffpulseBins);\n  if(rms_file_specified) {\n    double scale = 1.0/sqrt(rebin_factor);\n    RMSI *= scale;\n    RMSQ *= scale;\n    RMSU *= scale;\n    RMSV *= scale;\n    RMSL *= scale;\n    RMSP *= scale;\n  }\n  gsl_sort_float(Loffpulse, 1, nrOffpulseBins);\n  median_L = gsl_stats_float_median_from_sorted_data(Loffpulse, 1, nrOffpulseBins);\n  gsl_sort_float(Poffpulse, 1, nrOffpulseBins);\n  median_P = gsl_stats_float_median_from_sorted_data(Poffpulse, 1, nrOffpulseBins);\n  if(baseline_intensity != NULL)\n    *baseline_intensity = avrgI;\n  if(rmsI != NULL)\n    *rmsI = RMSI;\n  if(rmsQ != NULL)\n    *rmsQ = RMSQ;\n  if(rmsU != NULL)\n    *rmsU = RMSU;\n  if(rmsV != NULL)\n    *rmsV = RMSV;\n  if(rmsL != NULL)\n    *rmsL = RMSL;\n  if(rmsP != NULL)\n    *rmsP = RMSP;\n  if(medianL != NULL)\n    *medianL = median_L;\n  if(medianP != NULL)\n    *medianP = median_P;\n  for(i = 0; i < nrBins; i++) {\n    double sampleQ2, sampleU2, sampleV2, sampleL, sampleP;\n    sampleQ2 = dataQ[i]*dataQ[i];\n    sampleU2 = dataU[i]*dataU[i];\n    sampleV2 = dataV[i]*dataV[i];\n    sampleL = sqrt(sampleQ2+sampleU2);\n    if(correctLbias == 0) {\n      sampleL -= median_L;\n    }else if(correctLbias == 1) {\n      double junk = (sqrt(0.5*(RMSQ*RMSQ+RMSU*RMSU))/sampleL);\n      if(junk < 1.0) {\n sampleL *= sqrt(1.0-junk*junk);\n      }else {\n sampleL = 0.0;\n      }\n    }\n    if(dataL != NULL) {\n      dataL[i] = sampleL;\n    }\n    sampleP = sqrt(sampleQ2+sampleU2+sampleV2);\n    if(correctPbias == 0) {\n      sampleP -= median_P;\n    }\n    if(dataP != NULL) {\n      dataP[i] = sampleP;\n    }\n    if(dataPA != NULL) {\n      dataPA[i] = 90.0*atan2(dataU[i], dataQ[i])/M_PI;\n      if(paoffset != 0.0) {\n dataPA[i] += paoffset;\n dataPA[i] = derotate_180_small_double(dataPA[i]);\n      }\n    }\n    if(dataPaErr != NULL) {\n      if(sampleQ2 == 0 && sampleU2 == 0) {\n dataPaErr[i] = 0;\n      }else {\n dataPaErr[i] = sqrt(sampleQ2*RMSU*RMSU + sampleU2*RMSQ*RMSQ);\n dataPaErr[i] /= 2.0*(sampleQ2 + sampleU2);\n dataPaErr[i] *= 180.0/M_PI;\n      }\n    }\n    if(dataEll != NULL) {\n      if(sampleQ2 == 0 && sampleU2 == 0 && sampleV2 == 0) {\n dataEll[i] = 0;\n      }\n      double value;\n      value = dataV[i]/sqrt(sampleQ2+sampleU2+sampleV2);\n      if(value < -1.0) {\n value = -1.0;\n      }else if(value > 1.0) {\n value = 1.0;\n      }\n      dataEll[i] = 90.0*asin(value)/M_PI;\n    }\n    if(dataEllErr != NULL) {\n      if(dataQ[i] == 0 && dataU[i] == 0 && dataV[i] == 0) {\n dataEllErr[i] = -1;\n      }\n      dataEllErr[i] = sampleV2*(sampleQ2*RMSQ*RMSQ+sampleU2*RMSU*RMSU);\n      dataEllErr[i] += (sampleQ2+sampleU2)*(sampleQ2+sampleU2)*RMSV*RMSV;\n      dataEllErr[i] /= 4.0*(sampleQ2+sampleU2);\n      dataEllErr[i] = sqrt(dataEllErr[i]);\n      dataEllErr[i] /= (sampleQ2+sampleU2+sampleV2);\n      dataEllErr[i] *= 180.0/M_PI;\n    }\n  }\n  free(Loffpulse);\n  free(Poffpulse);\n  return 1;\n}\nvoid make_paswing_fromIQUV_reportRMS(long pulsenr, long freqnr, int extended, int spstat, float rmsI, float rmsQ, float rmsU, float rmsV, float rmsL, float rmsP, float medianL, float medianP, float baseline_intensity, verbose_definition verbose)\n{\n  int indent;\n  if(spstat == 0) {\n    for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n    fprintf(stdout, \"  PA conversion output for subint %ld frequency channel %ld:\\n\", pulsenr, freqnr);\n  }\n  for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n  fprintf(stdout, \"    Avrg baseline Stokes I:   %f (only reported, not subtracted)\\n\", baseline_intensity);\n  for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n  fprintf(stdout, \"    RMS I:                    %f\\n\", rmsI);\n  for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n  fprintf(stdout, \"    RMS Q:                    %f\\n\", rmsQ);\n  for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n  fprintf(stdout, \"    RMS U:                    %f\\n\", rmsU);\n  for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n  fprintf(stdout, \"    RMS V:                    %f\\n\", rmsV);\n  for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n  fprintf(stdout, \"    RMS L (before de-bias):   %f\\n\", rmsL);\n  if(extended) {\n    for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n    fprintf(stdout, \"    RMS sqrt(Q^2+U^2+V^2):    %f\\n\", rmsP);\n  }\n  for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n  fprintf(stdout, \"    Median L:                 %f\\n\", medianL);\n  if(extended) {\n    for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n    fprintf(stdout, \"    Median sqrt(Q^2+U^2+V^2): %f\\n\", medianP);\n  }\n}\nint make_paswing_fromIQUV(datafile_definition *datafile, int extended, int spstat, float sigma_limit, int sigmaI, pulselongitude_regions_definition onpulse, int normalize, int correctLbias, int correctPbias, float correctQV, float correctV, int nolongitudes, float loffset, float paoffset, datafile_definition *rms_file, float rebin_factor, int onpulseonly, verbose_definition verbose)\n{\n  int indent, output_nr_pols;\n  long i, pulsenr, freqnr;\n  float *newdata, *newdata_current_pulse;\n  if(verbose.verbose) {\n    for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n    printf(\"Constructing PA and degree of linear polarization\");\n    if(extended)\n      printf(\", total polarization and ellipticity\");\n    if(rms_file != NULL)\n      printf(\" (using a seperate file to determine the off-pulse rms)\");\n    printf(\"\\n\");\n    for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n    printf(\"  Reference frequency for PA is \");\n    if(datafile->isDeFarad) {\n      if((datafile->freq_ref > -1.1 && datafile->freq_ref < -0.9) || (datafile->freq_ref > 0.99e10 && datafile->freq_ref < 1.01e10))\n printf(\"infinity\\n\");\n      else if(datafile->freq_ref < 0)\n printf(\"unknown\\n\");\n      else\n printf(\"%f MHz\\n\", datafile->freq_ref);\n    }else {\n      if(datafile->NrFreqChan == 1)\n printf(\"%lf MHz\\n\", get_centre_frequency(*datafile, verbose));\n      else\n printf(\"observing frequencies of individual frequency channels\\n\");\n    }\n    for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n    printf(\"  \");\n    switch(correctLbias) {\n    case -1: printf(\"No L de-bias applied\"); break;\n    case 0: printf(\"De-bias L using median noise subtraction\"); break;\n    case 1: printf(\"De-bias L using Wardle & Kronberg correction\"); break;\n    default: printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Undefined L de-bias method specified.\"); return 0;\n    }\n    if(extended) {\n      switch(correctPbias) {\n      case -1: printf(\", no P de-bias applied\"); break;\n      case 0: printf(\", de-bias P using median noise subtraction\"); break;\n      case 1: printf(\", de-bias P using Wardle & Kronberg like correction\"); break;\n      default: printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Undefined P de-bias method specified.\"); return 0;\n      }\n    }\n    if(correctQV != 1 || correctV != 1)\n      printf(\", Q correction factor %f, V correction factor %f\", 1.0/correctQV, 1.0/(correctQV*correctV));\n    if(normalize)\n      printf(\", output is normalised\");\n    if(loffset != 0)\n      printf(\", pulse longitude shifted by %f deg\\n\", loffset);\n    if(paoffset != 0)\n      printf(\", PA shifted by %f deg\\n\", paoffset);\n    printf(\"\\n\");\n  }\n  if(datafile->NrPols != 4) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Expected 4 input polarizations.\");\n    return 0;\n  }\n  if(rms_file != NULL) {\n    if(rms_file->NrPols != 4) {\n      fflush(stdout);\n      printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Expected 4 input polarizations.\");\n      return 0;\n    }\n  }\n  if(datafile->poltype != POLTYPE_STOKES) {\n    if(datafile->poltype == POLTYPE_UNKNOWN) {\n      printwarning(verbose.debug, \"WARNING make_paswing_fromIQUV: Polarization state unknown, it is assumed the data are Stokes parameters.\");\n    }else {\n      printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Please convert data into Stokes parameters first.\");\n      return 0;\n    }\n  }\n  if(rms_file != NULL) {\n    if(rms_file->poltype != POLTYPE_STOKES) {\n      if(rms_file->poltype == POLTYPE_UNKNOWN) {\n printwarning(verbose.debug, \"WARNING make_paswing_fromIQUV: Polarization state of the data to be used to determine the off-pulse rms is unknown. It is assumed the data are Stokes parameters.\");\n      }else {\n printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Please convert data to be used to determine the off-pulse rms into Stokes parameters first.\");\n return 0;\n      }\n    }\n  }\n  if(datafile->tsampMode != TSAMPMODE_FIXEDTSAMP) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: It is expected that the input has a uniform time sampling.\");\n    return 0;\n  }\n  if(correctQV == 0) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: correctQV is set to zero, you probably want this to be 1.\");\n    return 0;\n  }\n  if(correctV == 0) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: correctV is set to zero, you probably want this to be 1.\");\n    return 0;\n  }\n  if(datafile->isDebase == 0) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Please remove baseline first, i.e. use pmod -debase.\");\n    return 0;\n  }else if(datafile->isDebase != 1) {\n    fflush(stdout);\n    printwarning(verbose.debug, \"WARNING make_paswing_fromIQUV: Unknown baseline removal state. It will be assumed the baseline has already removed from the data.\");\n  }\n  if(rms_file != NULL) {\n    if(rms_file->isDebase == 0) {\n      fflush(stdout);\n      printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Please remove baseline first, i.e. use pmod -debase.\");\n      return 0;\n    }else if(rms_file->isDebase != 1) {\n      fflush(stdout);\n      printwarning(verbose.debug, \"WARNING make_paswing_fromIQUV: Unknown baseline removal state. It is assumed the baseline has already removed from the data.\");\n    }\n    if(datafile->NrSubints != rms_file->NrSubints) {\n      printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Number of subintegrations is different in the data to be used to determine the off-pulse rms compared to the data used to compute the polarization information.\");\n return 0;\n    }\n    if(datafile->NrFreqChan != rms_file->NrFreqChan) {\n      printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Number of frequency channels is different in the data to be used to determine the off-pulse rms compared to the data used to compute the polarization information (%ld != %ld).\", rms_file->NrFreqChan, datafile->NrFreqChan);\n return 0;\n    }\n    if(correctLbias == 0) {\n      printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Subtracting the median of L is not supported when a separate file is used for the off-pulse statistics.\");\n      return 0;\n    }\n    if(extended && correctPbias == 0) {\n      printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Subtracting the median of P is not supported when a separate file is used for the off-pulse statistics.\");\n      return 0;\n    }\n  }\n  if(normalize && (datafile->NrSubints > 1 || datafile->NrFreqChan > 1)) {\n    if(spstat == 0) {\n      fflush(stdout);\n      printwarning(verbose.debug, \"WARNING make_paswing_fromIQUV: Normalization of the polarization information will cause all subintegrations/frequency channels to be normalised individually. This may not be desired.\");\n    }\n  }\n  if(extended) {\n    output_nr_pols = 8;\n  }else {\n    output_nr_pols = 5;\n  }\n  if(spstat == 0) {\n    newdata = (float *)malloc(datafile->NrBins*datafile->NrSubints*datafile->NrFreqChan*output_nr_pols*sizeof(float));\n  }else {\n    newdata = (float *)malloc(datafile->NrBins*output_nr_pols*sizeof(float));\n    newdata_current_pulse = (float *)malloc(datafile->NrBins*output_nr_pols*sizeof(float));\n  }\n  if(datafile->offpulse_rms != NULL) {\n    free(datafile->offpulse_rms);\n  }\n  if(spstat == 0) {\n    datafile->offpulse_rms = (float *)malloc(datafile->NrSubints*datafile->NrFreqChan*output_nr_pols*sizeof(float));\n  }else {\n    datafile->offpulse_rms = (float *)malloc(output_nr_pols*sizeof(float));\n  }\n  if(newdata == NULL || datafile->offpulse_rms == NULL\n     ) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Memory allocation error.\");\n    return 0;\n  }\n  if(nolongitudes == 0) {\n    datafile->tsamp_list = (double *)malloc(datafile->NrBins*sizeof(double));\n    if(datafile->tsamp_list == NULL) {\n      fflush(stdout);\n      printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Memory allocation error.\");\n      return 0;\n    }\n    for(i = 0; i < datafile->NrBins; i++) {\n      datafile->tsamp_list[i] = get_pulse_longitude(*datafile, 0, i, verbose);\n      datafile->tsamp_list[i] += loffset;\n    }\n  }\n  float *dataI, *dataQ, *dataU, *dataV, *newdataL, *newdataP, *newdataPa, *newdataPaErr, *newdataEll, *newdataEllErr;\n  float baseline_intensity, rmsI, rmsQ, rmsU, rmsV, rmsL, rmsP, medianL, medianP;\n  for(pulsenr = 0; pulsenr < datafile->NrSubints; pulsenr++) {\n    for(freqnr = 0; freqnr < datafile->NrFreqChan; freqnr++) {\n      int normalize_sp;\n      dataI = &(datafile->data[datafile->NrBins*(0+datafile->NrPols*(freqnr+pulsenr*datafile->NrFreqChan))]);\n      dataQ = &(datafile->data[datafile->NrBins*(1+datafile->NrPols*(freqnr+pulsenr*datafile->NrFreqChan))]);\n      dataU = &(datafile->data[datafile->NrBins*(2+datafile->NrPols*(freqnr+pulsenr*datafile->NrFreqChan))]);\n      dataV = &(datafile->data[datafile->NrBins*(3+datafile->NrPols*(freqnr+pulsenr*datafile->NrFreqChan))]);\n      if(spstat == 0) {\n newdataL = &(newdata[datafile->NrBins*(1+output_nr_pols*(freqnr+datafile->NrFreqChan*pulsenr))]);\n newdataPa = &(newdata[datafile->NrBins*(3+output_nr_pols*(freqnr+datafile->NrFreqChan*pulsenr))]);\n newdataPaErr = &(newdata[datafile->NrBins*(4+output_nr_pols*(freqnr+datafile->NrFreqChan*pulsenr))]);\n normalize_sp = normalize;\n      }else {\n newdataL = &(newdata_current_pulse[datafile->NrBins*1]);\n newdataPa = NULL;\n newdataPaErr = NULL;\n normalize_sp = 0;\n      }\n      if(extended == 0) {\n newdataP = NULL;\n newdataEll = NULL;\n newdataEllErr = NULL;\n      }else {\n if(spstat == 0) {\n   newdataP = &(newdata[datafile->NrBins*(5+output_nr_pols*(freqnr+datafile->NrFreqChan*pulsenr))]);\n   newdataEll = &(newdata[datafile->NrBins*(6+output_nr_pols*(freqnr+datafile->NrFreqChan*pulsenr))]);\n   newdataEllErr = &(newdata[datafile->NrBins*(7+output_nr_pols*(freqnr+datafile->NrFreqChan*pulsenr))]);\n }else {\n   newdataP = &(newdata_current_pulse[datafile->NrBins*5]);\n   newdataEll = NULL;\n   newdataEllErr = NULL;\n }\n      }\n      long rms_file_nrBins;\n      float *rms_file_I, *rms_file_Q, *rms_file_U, *rms_file_V;\n      if(rms_file != NULL) {\n rms_file_nrBins = rms_file->NrBins;\n rms_file_I = &(rms_file->data[rms_file->NrBins*(0+rms_file->NrPols*(freqnr+pulsenr*rms_file->NrFreqChan))]);\n rms_file_Q = &(rms_file->data[rms_file->NrBins*(1+rms_file->NrPols*(freqnr+pulsenr*rms_file->NrFreqChan))]);\n rms_file_U = &(rms_file->data[rms_file->NrBins*(2+rms_file->NrPols*(freqnr+pulsenr*rms_file->NrFreqChan))]);\n rms_file_V = &(rms_file->data[rms_file->NrBins*(3+rms_file->NrPols*(freqnr+pulsenr*rms_file->NrFreqChan))]);\n      }else {\n rms_file_nrBins = 0;\n rms_file_I = NULL;\n rms_file_Q = NULL;\n rms_file_U = NULL;\n rms_file_V = NULL;\n      }\n      if(make_paswing_fromIQUV_sp(dataI, dataQ, dataU, dataV, datafile->NrBins, newdataL, newdataP, newdataPa, newdataPaErr, newdataEll, newdataEllErr, &baseline_intensity, &rmsI, &rmsQ, &rmsU, &rmsV, &rmsL, &rmsP, &medianL, &medianP, onpulse, normalize_sp, correctLbias, correctPbias, correctQV, correctV, paoffset, rms_file_nrBins, rms_file_I, rms_file_Q, rms_file_U, rms_file_V, rebin_factor, verbose) == 0) {\n printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Calculating polarization products failed.\");\n return 0;\n      }\n      pulselongitude_regions_definition *onpulse_ptr;\n      onpulse_ptr = NULL;\n      if(onpulseonly) {\n onpulse_ptr = &onpulse;\n      }\n      make_paswing_fromIQUV_remove_lowS2N_points_sp(sigma_limit, sigmaI, datafile->NrBins, newdataL, newdataP, newdataPa, newdataPaErr, newdataEll, newdataEllErr, rmsI, rmsL, rmsP, onpulse_ptr, verbose);\n      if(spstat == 0) {\n for(i = 0; i < datafile->NrBins; i++) {\n   newdata[datafile->NrBins*(0+output_nr_pols*(freqnr+datafile->NrFreqChan*pulsenr))+i] = dataI[i];\n   newdata[datafile->NrBins*(2+output_nr_pols*(freqnr+datafile->NrFreqChan*pulsenr))+i] = dataV[i];\n        }\n datafile->offpulse_rms[0+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] = rmsI;\n datafile->offpulse_rms[1+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] = rmsL;\n datafile->offpulse_rms[2+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] = rmsV;\n datafile->offpulse_rms[3+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] = -1;\n datafile->offpulse_rms[4+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] = -1;\n if(extended) {\n   datafile->offpulse_rms[5+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] = rmsP;\n   datafile->offpulse_rms[6+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] = -1;\n   datafile->offpulse_rms[7+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] = -1;\n }\n      }\n      if(verbose.verbose) {\n if(spstat == 0 && ((freqnr == 0 && pulsenr == 0) || verbose.debug)) {\n   if(datafile->NrFreqChan > 1 || datafile->NrSubints > 1) {\n     for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n     fprintf(stdout, \"    Statistics based on first processed pulse\\n\");\n   }\n   if(extended) {\n     make_paswing_fromIQUV_reportRMS(pulsenr, freqnr, extended, spstat, datafile->offpulse_rms[0+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)], rmsQ, rmsU, datafile->offpulse_rms[2+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)], datafile->offpulse_rms[1+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)], datafile->offpulse_rms[5+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)], medianL, medianP, baseline_intensity, verbose);\n   }else {\n     make_paswing_fromIQUV_reportRMS(pulsenr, freqnr, extended, spstat, datafile->offpulse_rms[0+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)], rmsQ, rmsU, datafile->offpulse_rms[2+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)], datafile->offpulse_rms[1+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)], 0.0, medianL, 0.0, baseline_intensity, verbose);\n   }\n }\n      }\n    }\n  }\n  free(datafile->data);\n  datafile->data = newdata;\n  if(nolongitudes == 0) {\n    datafile->tsampMode = TSAMPMODE_LONGITUDELIST;\n  }\n  datafile->NrPols = output_nr_pols;\n  if(extended) {\n    datafile->poltype = POLTYPE_ILVPAdPATEldEl;\n  }else {\n    datafile->poltype = POLTYPE_ILVPAdPA;\n  }\n  return 1;\n}\nvoid paswing_remove_observed_PA_swing_sp(float *dataPA, float *dataPAerr, float *dataPAref, float *dataPArefErr, int nrBins, int add, verbose_definition verbose)\n{\n  int ok;\n  long j;\n  for(j = 0; j < nrBins; j++) {\n    ok = 1;\n    if(dataPAerr != NULL) {\n      if(dataPAerr[j] < 0) {\n ok = 0;\n      }\n    }\n    if(dataPArefErr != NULL) {\n      if(dataPArefErr[j] < 0) {\n ok = 0;\n dataPA[j] = 0;\n if(dataPAerr != NULL) {\n   dataPAerr[j] = -1;\n }\n      }\n    }\n    if(ok) {\n      if(add) {\n dataPA[j] += dataPAref[j];\n      }else {\n dataPA[j] -= dataPAref[j];\n      }\n      dataPA[j] = derotate_180(dataPA[j]) - 90;\n      if(dataPAerr != NULL && dataPArefErr != NULL) {\n dataPAerr[j] = sqrt(dataPAerr[j]*dataPAerr[j]+dataPArefErr[j]*dataPArefErr[j]);\n      }\n    }else {\n      dataPA[j] = 0;\n      if(dataPAerr != NULL) {\n dataPAerr[j] = -1;\n      }\n    }\n  }\n}\nint paswing_remove_observed_PA_swing(datafile_definition *datafile, datafile_definition datafile_reference, int add, verbose_definition verbose)\n{\n  int pachannel_ref, pachannelerr_ref, pachannel, pachannelerr;\n  if(datafile->poltype != POLTYPE_ILVPAdPA && datafile->poltype != POLTYPE_PAdPA && datafile->poltype != POLTYPE_ILVPAdPATEldEl) {\n    printerror(verbose.debug, \"ERROR paswing_remove_observed_PA_swing: Data doesn't appear to have poltype ILVPAdPA, PAdPA or ILVPAdPATEldEl.\");\n    return 0;\n  }\n  if(datafile_reference.poltype != POLTYPE_ILVPAdPA && datafile_reference.poltype != POLTYPE_PAdPA && datafile_reference.poltype != POLTYPE_ILVPAdPATEldEl) {\n    printerror(verbose.debug, \"ERROR paswing_remove_observed_PA_swing: Data in the reference doesn't appear to have poltype ILVPAdPA, PAdPA or ILVPAdPATEldEl.\");\n    return 0;\n  }\n  if(datafile->poltype == POLTYPE_ILVPAdPA && datafile->NrPols != 5) {\n    printerror(verbose.debug, \"ERROR paswing_remove_observed_PA_swing: 5 polarization channels were expected, but there are only %ld.\", datafile->NrPols);\n    return 0;\n  }else if(datafile->poltype == POLTYPE_ILVPAdPATEldEl && datafile->NrPols != 8) {\n    printerror(verbose.debug, \"ERROR paswing_remove_observed_PA_swing: 8 polarization channels were expected, but there are only %ld.\", datafile->NrPols);\n    return 0;\n  }else if(datafile->poltype == POLTYPE_PAdPA && datafile->NrPols != 2) {\n    printerror(verbose.debug, \"ERROR paswing_remove_observed_PA_swing: 2 polarization channels were expected, but there are only %ld.\", datafile->NrPols);\n    return 0;\n  }\n  if(datafile_reference.poltype == POLTYPE_ILVPAdPA && datafile_reference.NrPols != 5) {\n    printerror(verbose.debug, \"ERROR paswing_remove_observed_PA_swing: 5 polarization channels were expected in the reference, but there are only %ld.\", datafile_reference.NrPols);\n    return 0;\n  }else if(datafile_reference.poltype == POLTYPE_ILVPAdPATEldEl && datafile_reference.NrPols != 8) {\n    printerror(verbose.debug, \"ERROR paswing_remove_observed_PA_swing: 8 polarization channels were expected in the reference, but there are only %ld.\", datafile_reference.NrPols);\n    return 0;\n  }else if(datafile_reference.poltype == POLTYPE_PAdPA && datafile_reference.NrPols != 2) {\n    printerror(verbose.debug, \"ERROR paswing_remove_observed_PA_swing: 2 polarization channels were expected in the reference, but there are only %ld.\", datafile_reference.NrPols);\n    return 0;\n  }\n  if(datafile_reference.NrBins != datafile->NrBins) {\n    printerror(verbose.debug, \"ERROR paswing_remove_observed_PA_swing: Mismatch in the number of bins in the data and the reference (%ld != %ld).\", datafile->NrBins, datafile_reference.NrBins);\n    return 0;\n  }\n  if(datafile_reference.NrFreqChan != 1) {\n    printerror(verbose.debug, \"ERROR paswing_remove_observed_PA_swing: The number of frequency channels in the reference should be 1 (it is %ld).\", datafile_reference.NrFreqChan);\n    return 0;\n  }\n  if(datafile_reference.NrSubints != 1) {\n    printerror(verbose.debug, \"ERROR paswing_remove_observed_PA_swing: The number of subints in the reference should be 1 (it is %ld).\", datafile_reference.NrSubints);\n    return 0;\n  }\n  if(datafile->poltype == POLTYPE_ILVPAdPA || datafile->poltype == POLTYPE_ILVPAdPATEldEl) {\n    pachannel = 3;\n    pachannelerr = 4;\n  }else if(datafile->poltype == POLTYPE_PAdPA) {\n    pachannel = 0;\n    pachannelerr = 1;\n  }\n  if(datafile_reference.poltype == POLTYPE_ILVPAdPA || datafile_reference.poltype == POLTYPE_ILVPAdPATEldEl) {\n    pachannel_ref = 3;\n    pachannelerr_ref = 4;\n  }else if(datafile_reference.poltype == POLTYPE_PAdPA) {\n    pachannel_ref = 0;\n    pachannelerr_ref = 1;\n  }\n  long i, f;\n  for(i = 0; i < datafile->NrSubints; i++) {\n    for(f = 0; f < datafile->NrFreqChan; f++) {\n      paswing_remove_observed_PA_swing_sp(&(datafile->data[datafile->NrBins*(pachannel + datafile->NrPols*(f+datafile->NrFreqChan*i))]), &(datafile->data[datafile->NrBins*(pachannelerr + datafile->NrPols*(f+datafile->NrFreqChan*i))]), &(datafile_reference.data[datafile->NrBins*pachannel_ref]), &(datafile_reference.data[datafile->NrBins*pachannelerr_ref]), datafile->NrBins, add, verbose);\n    }\n  }\n  return 1;\n}\nint writePPOLHeader(datafile_definition datafile, int argc, char **argv, verbose_definition verbose)\n{\n  char *txt;\n  txt = malloc(10000);\n  if(txt == NULL) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR writePPOLHeader: Memory allocation error.\");\n    return 0;\n  }\n  constructCommandLineString(txt, 10000, argc, argv, verbose);\n  fprintf(datafile.fptr_hdr, \"#ppol file: %s\\n\", txt);\n  free(txt);\n  return 1;\n}\nint readPPOLHeader(datafile_definition *datafile, int extended, verbose_definition verbose)\n{\n  float dummy_float;\n  int ret, maxlinelength, nrwords;\n  char *txt, *ret_ptr, *word_ptr;\n  maxlinelength = 2000;\n  txt = malloc(maxlinelength);\n  if(txt == NULL) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR readPPOLHeader: Memory allocation error.\");\n    return 0;\n  }\n  datafile->isFolded = 1;\n  datafile->foldMode = FOLDMODE_FIXEDPERIOD;\n  datafile->fixedPeriod = 0;\n  datafile->tsampMode = TSAMPMODE_LONGITUDELIST;\n  datafile->fixedtsamp = 0;\n  datafile->tsubMode = TSUBMODE_FIXEDTSUB;\n  if(datafile->tsub_list != NULL)\n    free(datafile->tsub_list);\n  datafile->tsub_list = (double *)malloc(sizeof(double));\n  if(datafile->tsub_list == NULL) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR readPPOLHeader: Memory allocation error\");\n    return 0;\n  }\n  datafile->tsub_list[0] = 0;\n  datafile->NrSubints = 1;\n  datafile->NrFreqChan = 1;\n  datafile->datastart = 0;\n  rewind(datafile->fptr);\n  ret = fread(txt, 1, 3, datafile->fptr);\n  txt[3] = 0;\n  if(ret != 3) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR readPPOLHeader: cannot read from file.\");\n    free(txt);\n    return 0;\n  }\n  if(strcmp(txt, \"#pp\") != 0\n) {\n    fflush(stdout);\n    printwarning(verbose.debug, \"WARNING readPPOLHeader: File does not appear to be in PPOL or PPOLSHORT format. I will try to load file, but this will probably fail. Did you run ppol first?\");\n  }\n  skipallhashedlines(datafile);\n  datafile->NrBins = 0;\n  dummy_float = 0;\n  do {\n    ret_ptr = fgets(txt, maxlinelength, datafile->fptr);\n    if(ret_ptr != NULL) {\n      if(txt[0] != '#') {\n if(extended) {\n   word_ptr = pickWordFromString(txt, 2, &nrwords, 1, ' ', verbose);\n   if(nrwords != 10 && nrwords != 14) {\n     fflush(stdout);\n     printerror(verbose.debug, \"ERROR readPPOLHeader: Line should have 10 or 14 words, got %d\", nrwords);\n     if(nrwords == 3)\n       printerror(verbose.debug, \"                             Maybe file is in format %s?\", returnFileFormat_str(PPOL_SHORT_format));\n     printerror(verbose.debug, \"                             Line: '%s'.\", txt);\n     free(txt);\n     return 0;\n   }\n   if(nrwords == 10) {\n     datafile->poltype = POLTYPE_ILVPAdPA;\n     datafile->NrPols = 5;\n   }else {\n     datafile->poltype = POLTYPE_ILVPAdPATEldEl;\n     datafile->NrPols = 8;\n   }\n }else {\n   word_ptr = pickWordFromString(txt, 1, &nrwords, 1, ' ', verbose);\n   if(nrwords != 3) {\n     fflush(stdout);\n     printerror(verbose.debug, \"ERROR readPPOLHeader: Line should have 3 words, got %d\", nrwords);\n     if(nrwords == 10)\n       printerror(verbose.debug, \"                             Maybe file is in format %s?\", returnFileFormat_str(PPOL_format));\n     printerror(verbose.debug, \"                             Line: '%s'.\", txt);\n     free(txt);\n     return 0;\n   }\n }\n ret = sscanf(word_ptr, \"%f\", &dummy_float);\n if(ret != 1) {\n   fflush(stdout);\n   printerror(verbose.debug, \"ERROR readPPOLHeader: Cannot interpret as a float: '%s'.\", txt);\n   free(txt);\n   return 0;\n }\n if(dummy_float >= 360) {\n   fflush(stdout);\n   printwarning(verbose.debug, \"WARNING: IGNORING POINTS AT PULSE LONGITUDES > 360 deg.\");\n }else {\n   (datafile->NrBins)++;\n }\n      }\n    }\n  }while(ret_ptr != NULL && dummy_float < 360);\n  if(extended == 0) {\n    datafile->poltype = POLTYPE_PAdPA;\n    datafile->NrPols = 2;\n  }\n  fflush(stdout);\n  if(verbose.verbose) fprintf(stdout, \"Going to load %ld points from %s\\n\", datafile->NrBins, datafile->filename);\n  if(datafile->NrBins == 0) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR readPPOLHeader: No data in %s\", datafile->filename);\n    free(txt);\n    return 0;\n  }\n  fseek(datafile->fptr, datafile->datastart, SEEK_SET);\n  free(txt);\n  if(datafile->offpulse_rms != NULL) {\n    free(datafile->offpulse_rms);\n    datafile->offpulse_rms = NULL;\n  }\n  if(extended) {\n    datafile->offpulse_rms = (float *)malloc(datafile->NrSubints*datafile->NrFreqChan*datafile->NrPols*sizeof(float));\n    if(datafile->offpulse_rms == NULL) {\n      fflush(stdout);\n      printerror(verbose.debug, \"ERROR readPPOLHeader: Memory allocation error\");\n      return 0;\n    }\n  }\n  datafile->tsamp_list = (double *)malloc(datafile->NrBins*sizeof(double));\n  if(datafile->tsamp_list == NULL) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR readPPOLHeader: Memory allocation error\");\n    return 0;\n  }\n  return 1;\n}\nint readPPOLfile(datafile_definition *datafile, float *data, int extended, float add_longitude_shift, verbose_definition verbose)\n{\n  int maxlinelength;\n  long i, k, dummy_long;\n  char *txt, *ret_ptr;\n  if(datafile->NrBins == 0) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR readPPOLfile: No data in %s\", datafile->filename);\n    return 0;\n  }\n  maxlinelength = 2000;\n  txt = malloc(maxlinelength);\n  if(txt == NULL) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR readPPOLfile: Memory allocation error.\");\n    return 0;\n  }\n  fseek(datafile->fptr, datafile->datastart, SEEK_SET);\n  k = 0;\n  if(extended) {\n    datafile->offpulse_rms[3] = -1;\n    datafile->offpulse_rms[4] = -1;\n    if(datafile->NrPols == 8) {\n      datafile->offpulse_rms[6] = -1;\n      datafile->offpulse_rms[7] = -1;\n    }\n  }\n  for(i = 0; i < datafile->NrBins; i++) {\n    ret_ptr = fgets(txt, maxlinelength, datafile->fptr);\n    if(ret_ptr == NULL) {\n      fflush(stdout);\n      printerror(verbose.debug, \"ERROR readPPOLfile: Cannot read next line, should not happen after successfully reading in header\");\n      free(txt);\n      return 0;\n    }\n    if(txt[0] != '#') {\n      if(extended == 0) {\n sscanf(txt, \"%lf %f %f\", &(datafile->tsamp_list[k]), &(data[k]), &(data[k+datafile->NrBins]));\n      }else {\n if(datafile->NrPols == 8) {\n   sscanf(txt, \"%ld %lf %f %f %f %f %f %f %f %f %f %f %f %f\", &dummy_long, &(datafile->tsamp_list[k]), &(data[k]), &(datafile->offpulse_rms[0]), &(data[k+datafile->NrBins]), &(datafile->offpulse_rms[1]), &(data[k+2*datafile->NrBins]), &(datafile->offpulse_rms[2]), &(data[k+3*datafile->NrBins]), &(data[k+4*datafile->NrBins]), &(data[k+5*datafile->NrBins]), &(datafile->offpulse_rms[5]), &(data[k+6*datafile->NrBins]), &(data[k+7*datafile->NrBins]));\n }else {\n   sscanf(txt, \"%ld %lf %f %f %f %f %f %f %f %f\", &dummy_long, &(datafile->tsamp_list[k]), &(data[k]), &(datafile->offpulse_rms[0]), &(data[k+datafile->NrBins]), &(datafile->offpulse_rms[1]), &(data[k+2*datafile->NrBins]), &(datafile->offpulse_rms[2]), &(data[k+3*datafile->NrBins]), &(data[k+4*datafile->NrBins]));\n }\n      }\n      datafile->tsamp_list[k] += add_longitude_shift;\n      if(datafile->tsamp_list[k] >= 0 && datafile->tsamp_list[k] < 360) {\n   k++;\n      }else {\n fflush(stdout);\n printwarning(verbose.debug, \"WARNING readPPOLfile: IGNORING POINTS AT PULSE LONGITUDES outside range 0 ... 360 deg.\");\n      }\n    }\n  }\n  if(k != datafile->NrBins) {\n    fflush(stdout);\n    printerror(verbose.debug, \"WARNING readPPOLfile: The nr of bins read in is different as determined from header. Something is wrong.\");\n    return 0;\n  }\n  fflush(stdout);\n  if(verbose.verbose) fprintf(stdout, \"readPPOLfile: Accepted %ld points\\n\", datafile->NrBins);\n     free(txt);\n  return 1;\n}\nint writePPOLfile(datafile_definition datafile, float *data, int extended, int onlysignificantPA, int twoprofiles, float PAoffset, verbose_definition verbose)\n{\n  long j;\n  if(datafile.poltype != POLTYPE_ILVPAdPA && datafile.poltype != POLTYPE_PAdPA && datafile.poltype != POLTYPE_ILVPAdPATEldEl) {\n    printerror(verbose.debug, \"ERROR writePPOLfile: Data doesn't appear to have poltype ILVPAdPA, PAdPA or ILVPAdPATEldEl (it is %d).\", datafile.poltype);\n    return 0;\n  }\n  if(datafile.poltype == POLTYPE_ILVPAdPA && datafile.NrPols != 5) {\n    printerror(verbose.debug, \"ERROR writePPOLfile: 5 polarization channels were expected, but there are %ld.\", datafile.NrPols);\n    return 0;\n  }else if(datafile.poltype == POLTYPE_PAdPA && datafile.NrPols != 2) {\n    printerror(verbose.debug, \"ERROR writePPOLfile: 2 polarization channels were expected, but there are %ld.\", datafile.NrPols);\n    return 0;\n  }else if(datafile.poltype == POLTYPE_ILVPAdPATEldEl && datafile.NrPols != 8) {\n    printerror(verbose.debug, \"ERROR writePPOLfile: 8 polarization channels were expected, but there are %ld.\", datafile.NrPols);\n    return 0;\n  }\n  if(datafile.NrSubints > 1 || datafile.NrFreqChan > 1) {\n    printerror(verbose.debug, \"ERROR writePPOLfile: Can only do this opperation if there is one subint and one frequency channel.\");\n    return 0;\n  }\n  if(datafile.tsampMode != TSAMPMODE_LONGITUDELIST) {\n    printerror(verbose.debug, \"ERROR writePPOLfile: Expected pulse longitudes to be defined.\");\n    return 0;\n  }\n  int pa_offset, dpa_offset;\n  if(datafile.poltype == POLTYPE_ILVPAdPA || datafile.poltype == POLTYPE_ILVPAdPATEldEl) {\n    pa_offset = 3;\n    dpa_offset = 4;\n  }else if(datafile.poltype == POLTYPE_PAdPA) {\n    pa_offset = 0;\n    dpa_offset = 1;\n  }\n  for(j = 0; j < datafile.NrBins; j++) {\n    if(data[j+dpa_offset*datafile.NrBins] > 0 || onlysignificantPA == 0) {\n      if(extended) {\n fprintf(datafile.fptr, \"%ld %e %e %e %e %e %e %e %e %e\", j, datafile.tsamp_list[j], data[j], datafile.offpulse_rms[0], data[j+datafile.NrBins], datafile.offpulse_rms[1], data[j+2*datafile.NrBins], datafile.offpulse_rms[2], data[j+pa_offset*datafile.NrBins]+PAoffset, data[j+dpa_offset*datafile.NrBins]);\n if(datafile.poltype == POLTYPE_ILVPAdPATEldEl)\n   fprintf(datafile.fptr, \" %e %e %e %e\", data[j+5*datafile.NrBins], datafile.offpulse_rms[5], data[j+6*datafile.NrBins], data[j+7*datafile.NrBins]);\n fprintf(datafile.fptr, \"\\n\");\n      }else {\n fprintf(datafile.fptr, \"%e %e %e\\n\", datafile.tsamp_list[j], data[j+pa_offset*datafile.NrBins]+PAoffset, data[j+dpa_offset*datafile.NrBins]);\n      }\n    }\n  }\n  if(twoprofiles) {\n    for(j = 0; j < datafile.NrBins; j++) {\n      if(data[j+dpa_offset*datafile.NrBins] > 0 || onlysignificantPA == 0) {\n if(extended) {\n   fprintf(datafile.fptr, \"%ld %e %e %e %e %e %e %e %e %e\", j, datafile.tsamp_list[j]+360, data[j], datafile.offpulse_rms[0], data[j+datafile.NrBins], datafile.offpulse_rms[1], data[j+2*datafile.NrBins], datafile.offpulse_rms[2], data[j+pa_offset*datafile.NrBins]+PAoffset, data[j+dpa_offset*datafile.NrBins]);\n   if(datafile.poltype == POLTYPE_ILVPAdPATEldEl)\n     fprintf(datafile.fptr, \" %e %e %e %e\", data[j+5*datafile.NrBins], datafile.offpulse_rms[5], data[j+6*datafile.NrBins], data[j+7*datafile.NrBins]);\n   fprintf(datafile.fptr, \"\\n\");\n }else {\n   fprintf(datafile.fptr, \"%e %e %e\\n\", datafile.tsamp_list[j]+360, data[j]+PAoffset, data[j+dpa_offset*datafile.NrBins]);\n }\n      }\n    }\n  }\n  return 1;\n}\nint make_pa_distribution(datafile_definition datain, datafile_definition *dataout, int nrbins, int normalise, int weighttype, datafile_definition *pamask, float pamask_value, int ellipticity, verbose_definition verbose)\n{\n  long i, j, f, nrpointsadded, nrpointsadded_max, binnr;\n  float dpa;\n  if(datain.NrSubints <= 1 && datain.NrFreqChan <= 1) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR make_pa_distribution: Need more than a single subints and frequency channel to make a PA distribution\");\n    return 0;\n  }\n  if(datain.poltype != POLTYPE_ILVPAdPA && datain.poltype != POLTYPE_PAdPA && datain.poltype != POLTYPE_ILVPAdPATEldEl) {\n    printerror(verbose.debug, \"ERROR make_pa_distribution: Data doesn't appear to have poltype ILVPAdPA, ILVPAdPATEldEl or PAdPA.\");\n    return 0;\n  }\n  if(ellipticity && datain.poltype != POLTYPE_ILVPAdPATEldEl) {\n    printerror(verbose.debug, \"ERROR make_pa_distribution: The data isn't of polarization type ILVPAdPATEldEl, while the ellipticity distribution was requested.\");\n    return 0;\n  }\n  if(datain.poltype == POLTYPE_ILVPAdPA && datain.NrPols != 5) {\n    printerror(verbose.debug, \"ERROR make_pa_distribution: 5 polarization channels were expected, but there are %ld.\", datain.NrPols);\n    return 0;\n  }else if(datain.poltype == POLTYPE_ILVPAdPATEldEl && datain.NrPols != 8) {\n    printerror(verbose.debug, \"ERROR make_pa_distribution: 8 polarization channels were expected, but there are %ld.\", datain.NrPols);\n    return 0;\n  }else if(datain.poltype == POLTYPE_PAdPA && datain.NrPols != 2) {\n    printerror(verbose.debug, \"ERROR make_pa_distribution: 2 polarization channels were expected, but there are %ld.\", datain.NrPols);\n    return 0;\n  }\n  if(pamask != NULL) {\n    if(datain.NrBins != pamask->NrBins) {\n      printerror(verbose.debug, \"ERROR make_pa_distribution: Applying a PA mask only works when the input data has the same number of pulse longitude bins compared to that of the provided mask. (the input data has %ld pulse longitude bins, while the mask has %ld).\", datain.NrBins, pamask->NrBins);\n      return 0;\n    }\n    if(nrbins != pamask->NrSubints) {\n      printerror(verbose.debug, \"ERROR make_pa_distribution: Applying a PA mask only works when generating a PA-distribution with an equal number of PA bins compared to that of the provided mask. (now %ld pa bins are requested, while the mask has %ld pa-bins defined).\", nrbins, pamask->NrSubints);\n      return 0;\n    }\n    if(pamask->NrFreqChan > 1) {\n      printerror(verbose.debug, \"ERROR make_pa_distribution: Applying a PA mask only works when the mask has one frequency channel defined. There are currently %ld channels defined).\", pamask->NrFreqChan);\n      return 0;\n    }\n  }\n  cleanPSRData(dataout, verbose);\n  copy_params_PSRData(datain, dataout, verbose);\n  dataout->format = MEMORY_format;\n  dataout->NrSubints = nrbins;\n  dataout->NrPols = 1;\n  dataout->NrFreqChan = 1;\n  if(ellipticity == 0)\n    dataout->gentype = GENTYPE_PADIST;\n  else\n    dataout->gentype = GENTYPE_ELLDIST;\n  dataout->tsubMode = TSUBMODE_FIXEDTSUB;\n  if(dataout->tsub_list != NULL)\n    free(dataout->tsub_list);\n  dataout->tsub_list = (double *)malloc(sizeof(double));\n  if(dataout->tsub_list == NULL) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR make_pa_distribution: Memory allocation error\");\n    return 0;\n  }\n  dataout->tsub_list[0] = get_tobs(datain, verbose);\n  dataout->yrangeset = 1;\n  if(ellipticity == 0) {\n    dataout->yrange[0] = -90.0+0.5*180.0/(float)(nrbins);\n    dataout->yrange[1] = 90.0-0.5*180.0/(float)(nrbins);\n  }else {\n    dataout->yrange[0] = -45.0+0.5*90.0/(float)(nrbins);\n    dataout->yrange[1] = 45.0-0.5*90.0/(float)(nrbins);\n  }\n  dataout->data = (float *)calloc(dataout->NrSubints*dataout->NrBins*dataout->NrPols*dataout->NrFreqChan, sizeof(float));\n  if(dataout->data == NULL) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR make_pa_distribution: Cannot allocate memory for data.\");\n    return 0;\n  }\n  if(ellipticity == 0) {\n    dpa = 180.0/(float)nrbins;\n  }else {\n    dpa = 90.0/(float)nrbins;\n  }\n  int pa_chan, dpa_chan, weight_chan;\n  if(datain.poltype == POLTYPE_ILVPAdPA || datain.poltype == POLTYPE_ILVPAdPATEldEl) {\n    if(ellipticity == 0) {\n      pa_chan = 3;\n      dpa_chan = 4;\n    }else {\n      pa_chan = 6;\n      dpa_chan = 7;\n    }\n    if(weighttype == 0) {\n      weight_chan = -1;\n    }else if(weighttype == 1) {\n      weight_chan = 1;\n    }else if(weighttype == 2) {\n      weight_chan = 2;\n    }else if(weighttype == 3) {\n      weight_chan = 0;\n    }else if(weighttype == 4) {\n      weight_chan = 5;\n      if(datain.poltype != POLTYPE_ILVPAdPATEldEl) {\n printerror(verbose.debug, \"ERROR make_pa_distribution: Weighting by the total polarization is requested, but that is not appears to be defined in the input data.\");\n return 0;\n      }\n    }else {\n      printerror(verbose.debug, \"ERROR make_pa_distribution: Unsupported weighttype is specified.\");\n      return 0;\n    }\n  }else {\n    pa_chan = 0;\n    dpa_chan = 1;\n    if(weighttype != 0) {\n      printerror(verbose.debug, \"ERROR make_pa_distribution: Data only has PA values defined, so weighting is not supported.\");\n      return 0;\n    }\n  }\n  nrpointsadded_max = 0;\n  for(j = 0; j < datain.NrBins; j++) {\n    nrpointsadded = 0;\n    for(i = 0; i < datain.NrSubints; i++) {\n      for(f = 0; f < datain.NrFreqChan; f++) {\n float paerr;\n paerr = datain.data[j+datain.NrBins*(dpa_chan+datain.NrPols*(f+datain.NrFreqChan*i))];\n if(paerr > 0) {\n   float pa = derotate_180_small_double(datain.data[j+datain.NrBins*(pa_chan+datain.NrPols*(f+datain.NrFreqChan*i))]);\n   float weight = 1.0;\n   if(weighttype != 0) {\n     weight = datain.data[j+datain.NrBins*(weight_chan+datain.NrPols*(f+datain.NrFreqChan*i))];\n     if(weighttype == 2) {\n       weight = fabs(weight);\n     }\n   }\n   if(ellipticity == 0) {\n     if(pa == 90.0)\n       binnr = 0;\n     else\n       binnr = (pa + 90.0)/dpa;\n   }else {\n     if(pa == 45.0)\n       binnr = 0;\n     else\n       binnr = (pa + 45.0)/dpa;\n   }\n   if(binnr < 0 || binnr >= nrbins) {\n     fflush(stdout);\n     printerror(verbose.debug, \"ERROR make_pa_distribution: %ld %f %f BUG!!!!!!!!!!!!!!!\", binnr, datain.data[j+datain.NrBins*(pa_chan+datain.NrPols*(f+datain.NrFreqChan*i))], dpa);\n     return 0;\n   }\n   dataout->data[j+dataout->NrBins*binnr] += weight;\n   nrpointsadded++;\n }\n if(pamask != NULL) {\n   float value;\n   if(paerr <= 0) {\n     value = 0;\n   }else {\n     value = pamask->data[j+pamask->NrBins*(0+pamask->NrPols*(0+pamask->NrFreqChan*binnr))];\n   }\n   if(isnan(pamask_value)) {\n     int curpol;\n     for(curpol = 0; curpol < datain.NrPols; curpol++) {\n       datain.data[j+datain.NrBins*(curpol+datain.NrPols*(f+datain.NrFreqChan*i))] = value;\n     }\n   }else {\n     if(value < pamask_value-0.01 || value > pamask_value+0.01 || paerr <= 0) {\n       int curpol;\n       for(curpol = 0; curpol < datain.NrPols; curpol++) {\n  datain.data[j+datain.NrBins*(curpol+datain.NrPols*(f+datain.NrFreqChan*i))] = 0;\n       }\n     }\n   }\n }\n      }\n    }\n    if(nrpointsadded > nrpointsadded_max)\n      nrpointsadded_max = nrpointsadded;\n  }\n  if(normalise) {\n    if(nrpointsadded_max > 0) {\n      for(i = 0; i < nrbins; i++) {\n for(j = 0; j < datain.NrBins; j++) {\n   dataout->data[j+datain.NrBins*i] /= (float)nrpointsadded_max;\n }\n      }\n    }\n  }\n  return 1;\n}\nint make_polarization_projection_map(datafile_definition datafile, float *map, int nrx, int nry, float background, int binnr, pulselongitude_regions_definition onpulse, int weighting, float threshold, int projection, float rot_long, float rot_lat, float conalselection, datafile_definition *subtract_pa_data, verbose_definition verbose)\n{\n  int ok;\n  long i, xi, yi, pulsenr;\n  float longitude, stokesI, L, P, latitude, x, y, weight;\n  if(projection < 1 || projection > 3) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR make_projection_map_formIQUV: Projection type is not implemented.\");\n    return 0;\n  }\n  if(datafile.NrFreqChan != 1) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR make_projection_map_formIQUV: Expected 1 frequency channel.\");\n    return 0;\n  }\n  if(datafile.poltype == POLTYPE_ILVPAdPATEldEl) {\n    if(datafile.NrPols != 8) {\n      fflush(stdout);\n      printerror(verbose.debug, \"ERROR make_projection_map_formIQUV: Expected 8 input polarizations when reading in data containing PA's and ellipticities.\");\n      return 0;\n    }\n  }else {\n    if(datafile.NrPols != 4) {\n      fflush(stdout);\n      printerror(verbose.debug, \"ERROR make_projection_map_formIQUV: Expected 4 input polarizations.\");\n      return 0;\n    }\n  }\n  if(subtract_pa_data != NULL) {\n    if(subtract_pa_data->NrBins != datafile.NrBins) {\n      printerror(verbose.debug, \"ERROR make_projection_map_formIQUV: The reference PA-swing has a different number of pulse phase bins compared to the input data.\");\n      return 0;\n    }\n    if(subtract_pa_data->NrFreqChan != 1) {\n      fflush(stdout);\n      printerror(verbose.debug, \"ERROR make_projection_map_formIQUV: The reference PA-swing should have a single frequency channel.\");\n      return 0;\n    }\n    if(subtract_pa_data->NrSubints != 1) {\n      fflush(stdout);\n      printerror(verbose.debug, \"ERROR make_projection_map_formIQUV: The reference PA-swing should have a single subint.\");\n      return 0;\n    }\n  }\n  rot_long *= M_PI/180.0;\n  rot_lat *= M_PI/180.0;\n  float *normmap;\n  if(weighting == 2) {\n    normmap = malloc(nrx*nry*sizeof(float));\n    if(normmap == NULL) {\n      printerror(verbose.debug, \"ERROR make_projection_map_formIQUV: Memory allocation error.\");\n      return 0;\n    }\n  }\n  for(xi = 0; xi < nrx; xi++) {\n    for(yi = 0; yi < nry; yi++) {\n      map[xi+nrx*yi] = 0;\n      if(weighting == 2) {\n normmap[xi+nrx*yi] = 0;\n      }\n    }\n  }\n  for(pulsenr = 0; pulsenr < datafile.NrSubints; pulsenr++) {\n    for(i = 0; i < (datafile.NrBins); i++) {\n      ok = 1;\n      if(binnr >= 0) {\n if(i != binnr)\n   ok = 0;\n      }else if(binnr == -1) {\n if(checkRegions(i, &onpulse, 0, verbose) == 0) {\n   ok = 0;\n }\n      }\n      if(ok) {\n if(datafile.poltype == POLTYPE_ILVPAdPATEldEl) {\n   longitude = 2.0*datafile.data[i+datafile.NrBins*datafile.NrPols*pulsenr+3*(datafile.NrBins)]*M_PI/180.0;\n   L = datafile.data[i+datafile.NrBins*datafile.NrPols*pulsenr+1*(datafile.NrBins)];\n   latitude = 2.0*datafile.data[i+datafile.NrBins*datafile.NrPols*pulsenr+6*(datafile.NrBins)]*M_PI/180.0;\n   if(datafile.data[i+datafile.NrBins*datafile.NrPols*pulsenr+4*(datafile.NrBins)] < 0 || datafile.data[i+datafile.NrBins*datafile.NrPols*pulsenr+7*(datafile.NrBins)] < 0) {\n     longitude = latitude = sqrt(-1.0);\n   }\n }else {\n   longitude = atan2(datafile.data[i+datafile.NrBins*datafile.NrPols*pulsenr+2*(datafile.NrBins)],datafile.data[i+datafile.NrBins*datafile.NrPols*pulsenr+(datafile.NrBins)]);\n   L = sqrt(datafile.data[i+datafile.NrBins*datafile.NrPols*pulsenr+2*(datafile.NrBins)]*datafile.data[i+datafile.NrBins*datafile.NrPols*pulsenr+2*(datafile.NrBins)] + datafile.data[i+datafile.NrBins*datafile.NrPols*pulsenr+(datafile.NrBins)]*datafile.data[i+datafile.NrBins*datafile.NrPols*pulsenr+(datafile.NrBins)]);\n   latitude = atan(datafile.data[i+datafile.NrBins*datafile.NrPols*pulsenr+3*(datafile.NrBins)]/L);\n }\n if(subtract_pa_data != NULL) {\n   int pachannel_subtract_fin;\n   if(subtract_pa_data->poltype == POLTYPE_ILVPAdPATEldEl) {\n     pachannel_subtract_fin = 3;\n   }else {\n     pachannel_subtract_fin = subtract_pa_data->NrPols-2;\n   }\n   longitude -= 2.0*subtract_pa_data->data[i+subtract_pa_data->NrBins*(pachannel_subtract_fin)]*M_PI/180.0;\n }\n if(!isnan(latitude)) {\n   if(conalselection > 0) {\n     double sphericaldistance;\n     sphericaldistance = acos(cos(latitude-rot_lat)*cos(longitude+rot_long))*180.0/M_PI;\n     if(sphericaldistance > conalselection) {\n       latitude = sqrt(-1.0);\n     }\n   }\n }\n if(!isnan(latitude)) {\n   if(weighting) {\n     if(weighting != 3) {\n       if(datafile.poltype == POLTYPE_ILVPAdPATEldEl) {\n  P = datafile.data[i+datafile.NrBins*datafile.NrPols*pulsenr+5*(datafile.NrBins)];\n       }else {\n  P = sqrt(L*L+datafile.data[i+datafile.NrBins*datafile.NrPols*pulsenr+3*(datafile.NrBins)]*datafile.data[i+datafile.NrBins*datafile.NrPols*pulsenr+3*(datafile.NrBins)]);\n       }\n     }\n     if(weighting == 2 || weighting == 3) {\n       stokesI = datafile.data[i+datafile.NrBins*datafile.NrPols*pulsenr];\n     }\n   }\n   if(projection == 1) {\n     projectionHammerAitoff_xy(longitude, latitude, rot_long, rot_lat, &x, &y);\n     weight = 1;\n   }else if(projection == 2) {\n     projection_sphere_xy(longitude, latitude, rot_long, rot_lat, &x, &y, &weight);\n   }else if(projection == 3) {\n     projection_longlat_xy(longitude, latitude, rot_long, rot_lat, &x, &y);\n     weight = 1;\n     x /= 80.0;\n     y /= 80.0;\n   }\n   xi = 0.5*nrx + x*nrx/4.5;\n   yi = 0.5*nry + y*nry/2.25;\n   if(weighting == 0) {\n     map[xi+nrx*yi] += 1.0*weight;\n   }else {\n     if(weighting == 3) {\n       map[xi+nrx*yi] += stokesI*weight;\n     }else {\n       map[xi+nrx*yi] += P*weight;\n     }\n     if(weighting == 2) {\n       normmap[xi+nrx*yi] += stokesI*weight;\n     }\n   }\n }\n      }\n    }\n  }\n  if((weighting == 1 || weighting == 2) && threshold > 0) {\n    float maxvalue = map[0];\n    for(xi = 0; xi < nrx; xi++) {\n      for(yi = 0; yi < nry; yi++) {\n if(map[xi+nrx*yi] > maxvalue) {\n   maxvalue = map[xi+nrx*yi];\n }\n      }\n    }\n    for(xi = 0; xi < nrx; xi++) {\n      for(yi = 0; yi < nry; yi++) {\n if(map[xi+nrx*yi] < threshold*maxvalue) {\n   map[xi+nrx*yi] = 0;\n }\n      }\n    }\n  }\n  if(weighting == 2) {\n    for(xi = 0; xi < nrx; xi++) {\n      for(yi = 0; yi < nry; yi++) {\n if(normmap[xi+nrx*yi] != 0.0) {\n   map[xi+nrx*yi] /= normmap[xi+nrx*yi];\n   if(map[xi+nrx*yi] < 0) {\n     map[xi+nrx*yi] = 0;\n   }\n   if(map[xi+nrx*yi] > 1) {\n     map[xi+nrx*yi] = 1;\n   }\n }else {\n   map[xi+nrx*yi] = 0;\n }\n      }\n    }\n    free(normmap);\n  }\n  return 1;\n}\n", "meta": {"hexsha": "a1cb26e03ae91facc7a33aad8b259c1335cd1f83", "size": 59286, "ext": "c", "lang": "C", "max_stars_repo_path": "src/lib/psrio_paswing.c", "max_stars_repo_name": "weltevrede/psrsalsa", "max_stars_repo_head_hexsha": "4c5b1b32513174ec1f6929905e67c8b9ca44e008", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 5.0, "max_stars_repo_stars_event_min_datetime": "2017-09-05T23:22:13.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-11T14:12:18.000Z", "max_issues_repo_path": "src/lib/psrio_paswing.c", "max_issues_repo_name": "weltevrede/psrsalsa", "max_issues_repo_head_hexsha": "4c5b1b32513174ec1f6929905e67c8b9ca44e008", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2018-04-26T13:35:30.000Z", "max_issues_repo_issues_event_max_datetime": "2020-01-20T08:49:57.000Z", "max_forks_repo_path": "src/lib/psrio_paswing.c", "max_forks_repo_name": "weltevrede/psrsalsa", "max_forks_repo_head_hexsha": "4c5b1b32513174ec1f6929905e67c8b9ca44e008", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2018-04-09T09:04:46.000Z", "max_forks_repo_forks_event_max_datetime": "2020-06-16T15:24:07.000Z", "avg_line_length": 41.8390966831, "max_line_length": 755, "alphanum_fraction": 0.6713558007, "num_tokens": 18613, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.26894142136999516, "lm_q2_score": 0.024053554993252985, "lm_q1q2_score": 0.006468997268886802}}
{"text": "// Copyright (c) 2015-2016, Massachusetts Institute of Technology\n// Copyright (c) 2016-2017 Sandia Corporation\n// Copyright (c) 2017 NTESS, LLC.\n\n// This file is part of the Compressed Continuous Computation (C3) Library\n// Author: Alex A. Gorodetsky \n// Contact: alex@alexgorodetsky.com\n\n// All rights reserved.\n\n// Redistribution and use in source and binary forms, with or without modification, \n// are permitted provided that the following conditions are met:\n\n// 1. Redistributions of source code must retain the above copyright notice, \n//    this list of conditions and the following disclaimer.\n\n// 2. Redistributions in binary form must reproduce the above copyright notice, \n//    this list of conditions and the following disclaimer in the documentation \n//    and/or other materials provided with the distribution.\n\n// 3. Neither the name of the copyright holder nor the names of its contributors \n//    may be used to endorse or promote products derived from this software \n//    without specific prior written permission.\n\n// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" \n// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE \n// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE \n// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE \n// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL \n// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR \n// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER \n// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, \n// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE \n// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n//Code\n\n\n#ifndef LINALG_H\n#define LINALG_H\n\n#ifdef __APPLE__\n    #include <Accelerate/Accelerate.h>\n    /* #include \"/System/Library/Frameworks/Accelerate.framework/Versions/Current/Frameworks/vecLib.framework/Headers/clapack.h\" */\n\n    #define dgetri_(X, Y, Z, A , B, C, D ) \\\n            ( dgetri_( (__CLPK_integer *) X, Y, (__CLPK_integer *) Z, (__CLPK_integer *) A, \\\n                        B, (__CLPK_integer *)C , (__CLPK_integer *) D) )\n    #define dgetrf_(X, Y, Z, A ,B, C ) \\\n            ( dgetrf_( (__CLPK_integer *) X,(__CLPK_integer *) Y, Z, (__CLPK_integer *) A, \\\n                       (__CLPK_integer *) B, (__CLPK_integer *)C ))\n    #define dorgqr_(X,Y,Z,A,B,C,D,E,F) \\\n            ( dorgqr_( (__CLPK_integer *) X, (__CLPK_integer *) Y, (__CLPK_integer *) Z, A, \\\n                       (__CLPK_integer *) B, C , D, (__CLPK_integer *) E, (__CLPK_integer *)F) )\n    #define dgeqrf_(X, Y, Z, A , B, C, D, E ) \\\n            ( dgeqrf_( (__CLPK_integer *) X,  (__CLPK_integer *)Y, Z, (__CLPK_integer *) A, \\\n                        B, C, (__CLPK_integer *) D, (__CLPK_integer *) E) )\n\n    #define dorgrq_(X,Y,Z,A,B,C,D,E,F) \\\n            ( dorgrq_( (__CLPK_integer *) X, (__CLPK_integer *) Y, (__CLPK_integer *) Z, A, \\\n                       (__CLPK_integer *) B, C , D, (__CLPK_integer *) E, (__CLPK_integer *)F) )\n    #define dgerqf_(X, Y, Z, A , B, C, D, E ) \\\n            ( dgerqf_( (__CLPK_integer *) X,  (__CLPK_integer *)Y, Z, (__CLPK_integer *) A, \\\n                        B, C, (__CLPK_integer *) D, (__CLPK_integer *) E) )\n\n    #define dgesdd_(X,Y,Z,A,B,C,D,E,F,G,H,I,J,K) \\\n            ( dgesdd_(X, (__CLPK_integer *)Y, (__CLPK_integer *)Z, A, (__CLPK_integer *) B,\\\n                C,D,(__CLPK_integer *) E, F, (__CLPK_integer *) G, H, (__CLPK_integer *) I,\\\n                (__CLPK_integer *) J, (__CLPK_integer *) K ) )\n\n    #define dgebal_(X, Y, Z, A , B, C, D, E ) \\\n            ( dgebal_( X,  (__CLPK_integer *)Y, Z, (__CLPK_integer *) A, \\\n                   (__CLPK_integer *) B, (__CLPK_integer *)C, D, (__CLPK_integer *) E) )\n\n    #define dpotrf_(X,Y,Z,A,B) \\\n            ( dpotrf_(X, (__CLPK_integer *)Y, Z, (__CLPK_integer *) A, (__CLPK_integer *) B ))\n\n    #define dpotri_(X,Y,Z,A,B) \\\n            ( dpotri_(X, (__CLPK_integer *)Y, Z, (__CLPK_integer *) A, (__CLPK_integer *) B ))\n\n    #define dtrtri_(X,Y,Z,A,B,C) \\\n            ( dtrtri_(X,Y, (__CLPK_integer *)Z, A, (__CLPK_integer *) B, (__CLPK_integer *) C ))\n\n    #define dgesv_(X,Y,Z,A,B,C,D,E) \\\n            ( dgesv_((__CLPK_integer *)X, (__CLPK_integer *)Y, Z, (__CLPK_integer *) A, (__CLPK_integer *) B, \\\n                C, (__CLPK_integer *) D, (__CLPK_integer *) E))\n\n    #define dhseqr_(X, Y, Z, A , B, C, D, E,F,G,H,I,J,K ) \\\n            ( dhseqr_( X, Y, (__CLPK_integer *)Z, (__CLPK_integer *)A, \\\n                   (__CLPK_integer *) B, C, (__CLPK_integer *)D, E, F, G, (__CLPK_integer *) H, \\\n                   I, (__CLPK_integer *) J, (__CLPK_integer *)K ) )\n\n    #define dsyev_(A,B,C,D,E,F,G,H,J) \\\n        ( dsyev_(A,B,(__CLPK_integer *) C,D,(__CLPK_integer *) E,F, \\\n            G, (__CLPK_integer *) H, (__CLPK_integer *) J) )\n\n    #define dgeev_(X, Y, Z, A , B, C, D, E,F,G,H,I,J,K ) \\\n            ( dgeev_( X, Y, (__CLPK_integer *)Z, A, \\\n                   (__CLPK_integer *) B, C, D, E, (__CLPK_integer *) F, G, (__CLPK_integer *) H, \\\n                   I, (__CLPK_integer *) J, (__CLPK_integer *)K ) )\n\n    #define dstegr_(X,Y,Z,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q) \\\n            ( dstegr_(X,Y,(__CLPK_integer *)Z,A,B,C,D,\\\n                   (__CLPK_integer *)E,(__CLPK_integer *)F,G,(__CLPK_integer *)H, \\\n                   I,J,(__CLPK_integer *)K,(__CLPK_integer *)L,M,(__CLPK_integer *)N, \\\n                   (__CLPK_integer *)O,(__CLPK_integer *)P,(__CLPK_integer *)Q))\n\n    #define dgelsd_(X,Y,Z,A,B,C,D,E,F,G,H,I,J,K)                         \\\n            ( dgelsd_( (__CLPK_integer *)X, (__CLPK_integer *)Y, (__CLPK_integer *)Z, \\\n                       (__CLPK_doublereal *)A, (__CLPK_integer *)B, (__CLPK_doublereal *)C,  \\\n                       (__CLPK_integer *)D, (__CLPK_doublereal *) E, \\\n\t                   (__CLPK_doublereal *)F, (__CLPK_integer *)G, (__CLPK_doublereal *)H, \\\n                       (__CLPK_integer *)I, (__CLPK_integer *)J, (__CLPK_integer *)K)) \n#else\n    /* #include <gsl/gsl_cblas.h> */\n    #include <cblas.h>\n\nvoid dgetri_(int * X, double *Y, int * Z, int * A, double *B, int *C , int * D);\nvoid dgetrf_(int * X,int * Y, double*Z, int * A, int * B, int *C );\nvoid dorgqr_(int * X, int * Y, int * Z, double *A,int * B, double *C , double *D, int * E, int *F);\nvoid dgeqrf_(int *X, int *Y, double *Z, int * A, double * B, double * C, int * D, int * E);\nvoid dgeev_(char * X, char *Y, int * Z, double *A, int * B, double * C, double *D, double *E,\n            int * F, double *G, int * H, double *, int *, int *K);\nvoid dgebal_(char *X,  int *Y, double *Z, int * A, int * B, int *C, double *D, int * E);\nvoid dhseqr_(char *X, char *Y, int *Z, int *A,int * B, double *C, int *D,\n             double *E, double *F, double *G, int * H, double *, int *, int *K );\nvoid dorgrq_(int * X, int * Y, int * Z, double *A,int * B, double *C , double *D, int * E, int *F);\nvoid dgerqf_(int * X,  int *Y, double *Z, int * A, double *B, double *C, int * D, int * E);\nvoid dgesdd_(char *X, int * Y, int *Z, double *A, int * B,double * C,double * D,\n             int * E,double * F, int * G, double *H, int *, int *, int * K );\nvoid dstev_(char *X,  int *Y, double *Z, double *A, double *B, int *C, double *D, int * E);\nvoid dsyev_(char *A,char *B,int * C,double *D,int * E,double *F, double *G, int* H, int * J);\nvoid dpotrf_(char *X, int*Y, double *Z, int * A, int * B );\nvoid dpotri_(char *X, int*Y, double *Z, int * A, int* B);\nvoid dtrtri_(char *X,char*Y, int *Z, double *A, int * B, int * C);\nvoid dgesv_(int *X, int *Y, double*Z, int * A, int * B,double*C, int * D, int * E);\nvoid dgelsd_(int *X, int *Y, int *Z, double *A, int *B, double *C, \n             int *D, double * E, double *F, int *G, double *H, int *,int *, int *K);\n\n#endif\n\n#include \"matrix_util.h\"\n\nvoid c3linalg_multiple_vec_mat(size_t, size_t, size_t, const double *, size_t,\n                               const double *, size_t, double *,size_t);\nvoid c3linalg_multiple_mat_vec(size_t, size_t, size_t, const double *, size_t,\n                               const double *, size_t, double *,size_t);\nint qr(size_t, size_t, double *, size_t);\nvoid rq_with_rmult(size_t, size_t, double *, size_t, size_t, size_t, double *, size_t);\nvoid svd(size_t, size_t, size_t, double *, double *, double *, double *);\nsize_t truncated_svd(size_t, size_t, size_t, double *, double **, double **, double **, double);\nsize_t pinv(size_t, size_t, size_t, double *, double *, double);\n\ndouble norm2(double *, int);\ndouble norm2diff(double *, double *, int);\ndouble mean(double *, size_t);\ndouble mean_size_t(size_t *, size_t);\n\nstruct mat * kron(const struct mat *, const struct mat *);\nvoid kron_col(int, int, double *, int, int, int, double *, int, double *, int);\nvoid vec_kron(size_t, size_t, double *, size_t, size_t, size_t, \n        double *, size_t, double *, double, double *);\nvoid vec_kronl(size_t, size_t, double *, size_t, size_t, size_t, \n        double *, size_t, long double *, double, long double *);\n\n// decompositions\nstruct fiber_list{\n    size_t index;\n    double * vals;\n    struct fiber_list * next;\n};\nstruct fiber_info{\n    size_t nfibers;\n    struct fiber_list * head;\n};\nvoid AddFiber(struct fiber_list **, size_t, double *, size_t);\nint IndexExists(struct fiber_list *, size_t);\ndouble * getIndex(struct fiber_list *, size_t);\nvoid DeleteFiberList(struct fiber_list **);\n\nstruct sk_decomp {\n    size_t n;\n    size_t m;\n    size_t rank;\n    size_t * rows_kept;\n    size_t * cols_kept;\n    size_t cross_rank;\n    double * cross_inv;\n    struct fiber_info * row_vals;\n    struct fiber_info * col_vals;\n    int success;\n};\n\nvoid init_skf(struct sk_decomp **, size_t, size_t, size_t);\nvoid sk_decomp_to_full(struct sk_decomp *, double *);\nvoid free_skf(struct sk_decomp **);\n\n/* int comp_pivots(const double *, int, int, int *); */\nint maxvol_rhs(const double *, size_t, size_t, size_t *, double *); //\nint skeleton(double *, size_t, size_t, size_t, size_t *, size_t *, double);\nint skeleton_func(double (*A)(int,int, int, void*), void *, size_t, \n                size_t, size_t, size_t *, size_t *, double);\nint\nskeleton_func2(int (*Ap)(double *, double, size_t, size_t, double *,\n                void *),\n                   void *, struct sk_decomp **,  double *, double *, \n                   double);\nvoid linear_ls(size_t, size_t, double *, double *, double *);\n#endif\n", "meta": {"hexsha": "d5ad0581e6007f648dd0837c56e6ad60f97f8ae9", "size": 10527, "ext": "h", "lang": "C", "max_stars_repo_path": "c3/lib_linalg/linalg.h", "max_stars_repo_name": "goroda/Compressed-Continuous-Computation", "max_stars_repo_head_hexsha": "ecfa401306457b9476c0252dc9cc086ec3fdacfb", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 45.0, "max_stars_repo_stars_event_min_datetime": "2017-03-01T18:53:31.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-12T21:08:03.000Z", "max_issues_repo_path": "c3/lib_linalg/linalg.h", "max_issues_repo_name": "goroda/Compressed-Continuous-Computation", "max_issues_repo_head_hexsha": "ecfa401306457b9476c0252dc9cc086ec3fdacfb", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 10.0, "max_issues_repo_issues_event_min_datetime": "2015-12-18T15:50:09.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-22T23:49:15.000Z", "max_forks_repo_path": "c3/lib_linalg/linalg.h", "max_forks_repo_name": "goroda/Compressed-Continuous-Computation", "max_forks_repo_head_hexsha": "ecfa401306457b9476c0252dc9cc086ec3fdacfb", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 10.0, "max_forks_repo_forks_event_min_datetime": "2016-09-18T19:46:27.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-24T01:58:02.000Z", "avg_line_length": 50.1285714286, "max_line_length": 131, "alphanum_fraction": 0.6057756246, "num_tokens": 3189, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.2628418258225589, "lm_q2_score": 0.0236894701793002, "lm_q1q2_score": 0.006226583594696326}}
{"text": "#include <config.h>\n#include <gsl/gsl_math.h>\n#include <gsl/gsl_errno.h>\n#include <gsl/gsl_sum.h>\n\ngsl_sum_levin_u_workspace * \ngsl_sum_levin_u_alloc (size_t n)\n{\n  gsl_sum_levin_u_workspace * w;\n\n  if (n == 0)\n    {\n      GSL_ERROR_VAL (\"length n must be positive integer\", GSL_EDOM, 0);\n    }\n\n  w = (gsl_sum_levin_u_workspace *) malloc(sizeof(gsl_sum_levin_u_workspace));\n\n  if (w == NULL)\n    {\n      GSL_ERROR_VAL (\"failed to allocate struct\", GSL_ENOMEM, 0);\n    }\n\n  w->q_num = (double *) malloc (n * sizeof (double));\n\n  if (w->q_num == NULL)\n    {\n      free(w) ; /* error in constructor, prevent memory leak */\n\n      GSL_ERROR_VAL (\"failed to allocate space for q_num\", GSL_ENOMEM, 0);\n    }\n\n  w->q_den = (double *) malloc (n * sizeof (double));\n\n  if (w->q_den == NULL)\n    {\n      free (w->q_num);\n      free (w) ; /* error in constructor, prevent memory leak */\n\n      GSL_ERROR_VAL (\"failed to allocate space for q_den\", GSL_ENOMEM, 0);\n    }\n\n  w->dq_num = (double *) malloc (n * n * sizeof (double));\n\n  if (w->dq_num == NULL)\n    {\n      free (w->q_den);\n      free (w->q_num);\n      free(w) ; /* error in constructor, prevent memory leak */\n\n      GSL_ERROR_VAL (\"failed to allocate space for dq_num\", GSL_ENOMEM, 0);\n    }\n\n  w->dq_den = (double *) malloc (n * n * sizeof (double));\n\n  if (w->dq_den == NULL)\n    {\n      free (w->dq_num);\n      free (w->q_den);\n      free (w->q_num);\n      free (w) ; /* error in constructor, prevent memory leak */\n\n      GSL_ERROR_VAL (\"failed to allocate space for dq_den\", GSL_ENOMEM, 0);\n    }\n\n  w->dsum = (double *) malloc (n * sizeof (double));\n\n  if (w->dsum == NULL)\n    {\n      free (w->dq_den);\n      free (w->dq_num);\n      free (w->q_den);\n      free (w->q_num);\n      free (w) ; /* error in constructor, prevent memory leak */\n\n      GSL_ERROR_VAL (\"failed to allocate space for dsum\", GSL_ENOMEM, 0);\n    }\n\n  w->size = n;\n  w->terms_used = 0;\n  w->sum_plain = 0;\n\n  return w;\n}\n\nvoid\ngsl_sum_levin_u_free (gsl_sum_levin_u_workspace * w)\n{\n  free (w->dsum);\n  free (w->dq_den);\n  free (w->dq_num);\n  free (w->q_den);\n  free (w->q_num);\n  free (w);\n}\n", "meta": {"hexsha": "3f7052b30d2294b6c6c849b04616239aa9e24ca7", "size": 2121, "ext": "c", "lang": "C", "max_stars_repo_path": "pkgs/libs/gsl/src/sum/work_u.c", "max_stars_repo_name": "manggoguy/parsec-modified", "max_stars_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 64.0, "max_stars_repo_stars_event_min_datetime": "2015-03-06T00:30:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T13:26:53.000Z", "max_issues_repo_path": "pkgs/libs/gsl/src/sum/work_u.c", "max_issues_repo_name": "manggoguy/parsec-modified", "max_issues_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2020-12-15T08:30:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-13T03:54:24.000Z", "max_forks_repo_path": "pkgs/libs/gsl/src/sum/work_u.c", "max_forks_repo_name": "manggoguy/parsec-modified", "max_forks_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 40.0, "max_forks_repo_forks_event_min_datetime": "2015-02-26T15:31:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T23:23:37.000Z", "avg_line_length": 22.3263157895, "max_line_length": 78, "alphanum_fraction": 0.5893446488, "num_tokens": 661, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.30404167496654744, "lm_q2_score": 0.019719129079494028, "lm_q1q2_score": 0.005995437034210917}}
{"text": "#ifndef PROTO_H_\n#define PROTO_H_\n\n#define _DEFAULT_SOURCE 1\n\n/** PROTO SETTINGS **/\n#define PRECISION 2\n#define MAX_LINE_LENGTH 9046\n#define USE_CBLAS\n#define USE_LAPACK\n/* #define USE_CERES */\n#define USE_STB_IMAGE\n\n#define WARN_UNUSED __attribute__((warn_unused_result))\n\n#include <stdio.h>\n#include <stdlib.h>\n#include <stdint.h>\n#include <string.h>\n#include <math.h>\n#include <time.h>\n#include <unistd.h>\n#include <dirent.h>\n#include <assert.h>\n#include <sys/time.h>\n\n#include <errno.h>\n#include <netdb.h>\n#include <netinet/in.h>\n#include <arpa/inet.h>\n#include <sys/types.h>\n#include <sys/socket.h>\n#include <sys/poll.h>\n\n#ifdef USE_CBLAS\n#include <cblas.h>\n#endif\n\n#ifdef USE_LAPACK\n#include <lapacke.h>\n#endif\n\n#ifdef USE_CERES\n#include <ceres/c_api.h>\n#endif\n\n/******************************************************************************\n * MACROS\n ******************************************************************************/\n\n/**\n * Mark variable unused.\n * @param[in] expr Variable to mark as unused\n */\n#define UNUSED(expr)                                                           \\\n  do {                                                                         \\\n    (void) (expr);                                                             \\\n  } while (0)\n\n/**\n * Check if condition is satisfied.\n *\n * If the condition is not satisfied a message M will be logged and a goto\n * error is called.\n *\n * @param[in] A Condition to be checked\n * @param[in] M Error message\n * @param[in] ... Varadic arguments for error message\n */\n#define CHECK(A, M, ...)                                                       \\\n  if (!(A)) {                                                                  \\\n    LOG_ERROR(M, ##__VA_ARGS__);                                               \\\n    goto error;                                                                \\\n  }\n\n/******************************************************************************\n * LOGGING\n ******************************************************************************/\n\n/** Terminal ANSI colors */\n#define KRED \"\\x1B[1;31m\"\n#define KGRN \"\\x1B[1;32m\"\n#define KYEL \"\\x1B[1;33m\"\n#define KBLU \"\\x1B[1;34m\"\n#define KMAG \"\\x1B[1;35m\"\n#define KCYN \"\\x1B[1;36m\"\n#define KWHT \"\\x1B[1;37m\"\n#define KNRM \"\\x1B[1;0m\"\n\n/** Macro function that returns the caller's filename */\n#define __FILENAME__                                                           \\\n  (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)\n\n/**\n * Debug\n * @param[in] M Message\n * @param[in] ... Varadic arguments\n */\n#ifdef NDEBUG\n#define DEBUG(M, ...)\n#else\n#define DEBUG(M, ...) fprintf(stdout, \"[DEBUG] \" M \"\\n\", ##__VA_ARGS__)\n#endif\n\n/**\n * Log info\n * @param[in] M Message\n * @param[in] ... Varadic arguments\n */\n#define LOG_INFO(M, ...)                                                       \\\n  fprintf(stderr,                                                              \\\n          \"[INFO] [%s:%d] \" M \"\\n\",                                            \\\n          __FILENAME__,                                                        \\\n          __LINE__,                                                            \\\n          ##__VA_ARGS__)\n\n/**\n * Log error\n * @param[in] M Message\n * @param[in] ... Varadic arguments\n */\n#define LOG_ERROR(M, ...)                                                      \\\n  fprintf(stderr,                                                              \\\n          KRED \"[ERROR] [%s:%d] \" M KNRM \"\\n\",                                 \\\n          __FILENAME__,                                                        \\\n          __LINE__,                                                            \\\n          ##__VA_ARGS__)\n\n/**\n * Log warn\n * @param[in] M Message\n * @param[in] ... Varadic arguments\n */\n#define LOG_WARN(M, ...)                                                       \\\n  fprintf(stderr,                                                              \\\n          KYEL \"[WARN] [%s:%d] \" M KNRM \"\\n\",                                  \\\n          __FILENAME__,                                                        \\\n          __LINE__,                                                            \\\n          ##__VA_ARGS__)\n\n/**\n * Fatal\n *\n * @param[in] M Message\n * @param[in] ... Varadic arguments\n */\n#define FATAL(M, ...)                                                          \\\n  fprintf(stdout,                                                              \\\n          KRED \"[FATAL] [%s:%d] \" M KNRM \"\\n\",                                 \\\n          __FILENAME__,                                                        \\\n          __LINE__,                                                            \\\n          ##__VA_ARGS__);                                                      \\\n  exit(-1)\n\n/******************************************************************************\n * FILESYSTEM\n ******************************************************************************/\n\nvoid path_file_name(const char *path, char *fname);\nvoid path_file_ext(const char *path, char *fext);\nvoid path_dir_name(const char *path, char *dir_name);\nchar *path_join(const char *x, const char *y);\nchar **list_files(const char *path, int *nb_files);\nvoid list_files_free(char **data, const int n);\nchar *file_read(const char *fp);\nvoid skip_line(FILE *fp);\nint file_exists(const char *fp);\nint file_rows(const char *fp);\nint file_copy(const char *src, const char *dest);\n\n/******************************************************************************\n * DATA\n ******************************************************************************/\n\n#if PRECISION == 1\ntypedef float real_t;\n#elif PRECISION == 2\ntypedef double real_t;\n#else\n#error \"Precision not defined!\"\n#endif\n\nsize_t string_copy(char *dst, const char *src);\nvoid string_cat(char *dst, const char *src);\nchar *string_malloc(const char *s);\nint **load_iarrays(const char *csv_path, int *nb_arrays);\nreal_t **load_darrays(const char *csv_path, int *nb_arrays);\n\nint dsv_rows(const char *fp);\nint dsv_cols(const char *fp, const char delim);\nchar **dsv_fields(const char *fp, const char delim, int *nb_fields);\nreal_t **dsv_data(const char *fp, const char delim, int *nb_rows, int *nb_cols);\nvoid dsv_free(real_t **data, const int nb_rows);\n\nreal_t **csv_data(const char *fp, int *nb_rows, int *nb_cols);\nvoid csv_free(real_t **data, const int nb_rows);\n\n/* real_t *load_matrix(const char *file_path); */\n/* real_t *load_vector(const char *file_path); */\n\n/******************************************************************************\n * TIME\n ******************************************************************************/\n\n/** Timestamp Type */\ntypedef uint64_t timestamp_t;\n\nstruct timespec tic();\nfloat toc(struct timespec *tic);\nfloat mtoc(struct timespec *tic);\ntimestamp_t time_now();\n\nreal_t ts2sec(const timestamp_t ts);\ntimestamp_t sec2ts(const real_t time_s);\n\n/******************************************************************************\n * NETWORK\n ******************************************************************************/\n\n/**\n * TCP server\n */\ntypedef struct tcp_server_t {\n  int port;\n  int sockfd;\n  int conn;\n  void *(*conn_handler)(void *);\n} tcp_server_t;\n\n/**\n * TCP client\n */\ntypedef struct tcp_client_t {\n  char server_ip[1024];\n  int server_port;\n  int sockfd;\n  int (*loop_cb)(struct tcp_client_t *);\n} tcp_client_t;\n\nint ip_port_info(const int sockfd, char *ip, int *port);\n\nint tcp_server_setup(tcp_server_t *server, const int port);\nint tcp_server_loop(tcp_server_t *server);\n\nint tcp_client_setup(tcp_client_t *client,\n                     const char *server_ip,\n                     const int server_port);\nint tcp_client_loop(tcp_client_t *client);\n\n/******************************************************************************\n * MATHS\n ******************************************************************************/\n\n/** Mathematical Pi constant (i.e. 3.1415..) */\n#ifndef M_PI\n#define M_PI (3.14159265358979323846)\n#endif\n\n/** Real number comparison tolerance */\n#ifndef CMP_TOL\n#define CMP_TOL 1e-6\n#endif\n\n/** Min of two numbers, X or Y. */\n#define MIN(x, y) ((x) < (y) ? (x) : (y))\n\n/** Max of two numbers, X or Y. */\n#define MAX(x, y) ((x) > (y) ? (x) : (y))\n\n/** Based on sign of b, return +ve or -ve a. */\n#define SIGN2(a, b) ((b) >= 0.0 ? fabs(a) : -fabs(a))\n\nfloat randf(float a, float b);\nreal_t deg2rad(const real_t d);\nreal_t rad2deg(const real_t r);\nint fltcmp(const real_t x, const real_t y);\nint fltcmp2(const void *x, const void *y);\nreal_t pythag(const real_t a, const real_t b);\nreal_t lerp(const real_t a, const real_t b, const real_t t);\nvoid lerp3(const real_t a[3], const real_t b[3], const real_t t, real_t x[3]);\nreal_t sinc(const real_t x);\nreal_t mean(const real_t *x, const size_t length);\nreal_t median(const real_t *x, const size_t length);\nreal_t var(const real_t *x, const size_t length);\nreal_t stddev(const real_t *x, const size_t length);\n\n/******************************************************************************\n * LINEAR ALGEBRA\n ******************************************************************************/\n\nvoid print_matrix(const char *prefix,\n                  const real_t *A,\n                  const size_t m,\n                  const size_t n);\nvoid print_vector(const char *prefix, const real_t *v, const size_t n);\n\nvoid eye(real_t *A, const size_t m, const size_t n);\nvoid ones(real_t *A, const size_t m, const size_t n);\nvoid zeros(real_t *A, const size_t m, const size_t n);\n\nreal_t *mat_malloc(const size_t m, const size_t n);\nint mat_cmp(const real_t *A, const real_t *B, const size_t m, const size_t n);\nint mat_equals(const real_t *A,\n               const real_t *B,\n               const size_t m,\n               const size_t n,\n               const real_t tol);\nint mat_save(const char *save_path, const real_t *A, const int m, const int n);\nreal_t *mat_load(const char *save_path, int *nb_rows, int *nb_cols);\nvoid mat_set(real_t *A,\n             const size_t stride,\n             const size_t i,\n             const size_t j,\n             const real_t val);\nreal_t\nmat_val(const real_t *A, const size_t stride, const size_t i, const size_t j);\nvoid mat_copy(const real_t *src, const int m, const int n, real_t *dest);\nvoid mat_row_set(real_t *A,\n                 const size_t stride,\n                 const int row_idx,\n                 const real_t *x);\nvoid mat_col_set(real_t *A,\n                 const size_t stride,\n                 const int nb_rows,\n                 const int col_idx,\n                 const real_t *x);\nvoid mat_block_get(const real_t *A,\n                   const size_t stride,\n                   const size_t rs,\n                   const size_t cs,\n                   const size_t re,\n                   const size_t ce,\n                   real_t *block);\nvoid mat_block_set(real_t *A,\n                   const size_t stride,\n                   const size_t rs,\n                   const size_t cs,\n                   const size_t re,\n                   const size_t ce,\n                   const real_t *block);\nvoid mat_diag_get(const real_t *A, const int m, const int n, real_t *d);\nvoid mat_diag_set(real_t *A, const int m, const int n, const real_t *d);\nvoid mat_triu(const real_t *A, const size_t n, real_t *U);\nvoid mat_tril(const real_t *A, const size_t n, real_t *L);\nreal_t mat_trace(const real_t *A, const size_t m, const size_t n);\nvoid mat_transpose(const real_t *A, size_t m, size_t n, real_t *A_t);\nvoid mat_add(const real_t *A, const real_t *B, real_t *C, size_t m, size_t n);\nvoid mat_sub(const real_t *A, const real_t *B, real_t *C, size_t m, size_t n);\nvoid mat_scale(real_t *A, const size_t m, const size_t n, const real_t scale);\n\nreal_t *vec_malloc(const size_t n);\nvoid vec_copy(const real_t *src, const size_t n, real_t *dest);\nint vec_equals(const real_t *x, const real_t *y, const size_t n);\nvoid vec_add(const real_t *x, const real_t *y, real_t *z, size_t n);\nvoid vec_sub(const real_t *x, const real_t *y, real_t *z, size_t n);\nvoid vec_scale(real_t *x, const size_t n, const real_t scale);\nreal_t vec_norm(const real_t *x, const size_t n);\nvoid vec_normalize(real_t *x, const size_t n);\n\nvoid dot(const real_t *A,\n         const size_t A_m,\n         const size_t A_n,\n         const real_t *B,\n         const size_t B_m,\n         const size_t B_n,\n         real_t *C);\nvoid skew(const real_t x[3], real_t A[3 * 3]);\nvoid skew_inv(const real_t A[3 * 3], real_t x[3]);\nvoid fwdsubs(const real_t *L, const real_t *b, real_t *y, const size_t n);\nvoid bwdsubs(const real_t *U, const real_t *y, real_t *x, const size_t n);\nint check_jacobian(const char *jac_name,\n                   const real_t *fdiff,\n                   const real_t *jac,\n                   const size_t m,\n                   const size_t n,\n                   const real_t tol,\n                   const int verbose);\n\n#ifdef USE_CBLAS\nvoid cblas_dot(const real_t *A,\n               const size_t A_m,\n               const size_t A_n,\n               const real_t *B,\n               const size_t B_m,\n               const size_t B_n,\n               real_t *C);\n#endif\n\n/******************************************************************************\n * SVD\n ******************************************************************************/\n\nint svd(real_t *A, const int m, const int n, real_t *w, real_t *V);\n\n#ifdef USE_LAPACK\nvoid lapack_svd(real_t *A, int m, int n, real_t **S, real_t **U, real_t **V_t);\n#endif\n\n/******************************************************************************\n * CHOL\n ******************************************************************************/\n\nvoid chol(const real_t *A, const size_t n, real_t *L);\nvoid chol_solve(const real_t *A, const real_t *b, real_t *x, const size_t n);\n\n#ifdef USE_LAPACK\nvoid lapack_chol_solve(const real_t *A,\n                       const real_t *b,\n                       real_t *x,\n                       const size_t n);\n#endif\n\n/******************************************************************************\n * TRANSFORMS\n ******************************************************************************/\n\nvoid tf(const real_t params[7], real_t T[4 * 4]);\nvoid tf_vector(const real_t T[4 * 4], real_t params[7]);\nvoid tf_decompose(const real_t T[4 * 4], real_t C[3 * 3], real_t r[3]);\nvoid tf_rot_set(real_t T[4 * 4], const real_t C[3 * 3]);\nvoid tf_rot_get(const real_t T[4 * 4], real_t C[3 * 3]);\nvoid tf_quat_set(real_t T[4 * 4], const real_t q[4]);\nvoid tf_quat_get(const real_t T[4 * 4], real_t q[4]);\nvoid tf_euler_set(real_t T[4 * 4], const real_t ypr[3]);\nvoid tf_euler_get(const real_t T[4 * 4], real_t ypr[3]);\nvoid tf_trans_set(real_t T[4 * 4], const real_t r[3]);\nvoid tf_trans_get(const real_t T[4 * 4], real_t r[3]);\nvoid tf_inv(const real_t T[4 * 4], real_t T_inv[4 * 4]);\nvoid tf_point(const real_t T[4 * 4], const real_t p[3], real_t retval[3]);\nvoid tf_hpoint(const real_t T[4 * 4], const real_t p[4], real_t retval[4]);\nvoid tf_perturb_rot(real_t T[4 * 4], const real_t step_size, const int i);\nvoid tf_perturb_trans(real_t T[4 * 4], const real_t step_size, const int i);\nvoid print_pose_vector(const char *prefix, const real_t pose[7]);\nvoid rvec2rot(const real_t *rvec, const real_t eps, real_t *R);\nvoid euler321(const real_t ypr[3], real_t C[3 * 3]);\nvoid euler2quat(const real_t ypr[3], real_t q[4]);\nvoid rot2quat(const real_t C[3 * 3], real_t q[4]);\nvoid rot2euler(const real_t C[3 * 3], real_t ypr[3]);\nvoid quat2euler(const real_t q[4], real_t ypr[3]);\nvoid quat2rot(const real_t q[4], real_t C[3 * 3]);\nreal_t quat_norm(const real_t q[4]);\nvoid quat_normalize(real_t q[4]);\nvoid quat_inv(const real_t q[4], real_t q_inv[4]);\nvoid quat_left(const real_t q[4], real_t left[4 * 4]);\nvoid quat_right(const real_t q[4], real_t right[4 * 4]);\nvoid quat_lmul(const real_t p[4], const real_t q[4], real_t r[4]);\nvoid quat_rmul(const real_t p[4], const real_t q[4], real_t r[4]);\nvoid quat_mul(const real_t p[4], const real_t q[4], real_t r[4]);\nvoid quat_delta(const real_t dalpha[3], real_t dq[4]);\nvoid quat_perturb(real_t q[4], const int i, const real_t h);\n\n/******************************************************************************\n * Lie\n ******************************************************************************/\n\nvoid lie_Exp(const real_t phi[3], real_t C[3 * 3]);\nvoid lie_Log(const real_t C[3 * 3], real_t rvec[3]);\n\n/******************************************************************************\n * CV\n ******************************************************************************/\n\n// IMAGE ///////////////////////////////////////////////////////////////////////\n\ntypedef struct image_t {\n  int width;\n  int height;\n  int channels;\n  uint8_t *data;\n} image_t;\n\nvoid image_setup(image_t *img,\n                 const int width,\n                 const int height,\n                 uint8_t *data);\nimage_t *image_load(const char *file_path);\nvoid image_print_properties(const image_t *img);\nvoid image_free(image_t *img);\n\n// GEOMETRY ////////////////////////////////////////////////////////////////////\n\nvoid linear_triangulation(const real_t P_i[3 * 4],\n                          const real_t P_j[3 * 4],\n                          const real_t z_i[2],\n                          const real_t z_j[2],\n                          real_t p[3]);\n\n// RADTAN //////////////////////////////////////////////////////////////////////\n\nvoid radtan4_distort(const real_t params[4], const real_t p[2], real_t p_d[2]);\nvoid radtan4_point_jacobian(const real_t params[4],\n                            const real_t p[2],\n                            real_t J_point[2 * 2]);\nvoid radtan4_params_jacobian(const real_t params[4],\n                             const real_t p[2],\n                             real_t J_param[2 * 4]);\n\n// EQUI ////////////////////////////////////////////////////////////////////////\n\nvoid equi4_distort(const real_t params[4], const real_t p[2], real_t p_d[2]);\nvoid equi4_point_jacobian(const real_t params[4],\n                          const real_t p[2],\n                          real_t J_point[2 * 2]);\nvoid equi4_params_jacobian(const real_t params[4],\n                           const real_t p[2],\n                           real_t J_param[2 * 4]);\n\n// PINHOLE /////////////////////////////////////////////////////////////////////\n\nreal_t pinhole_focal(const int image_width, const real_t fov);\nvoid pinhole_K(const real_t params[4], real_t K[3 * 3]);\nvoid pinhole_projection_matrix(const real_t params[4],\n                               const real_t T[4 * 4],\n                               real_t P[3 * 4]);\nvoid pinhole_project(const real_t params[4], const real_t p_C[3], real_t z[2]);\nvoid pinhole_point_jacobian(const real_t params[4], real_t J_point[2 * 2]);\nvoid pinhole_params_jacobian(const real_t params[4],\n                             const real_t x[2],\n                             real_t J[2 * 4]);\n\n// PINHOLE-RADTAN4 /////////////////////////////////////////////////////////////\n\nvoid pinhole_radtan4_project(const real_t params[8],\n                             const real_t p_C[3],\n                             real_t x[2]);\nvoid pinhole_radtan4_project_jacobian(const real_t params[8],\n                                      const real_t p_C[3],\n                                      real_t J[2 * 3]);\nvoid pinhole_radtan4_params_jacobian(const real_t params[8],\n                                     const real_t p_C[3],\n                                     real_t J[2 * 8]);\n\n// PINHOLE-EQUI4 ///////////////////////////////////////////////////////////////\n\nvoid pinhole_equi4_project(const real_t params[8],\n                           const real_t p_C[3],\n                           real_t x[2]);\nvoid pinhole_equi4_project_jacobian(const real_t params[8],\n                                    const real_t p_C[3],\n                                    real_t J[2 * 3]);\nvoid pinhole_equi4_params_jacobian(const real_t params[8],\n                                   const real_t p_C[3],\n                                   real_t J[2 * 8]);\n\n/******************************************************************************\n * SENSOR FUSION\n ******************************************************************************/\n\n#define POSE_PARAM 1\n#define SB_PARAM 2\n#define FEATURE_PARAM 3\n#define EXTRINSICS_PARAM 4\n#define CAM_PARAM 5\n\n// POSE ////////////////////////////////////////////////////////////////////////\n\ntypedef struct pose_t {\n  timestamp_t ts;\n  real_t pos[3];\n  real_t quat[4];\n} pose_t;\n\nvoid pose_setup(pose_t *pose, const timestamp_t ts, const real_t *param);\nvoid pose_print(const char *prefix, const pose_t *pose);\n\n// SPEED AND BIASES ////////////////////////////////////////////////////////////\n\ntypedef struct speed_biases_t {\n  timestamp_t ts;\n  real_t data[9];\n} speed_biases_t;\n\nvoid speed_biases_setup(speed_biases_t *sb,\n                        const timestamp_t ts,\n                        const real_t *param);\nvoid speed_biases_print(const speed_biases_t *sb);\n\n// FEATURE /////////////////////////////////////////////////////////////////////\n\n#define MAX_FEATURES 10000\n\ntypedef struct feature_t {\n  real_t data[3];\n} feature_t;\n\nvoid feature_setup(feature_t *p, const real_t *param);\nvoid feature_print(const feature_t *feature);\n\ntypedef struct features_t {\n  feature_t data[MAX_FEATURES];\n  int nb_features;\n  int status[MAX_FEATURES];\n} features_t;\n\nvoid features_setup(features_t *features);\nint features_exists(const features_t *features, const int feature_id);\nfeature_t *features_get(features_t *features, const int feature_id);\nfeature_t *features_add(features_t *features,\n                        const int feature_id,\n                        const real_t *param);\nvoid features_remove(features_t *features, const int feature_id);\n\n// EXTRINSICS //////////////////////////////////////////////////////////////////\n\ntypedef struct extrinsics_t {\n  real_t pos[3];\n  real_t quat[4];\n} extrinsics_t;\n\nvoid extrinsics_setup(extrinsics_t *extrinsics, const real_t *param);\nvoid extrinsics_print(const char *prefix, const extrinsics_t *exts);\n\n// CAMERA PARAMS ///////////////////////////////////////////////////////////////\n\ntypedef struct camera_params_t {\n  int cam_idx;\n  int resolution[2];\n  char proj_model[20];\n  char dist_model[20];\n  real_t data[8];\n} camera_params_t;\n\nvoid camera_params_setup(camera_params_t *camera,\n                         const int cam_idx,\n                         const int cam_res[2],\n                         const char *proj_model,\n                         const char *dist_model,\n                         const real_t *data);\nvoid camera_params_print(const camera_params_t *camera);\n\n// POSE FACTOR /////////////////////////////////////////////////////////////////\n\ntypedef struct pose_factor_t {\n  real_t pos_meas[3];\n  real_t quat_meas[4];\n  pose_t *pose_est;\n  int nb_params;\n\n  real_t covar[6 * 6];\n  real_t sqrt_info[6 * 6];\n} pose_factor_t;\n\nvoid pose_factor_setup(pose_factor_t *factor,\n                       pose_t *pose,\n                       const real_t var[6]);\nint pose_factor_eval(pose_factor_t *factor,\n                     real_t **params,\n                     real_t *residuals,\n                     real_t **jacobians);\nint pose_factor_ceres_eval(void *factor,\n                           double **params,\n                           double *residuals,\n                           double **jacobians);\n\n// BA FACTOR ///////////////////////////////////////////////////////////////////\n\ntypedef struct ba_factor_t {\n  const pose_t *pose;\n  const camera_params_t *camera;\n  const feature_t *feature;\n  int nb_params;\n\n  real_t covar[2 * 2];\n  real_t sqrt_info[2 * 2];\n  real_t z[2];\n} ba_factor_t;\n\nvoid ba_factor_setup(ba_factor_t *factor,\n                     const pose_t *pose,\n                     const feature_t *feature,\n                     const camera_params_t *camera,\n                     const real_t z[2],\n                     const real_t var[2]);\nint ba_factor_eval(ba_factor_t *factor,\n                   real_t **params,\n                   real_t *residuals,\n                   real_t **jacobians);\nint ba_factor_ceres_eval(void *factor,\n                         double **params,\n                         double *residuals,\n                         double **jacobians);\n\n// CAMERA FACTOR ///////////////////////////////////////////////////////////////\n\ntypedef struct cam_factor_t {\n  const pose_t *pose;\n  const extrinsics_t *extrinsics;\n  const camera_params_t *camera;\n  const feature_t *feature;\n  int nb_params;\n\n  real_t covar[2 * 2];\n  real_t sqrt_info[2 * 2];\n  real_t z[2];\n} cam_factor_t;\n\nvoid cam_factor_setup(cam_factor_t *factor,\n                      const pose_t *pose,\n                      const extrinsics_t *extrinsics,\n                      const feature_t *feature,\n                      const camera_params_t *camera,\n                      const real_t z[2],\n                      const real_t var[2]);\nint cam_factor_eval(cam_factor_t *factor,\n                    real_t **params,\n                    real_t *residuals,\n                    real_t **jacobians);\nint cam_factor_ceres_eval(void *factor,\n                          double **params,\n                          double *residuals,\n                          double **jacobians);\n\n// IMU FACTOR //////////////////////////////////////////////////////////////////\n\n#define MAX_IMU_BUF_SIZE 10000\n\ntypedef struct imu_params_t {\n  uint64_t param_id;\n  int imu_idx;\n  real_t rate;\n\n  real_t n_aw;\n  real_t n_gw;\n  real_t n_a;\n  real_t n_g;\n  real_t g;\n} imu_params_t;\n\ntypedef struct imu_buf_t {\n  timestamp_t ts[MAX_IMU_BUF_SIZE];\n  real_t acc[MAX_IMU_BUF_SIZE][3];\n  real_t gyr[MAX_IMU_BUF_SIZE][3];\n  int size;\n} imu_buf_t;\n\ntypedef struct imu_factor_t {\n  imu_params_t *imu_params;\n  imu_buf_t imu_buf;\n  pose_t *pose_i;\n  pose_t *pose_j;\n  speed_biases_t *sb_i;\n  speed_biases_t *sb_j;\n\n  real_t covar[15 * 15];\n  real_t r[15];\n  int r_size;\n\n  real_t J0[2 * 6]; /* Jacobian w.r.t pose i */\n  real_t J1[2 * 9]; /* Jacobian w.r.t speed and biases i */\n  real_t J2[2 * 6]; /* Jacobian w.r.t pose j */\n  real_t J3[2 * 9]; /* Jacobian w.r.t speed and biases j */\n  real_t *jacs[4];\n  int nb_params;\n\n  /* Preintegration variables */\n  real_t Dt;\n  real_t F[15 * 15]; /* State jacobian */\n  real_t P[15 * 15]; /* State covariance */\n  real_t Q[15 * 15]; /* Noise matrix */\n\n  real_t dr[3];     /* Relative position */\n  real_t dv[3];     /* Relative velocity */\n  real_t dC[3 * 3]; /* Relative rotation */\n  real_t ba[3];     /* Accel biase */\n  real_t bg[3];     /* Gyro biase */\n\n} imu_factor_t;\n\nvoid imu_buf_setup(imu_buf_t *imu_buf);\nvoid imu_buf_add(imu_buf_t *imu_buf,\n                 const timestamp_t ts,\n                 const real_t acc[3],\n                 const real_t gyr[3]);\nvoid imu_buf_clear(imu_buf_t *imu_buf);\nvoid imu_buf_copy(const imu_buf_t *from, imu_buf_t *to);\nvoid imu_buf_print(const imu_buf_t *imu_buf);\n\n/* void imu_factor_setup(imu_factor_t *factor, */\n/*                       imu_params_t *imu_params, */\n/*                       imu_buf_t *imu_buf, */\n/*                       pose_t *pose_i, */\n/*                       speed_biases_t *sb_i, */\n/*                       pose_t *pose_j, */\n/*                       speed_biases_t *sb_j); */\nvoid imu_factor_reset(imu_factor_t *factor);\n\n// GRAPH ///////////////////////////////////////////////////////////////////////\n\n#define MAX_NB_FACTORS 1000\n\n#define POSE_FACTOR 1\n#define BA_FACTOR 2\n#define CAM_FACTOR 3\n#define IMU_FACTOR 4\n\ntypedef struct keyframe_t {\n  cam_factor_t *cam_factors;\n  int nb_cam_factors;\n\n  imu_factor_t *imu_factors;\n  int nb_imu_factors;\n\n  pose_t *pose;\n} keyframe_t;\n\ntypedef struct graph_t {\n  void *factors[MAX_NB_FACTORS];\n  int nb_factors;\n  int *factor_types;\n\n  pose_t **poses;\n  int nb_poses;\n\n  const extrinsics_t *extrinsics;\n  int nb_exts;\n\n  camera_params_t **cam_params;\n  int nb_cams;\n\n  feature_t **features;\n  int nb_features;\n\n  real_t *H;\n  real_t *g;\n  real_t *x;\n  int x_size;\n  int r_size;\n} graph_t;\n\nvoid graph_setup(graph_t *graph);\nvoid graph_print(graph_t *graph);\nint graph_add_factor(graph_t *graph, void *factor, int factor_type);\nint graph_eval(graph_t *graph);\nvoid graph_optimize(graph_t *graph);\n\n/******************************************************************************\n * DATASET\n ******************************************************************************/\n\npose_t *load_poses(const char *fp, int *nb_poses);\nint **assoc_pose_data(pose_t *gnd_poses,\n                      size_t nb_gnd_poses,\n                      pose_t *est_poses,\n                      size_t nb_est_poses,\n                      double threshold,\n                      size_t *nb_matches);\n\n/******************************************************************************\n * SIM\n ******************************************************************************/\n\n// SIM FEATURES ////////////////////////////////////////////////////////////////\n\ntypedef struct sim_features_t {\n  real_t **features;\n  int nb_features;\n} sim_features_t;\n\nsim_features_t *load_sim_features(const char *csv_path);\nvoid free_sim_features(sim_features_t *features_data);\n\n// SIM IMU DATA ////////////////////////////////////////////////////////////////\n\ntypedef struct sim_imu_data_t {\n  real_t **data;\n  int nb_measurements;\n} sim_imu_data_t;\n\nsim_imu_data_t *load_sim_imu_data(const char *csv_path);\nvoid free_sim_imu_data(sim_imu_data_t *imu_data);\n\n// SIM CAM DATA ////////////////////////////////////////////////////////////////\n\ntypedef struct sim_cam_frame_t {\n  timestamp_t ts;\n  int *feature_ids;\n  real_t **keypoints;\n  int nb_measurements;\n} sim_cam_frame_t;\n\ntypedef struct sim_cam_data_t {\n  sim_cam_frame_t **frames;\n  int nb_frames;\n\n  timestamp_t *ts;\n  real_t **poses;\n} sim_cam_data_t;\n\nsim_cam_frame_t *load_sim_cam_frame(const char *csv_path);\nvoid print_sim_cam_frame(sim_cam_frame_t *frame_data);\nvoid free_sim_cam_frame(sim_cam_frame_t *frame_data);\n\nsim_cam_data_t *load_sim_cam_data(const char *dir_path);\nvoid free_sim_cam_data(sim_cam_data_t *cam_data);\n\n#endif // _PROTO_H_\n", "meta": {"hexsha": "14c1e0646e48bf1d12cdd9ca84afc9dbc3fcd8b4", "size": 30083, "ext": "h", "lang": "C", "max_stars_repo_path": "proto/lib/proto.h", "max_stars_repo_name": "daoran/proto", "max_stars_repo_head_hexsha": "c0f7bfc3acceac7872dfe9b510e2713f3e5efd90", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 15.0, "max_stars_repo_stars_event_min_datetime": "2019-08-27T21:37:47.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-20T12:25:04.000Z", "max_issues_repo_path": "proto/lib/proto.h", "max_issues_repo_name": "daoran/proto", "max_issues_repo_head_hexsha": "c0f7bfc3acceac7872dfe9b510e2713f3e5efd90", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-12-21T01:08:52.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-21T01:10:10.000Z", "max_forks_repo_path": "proto/lib/proto.h", "max_forks_repo_name": "daoran/proto", "max_forks_repo_head_hexsha": "c0f7bfc3acceac7872dfe9b510e2713f3e5efd90", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2020-03-12T05:10:24.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-22T03:19:44.000Z", "avg_line_length": 33.5373467113, "max_line_length": 80, "alphanum_fraction": 0.5126150982, "num_tokens": 6780, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.19436781568545955, "lm_q2_score": 0.029312231811314076, "lm_q1q2_score": 0.0056973544700309586}}
{"text": "/*--------------------------------------------------------------------\n * $Id$\n * \n * This file is part of libRadtran.\n * Copyright (c) 1997-2012 by Arve Kylling, Bernhard Mayer,\n *                            Claudia Emde, Robert Buras\n *\n * ######### Contact info: http://www.libradtran.org #########\n *\n * This program is free software; you can redistribute it and/or \n * modify it under the terms of the GNU General Public License   \n * as published by the Free Software Foundation; either version 2\n * of the License, or (at your option) any later version.        \n * \n * This program is distributed in the hope that it will be useful, \n * but WITHOUT ANY WARRANTY; without even the implied warranty of  \n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the   \n * GNU General Public License for more details.                    \n * \n * You should have received a copy of the GNU General Public License          \n * along with this program; if not, write to the Free Software                \n * Foundation, Inc., 59 Temple Place - Suite 330, \n * Boston, MA 02111-1307, USA.\n *--------------------------------------------------------------------*/\n\n#include <math.h>\n#include <string.h>\n#include <time.h>\n#include <assert.h>\n\n#include \"solve_rte.h\"\n#include \"uvspec.h\"\n#include \"uvspecrandom.h\"\n#include \"ascii.h\"\n#include \"ancillary.h\"\n#include \"numeric.h\"\n#include \"fortran_and_c.h\"\n#include \"cloud.h\"\n#include \"molecular.h\"\n#include \"rodents.h\"\n#include \"twostrebe.h\"\n#include \"twomaxrnd.h\"\n#include \"dynamic_twostream.h\"\n#include \"dynamic_tenstream.h\"\n#if HAVE_TWOMAXRND3C\n#include \"twomaxrnd3C.h\"\n#endif\n#include \"cdisort.h\"\n#include \"c_tzs.h\"\n#include \"sslidar.h\"\n#include \"errors.h\"\n#include \"Corefinder.h\"\n#include \"LinArray.h\"\n#include \"wcloud3d.h\"\n#include \"allocnd.h\"\n#include \"redistribute.h\"\n\n#if HAVE_MYSTIC\n#include \"mystic.h\"\n#endif\n#if HAVE_TIPA\n#include \"tipa.h\"\n#endif\n#if HAVE_SOS\n#include \"sos.h\"\n#endif\n\n#include \"f77-uscore.h\"\n#include \"solver.h\"\n\n#ifndef PI\n#define PI 3.14159265358979323846264338327\n#endif\n\n#if HAVE_LIBGSL\n#include <gsl/gsl_math.h>\n#include <gsl/gsl_diff.h>\n#endif\n\n/* Definitions for numerical recipes functions */\n#define NRANSI\n#define SIGN(a, b) ((b) >= 0.0 ? fabs (a) : -fabs (a))\n\n/* internal structures */\ntypedef struct {\n  char*       deltam;\n  char*       ground_type;\n  char        polscat[15];\n  pol_complex ground_index;\n  double      albedo;\n  double      btemp;\n  double      flux;\n  double*     gas_extinct;\n  double*     height;\n  double      mu;\n  double      sky_temp;\n  double*     temperatures;\n  double      wavelength;\n  int*        outlevels;\n  int         nummu; /* Number of quadrature angles (per hemisphere). */\n} polradtran_input;\n\ntypedef struct {\n  char header[127]; /* A 127- (or less) character header for prints         */\n\n  float accur; /* Convergence criterion for azimuthal series.          */\n\n  float fbeam; /* Intensity of incident parallel beam at top boundary. */\n               /*  [same units as PLKAVG (default W/sq m) if thermal   */\n               /*  sources active, otherwise arbitrary units].         */\n\n  float fisot; /* Intensity of top-boundary isotropic illumination.    */\n               /*  [same units as PLKAVG (default W/sq m) if thermal   */\n               /*  sources active, otherwise arbitrary units].         */\n               /*  Corresponding incident flux is pi (3.14159...)      */\n               /*  times FISOT.                                        */\n\n  float* hl; /* K = 0 to NSTR.  Coefficients in Legendre-            */\n             /* polynomial expansion of bottom bidirectional         */\n             /* reflectivity                                         */\n\n  int planck; /* TRUE,  include thermal emission                      */\n              /* FALSE, ignore thermal emission (saves computer time) */\n\n  float btemp; /* Temperature of bottom boundary (K)                   */\n               /* (bottom emissivity is calculated from ALBEDO or HL,  */\n               /* so it need not be specified).                        */\n               /* Needed only if PLANK is TRUE.                        */\n\n  float ttemp; /* Temperature of top boundary (K)                      */\n               /* Needed only if PLANK is TRUE.                        */\n\n  float temis; /* Emissivity of top boundary.                          */\n               /* Needed only if PLANK is TRUE.                        */\n\n  float* utau;\n  float  umu0;\n\n  int ierror_d[47];\n  int ierror_s[33];\n  int ierror_t[22];\n\n  int prndis[7];\n  int prndis2[5];\n  int prntwo[2];\n\n  int ibcnd; /* 0 : General case.                                    */\n             /* 1 : Return only albedo and transmissivity of the     */\n             /*     entire medium vs. incident beam angle.           */\n\n  int lamber; /* TRUE, isotropically reflecting bottom boundary.      */\n              /* FALSE, bidirectionally reflecting bottom boundary.   */\n\n  int onlyfl; /* TRUE, return fluxes, flux divergences, and mean      */\n              /*       intensities.                                   */\n              /* FALSE, return fluxes, flux divergences, mean         */\n              /*        intensities, azimuthally averaged intensities */\n              /*        (at the user angles) AND intensities.         */\n\n  int quiet;\n  int usrang;\n  int usrtau;\n\n  /* sdisort-specific variables */\n  int nil;\n  int newgeo;\n  int spher;\n\n  /* qdisort-specific variables */\n  int       gsrc;  /* Flag for general source for qdisort */\n  double*** qsrc;  /* The general source, in FORTRAN: REAL*4 qsrc( MXCMU, 0:MXULV, MXCMU )*/\n                   /* At computational angles                                             */\n  double*** qsrcu; /* The general source, in FORTRAN: REAL*4 qsrc( MXUMU, 0:MXULV, MXCMU )*/\n                   /* At user angles                                                      */\n\n  /* PolRadtran-specific variables */\n  polradtran_input pol;\n\n} rte_input;\n\ntypedef struct {\n  float*   dfdt;\n  float*   flup;\n  float*   rfldir;\n  float*   rfldn;\n  float*   uavgso;\n  float*   uavgdn;\n  float*   uavgup;\n  float*   uavg;\n  float*   heat;\n  float*   emis;\n  float*   w_zout;\n  float**  u0u;\n  float*** uu;\n  float*** uum; /* Fourier components of intensities, returned by qdisort */\n  float*   sslidar_nphot;\n  float*   sslidar_nphot_q;\n  float*   sslidar_ratio;\n\n  float***    rfldir3d;\n  float***    rfldn3d;\n  float***    flup3d;\n  float*****  fl3d_is; /* importance sampling */\n  float***    uavgso3d;\n  float***    uavgdn3d;\n  float***    uavgup3d;\n  float***    abs3d;\n  float***    absback3d;\n  float****   radiance3d;\n  float****** radiance3d_is; /*importance sampling*/\n  float****** jacobian;\n\n  /* corresponding variances */\n  float***  rfldir3d_var;\n  float***  rfldn3d_var;\n  float***  flup3d_var;\n  float***  uavgso3d_var;\n  float***  uavgdn3d_var;\n  float***  uavgup3d_var;\n  float***  abs3d_var;\n  float***  absback3d_var;\n  float**** radiance3d_var;\n\n  float* albmed;\n  float* trnmed;\n\n  double**   polradtran_down_flux;\n  double**   polradtran_up_flux;\n  double**** polradtran_down_rad_q; /* _q indicates radiances at quadrature angels. */\n  double**** polradtran_up_rad_q;\n  double**** polradtran_down_rad;\n  double**** polradtran_up_rad;\n  double*    polradtran_mu_values;\n\n  // triangular surface output\n  struct t_triangle_radiation_field* triangle_results;\n} rte_output;\n\ntypedef struct {\n  float* tauw;\n  float* taui;\n\n  float* g1d;\n  float* g2d;\n  float* fd;\n  float* g1i;\n  float* g2i;\n  float* fi;\n\n  float* ssaw;\n  float* ssai;\n} save_optprop;\n\ntypedef struct {\n  double**   dtauc;\n  double*    fbeam;\n  double**** uum;\n  double **  uavgso, **uavgdn, **uavgup;\n  double **  rfldir, **rfldn, **flup;\n  double***  u0u;\n  double**** uu;\n} raman_qsrc_components;\n\n/* prototypes of internal functions */\nstatic int         reverse_profiles (input_struct input, output_struct* output);\nstatic rte_output* calloc_rte_output (input_struct input,\n                                      int          nzout,\n                                      int          Nxcld,\n                                      int          Nycld,\n                                      int          Nzcld,\n                                      int          Ncsample,\n                                      int          Nlambda,\n                                      int          Nxsample,\n                                      int          Nysample,\n                                      int          Nlyr,\n                                      int*         threed,\n                                      int          passback3D,\n                                      const size_t N_triangles);\n\nstatic int reset_rte_output (rte_output** rte,\n                             input_struct input,\n                             int          nzout,\n                             int          Nxcld,\n                             int          Nycld,\n                             int          Nzcld,\n                             int          Nxsample,\n                             int          Nysample,\n                             int          Ncsample,\n                             int          Nlambda,\n                             int          Nlyr,\n                             int*         threed,\n                             int          passback3D,\n                             const size_t N_triangles);\n\nstatic int free_rte_output (rte_output*  result,\n                            input_struct input,\n                            int          nzout,\n                            int          Nxcld,\n                            int          Nycld,\n                            int          Nzcld,\n                            int          Nxsample,\n                            int          Nysample,\n                            int          Ncsample,\n                            int          Nlyr,\n                            int          Nlambda,\n                            int*         threed,\n                            int          passback3D);\n\nstatic int  add_rte_output (rte_output*        rte,\n                            const rte_output*  add,\n                            const double       factor,\n                            const double*      factor_spectral,\n                            const input_struct input,\n                            const int          nzout,\n                            const int          Nxcld,\n                            const int          Nycld,\n                            const int          Nzcld,\n                            const int          Nc,\n                            const int          Nlyr,\n                            const int          Nlambda,\n                            const int*         threed,\n                            const int          passback3D,\n                            const int          islower,\n                            const int          isupper,\n                            const int          jslower,\n                            const int          jsupper,\n                            const int          isstep,\n                            const int          jsstep);\nstatic int  init_rte_input (rte_input* rte, input_struct input, output_struct* output);\nstatic int  setup_and_call_solver (input_struct           input,\n                                   output_struct*         output,\n                                   rte_input*             rte_in,\n                                   rte_output*            rte_out,\n                                   raman_qsrc_components* raman_qsrc_components,\n                                   int                    iv,\n                                   int                    ib,\n                                   int                    ir,\n                                   int*                   threed,\n                                   int                    mc_loaddata);\nstatic int  call_solver (input_struct           input,\n                         output_struct*         output,\n                         int                    rte_solver,\n                         rte_input*             rte_in,\n                         raman_qsrc_components* raman_qsrc_components,\n                         int                    iv,\n                         int                    ib,\n                         int                    ir,\n                         rte_output*            rte_out,\n                         int*                   threed,\n                         int                    mc_loaddata,\n                         int                    verbose);\nstatic void fourier2azimuth (double**** down_rad_rt3,\n                             double**** up_rad_rt3,\n                             double**** down_rad,\n                             double**** up_rad,\n                             int        nzout,\n                             int        aziorder,\n                             int        nstr,\n                             int        numu,\n                             int        nstokes,\n                             int        nphi,\n                             float*     phi);\n\nstatic int calc_spectral_heating (input_struct   input,\n                                  output_struct* output,\n                                  float*         dz,\n                                  double*        rho_mass_zout,\n                                  float*         k_abs,\n                                  float*         k_abs_layer,\n                                  int*           zout_index,\n                                  rte_output*    rte_out,\n                                  float*         heat,\n                                  float*         emis,\n                                  float*         w_zout,\n                                  int            iv);\n\nstatic float*** calloc_abs3d (int Nx, int Ny, int Nz, int* threed);\n\nstatic void free_abs3d (float*** abs3d, int Nx, int Ny, int Nz, int* threed);\n\nstatic float**** calloc_spectral_abs3d (int Nx, int Ny, int Nz, int nlambda, int* threed);\n\ndouble get_unit_factor (input_struct input, output_struct* output, int iv);\n\nstatic int\ngenerate_effective_cloud (input_struct input, output_struct* output, save_optprop* save_cloud, int iv, int iq, int verbose);\n\nstatic int set_raman_source (double***              qsrc,\n                             double***              qsrcu,\n                             int                    maxphi,\n                             int                    nlev,\n                             int                    nzout,\n                             int                    nstr,\n                             int                    n_shifts,\n                             float                  wanted_wl,\n                             double*                wl_shifts,\n                             float                  umu0,\n                             float*                 zd,\n                             float*                 zout,\n                             float                  zenang,\n                             float                  fbeam,\n                             float                  radius,\n                             float*                 dens,\n                             double**               crs_RL,\n                             double**               crs_RG,\n                             float*                 ssalb,\n                             int                    numu,\n                             float*                 umu,\n                             int                    usrang,\n                             int*                   cmuind,\n                             float***               pmom,\n                             raman_qsrc_components* raman_qsrc_components,\n                             int*                   zout_comp_index,\n                             float                  altitude,\n                             int                    last,\n                             int                    verbose);\n\nstatic save_optprop* calloc_save_optprop (int Nlev);\n\nraman_qsrc_components* calloc_raman_qsrc_components (int raman_fast, int nzout, int maxumu, int nphi, int nstr, int nlambda_shift);\n\nstatic void free_raman_qsrc_components (raman_qsrc_components* result, int raman_fast, int nzout, int maxumu, int nphi, int nstr);\n\nvoid F77_FUNC (swde, SWDE) (float* g_scaled,\n                            float* pref,\n                            float* prmuz,\n                            float* tau,\n                            float* ssa_gas,\n                            float* pre1,\n                            float* pre2,\n                            float* ptr1,\n                            float* ptr2);\n\nfloat zbrent_taueff (float mu_eff,\n                     float g_scaled,\n                     float ssa_gas,\n                     float transmission_cloud,\n                     float transmission_layer,\n                     float x1,\n                     float x2,\n                     float tol);\n\nvoid F77_FUNC (qgausn, QGAUSN) (int* n, float* cmu, float* cwt);\nvoid F77_FUNC (lepolys, LEPOLYS) (int* nn, int* mazim, int* mxcmu, int* nstr, float* cmu, float* ylmc);\n\n/*********************************************************************/\n/* Main function. Loop over wavelengths or wavelength bands,         */\n/* correlated-k quadrature points, and independent pixels.           */\n/*********************************************************************/\n\nint solve_rte (input_struct input, output_struct* output) {\n  static int first  = TRUE;\n  int        status = 0, add = 0;\n  int        isp = 0, ipa = 0, is = 0, js = 0, ks = 0, ivs = 0, iv_alis = 0, iv_alis_ref = 0;\n\n  int       iipa = 0, jipa = 0;\n  int       iv = 0, iu = 0, j = 0, lu = 0, ip = 0, iz = 0, ic = 0;\n  int       iq = 0, lc = 0, nr = 0, ir = 0, irs = 0;\n  int       ijac        = 0;\n  int       lower_wl_id = 0, upper_wl_id = 0, lower_iq_id = 0, upper_iq_id = 0, ivr = 0;\n  int       nlambda       = 0;\n  float*    dz            = NULL;\n  double    weight        = 1;\n  double*   rho_mass_zout = NULL;\n  float*    k_abs         = NULL;\n  float*    k_abs_layer   = NULL;\n  float*    k_abs_outband = NULL;\n  int       mc_loaddata   = 1;\n  double    weight2       = 0;\n  double    unit_factor   = 0;\n  double    ffactor = 0.0, rfactor = 0.0, hfactor = 1.0;\n  double**  u0u_raman    = NULL;\n  double*   uavgso_raman = NULL;\n  double*   uavgdn_raman = NULL;\n  double*   uavgup_raman = NULL;\n  double*   rfldir_raman = NULL;\n  double*   rfldn_raman  = NULL;\n  double*   flup_raman   = NULL;\n  double*** uu_raman     = NULL; /* The radiance at user angles for the general source for qdisort */\n                                 /* Only used if raman scattering is on                            */\n\n  /* float heating_rate_emission = 0.0; */\n\n  rte_input*  rte_in      = NULL;\n  rte_output* rte_out     = NULL;\n  rte_output* rte_outband = NULL;\n\n  save_optprop*          save_cloud            = NULL;\n  raman_qsrc_components* raman_qsrc_components = NULL;\n\n  char function_name[] = \"solve_rte\";\n  char file_name[]     = \"solve_rte.c\";\n\n  double* weight_spectral = NULL;\n\n  //FIX 3DAbs not initialized when aerosol setup not done, should be redundant now\n  // output->mc.alis.Nc = 1;\n\n  if (first) {\n    first = FALSE;\n\n    /* this is not the right place to do this! This should be done somewhere else! Please clean up! BCA */\n    if (input.ipa3d) {\n      output->mc.sample.passback3D = 1; /* like for mystic, I set passback3d to 1 */\n\n      /* ipa3d and tipa were configured and tested only with 3D-cloudfiles containing lwc and reff, thus check: */\n      for (isp = 0; isp < input.n_caoth; isp++)\n        if (!(output->caoth3d[isp].cldproperties == 3 || output->caoth3d[isp].cldproperties == 4)) {\n          fprintf (stderr, \"Error: ipa3d/tipa does not work with cldproperties flag different from 3\\n\");\n          return -1;\n        }\n\n      /* finally, we add normalization to the number of pixels to ipaweight, BM 3.7.2020 */\n      /* ipaweight[] either considers cloudcover or normalization for ipa3d              */\n      for (ipa = 0; ipa < output->nipa; ipa++)\n        output->ipaweight[ipa] /= ((double)output->niipa * (double)output->njipa);\n    }\n\n    rte_in = calloc (1, sizeof (rte_input));\n\n    rte_out = calloc_rte_output (input,\n                                 output->atm.nzout,\n                                 output->atm.Nxcld,\n                                 output->atm.Nycld,\n                                 output->atm.Nzcld,\n                                 output->mc.sample.Nx,\n                                 output->mc.sample.Ny,\n                                 output->mc.alis.Nc,\n                                 output->mc.alis.nlambda_abs,\n                                 output->atm.nlev - 1,\n                                 output->atm.threed,\n                                 output->mc.sample.passback3D,\n                                 output->mc.triangular_surface.N_triangles);\n\n    rte_outband = calloc_rte_output (input,\n                                     output->atm.nzout,\n                                     output->atm.Nxcld,\n                                     output->atm.Nycld,\n                                     output->atm.Nzcld,\n                                     output->mc.sample.Nx,\n                                     output->mc.sample.Ny,\n                                     output->mc.alis.Nc,\n                                     output->mc.alis.nlambda_abs,\n                                     output->atm.nlev - 1,\n                                     output->atm.threed,\n                                     output->mc.sample.passback3D,\n                                     output->mc.triangular_surface.N_triangles);\n\n    save_cloud = calloc_save_optprop (output->atm.nlev);\n\n    /* initialize RTE input */\n    status = init_rte_input (rte_in, input, output);\n    if (status != 0) {\n      fprintf (stderr, \"Error %d initializing rte input in %s (%s)\\n\", status, function_name, file_name);\n      return status;\n    }\n\n    /* allocate memory for the output result structures */\n    status = setup_result (input, output, &dz, &rho_mass_zout, &k_abs_layer, &k_abs, &k_abs_outband);\n    if (status != 0) {\n      fprintf (stderr, \"Error %d allocating memory for the model output in %s (%s)\\n\", status, function_name, file_name);\n      return status;\n    }\n\n    if (input.raman) {\n      nr = 2;\n\n      if ((status = ASCII_calloc_double_3D (&uu_raman, output->atm.nzout, input.rte.nphi, input.rte.numu)) != 0)\n        return status;\n      if ((status = ASCII_calloc_double (&u0u_raman, output->atm.nzout, input.rte.numu)) != 0)\n        return status;\n      uavgso_raman = calloc (output->atm.nzout, sizeof (double));\n      uavgdn_raman = calloc (output->atm.nzout, sizeof (double));\n      uavgup_raman = calloc (output->atm.nzout, sizeof (double));\n      rfldir_raman = calloc (output->atm.nzout, sizeof (double));\n      rfldn_raman  = calloc (output->atm.nzout, sizeof (double));\n      flup_raman   = calloc (output->atm.nzout, sizeof (double));\n\n      /* Number of wavelength shifts considered is independent of primary wavelength, */\n      /* hence use output->atm.nq_t[0] below                                          */\n      if (input.raman_fast)\n        nlambda = output->wl.nlambda_r;\n      else\n        nlambda = output->crs.number_of_ramanwavelengths;\n      raman_qsrc_components = calloc_raman_qsrc_components (input.raman_fast,\n                                                            output->atm.nzout,\n                                                            input.rte.maxumu,\n                                                            input.rte.nphi,\n                                                            input.rte.nstr,\n                                                            nlambda);\n    } else {\n      nr = 1;\n    }\n  }\n\n  if (input.raman) {\n    /* For Raman scattering only include wavelengths that the user asked. */\n    /* Internally we have to include more wavelengths to account for      */\n    /* Raman scattered radiation, see loop over quadrature points below.  */\n\n    lower_wl_id = output->wl.raman_start_id;\n    upper_wl_id = output->wl.raman_end_id;\n  } else {\n    lower_wl_id = output->wl.nlambda_rte_lower;\n    upper_wl_id = output->wl.nlambda_rte_upper;\n  }\n\n  /* concentration importance sampling */\n  if (input.rte.mc.concentration_is) {\n    weight_spectral    = calloc (1, sizeof (double));\n    weight_spectral[0] = 1.0;\n  }\n\n  if (input.rte.mc.spectral_is) {\n\n    weight_spectral = calloc (output->mc.alis.nlambda_abs, sizeof (double));\n    /* Take wavelength in center of spectrum if not specified explicitly, FIXCE should also check whether absorption is not too high here */\n    if (input.rte.mc.spectral_is_wvl[0] == 0.) {\n      lower_wl_id                    = (int)(0.5 * ((float)output->wl.nlambda_rte_lower + (float)output->wl.nlambda_rte_upper));\n      output->mc.alis.nlambda_ref    = 1;\n      output->mc.alis.ilambda_ref    = calloc (1, sizeof (int));\n      output->mc.alis.ilambda_ref[0] = lower_wl_id;\n    }\n\n    else if (input.rte.mc.spectral_is_wvl[0] > 0.) {\n      /* Find wavelength index for specified wavelength */\n      lower_wl_id = 0;\n      for (iv_alis = 0; iv_alis < output->mc.alis.nlambda_abs; iv_alis++) {\n        if (output->mc.alis.lambda[iv_alis] > input.rte.mc.spectral_is_wvl[0]) {\n          lower_wl_id                    = iv_alis - 1;\n          output->mc.alis.nlambda_ref    = 1;\n          output->mc.alis.ilambda_ref    = calloc (1, sizeof (int));\n          output->mc.alis.ilambda_ref[0] = lower_wl_id;\n          break;\n        }\n      }\n    } else {\n      /* several calc wvls do not work so far */\n      lower_wl_id                 = (int)(0.5 * ((float)output->wl.nlambda_rte_lower + (float)output->wl.nlambda_rte_upper));\n      output->mc.alis.nlambda_ref = input.rte.mc.spectral_is_nwvl;\n      output->mc.alis.ilambda_ref = calloc (output->mc.alis.nlambda_ref, sizeof (int));\n      for (iv_alis_ref = 0; iv_alis_ref < output->mc.alis.nlambda_ref; iv_alis_ref++) {\n        for (iv_alis = 0; iv_alis < output->mc.alis.nlambda_abs; iv_alis++) {\n          if (output->mc.alis.lambda[iv_alis] > input.rte.mc.spectral_is_wvl[iv_alis_ref]) {\n            output->mc.alis.ilambda_ref[iv_alis_ref] = iv_alis;\n          }\n        }\n      }\n    }\n\n    upper_wl_id = lower_wl_id;\n    if (!input.quiet) {\n      fprintf (stderr, \"... ALIS calculation wavelength: %g nm \\n\", output->mc.alis.lambda[lower_wl_id]);\n      if (output->mc.alis.nlambda_ref > 1)\n        for (iv_alis_ref = 1; iv_alis_ref < output->mc.alis.nlambda_ref; iv_alis_ref++) {\n          fprintf (stderr,\n                   \"... helper ALIS wavelength: %g nm \\n\",\n                   output->mc.alis.lambda[output->mc.alis.ilambda_ref[iv_alis_ref]]);\n        }\n    }\n  }\n\n#if HAVE_TIPA\n  /* ulrike: TIPA DIR. The \"tilted cloud matrix\" is used only for the\n                       calculation of the DIRECT radiation Tilting for\n                       every z-level is done here (outside the loop\n                       over the wavelength)  */\n  if (input.tipa == TIPA_DIR || input.rte.mc.tipa == TIPA_DIR) {\n    for (isp = 0; isp < input.n_caoth; isp++)\n      if (input.caoth[isp].source == CAOTH_FROM_3D) {\n        if (!input.quiet)\n          fprintf (stderr, \" ... performing the tilting for tipa dir (water clouds)\\n\");\n        status = tipa_dirtilt (&(output->caoth3d[isp]),\n                               output->atm,\n                               output->alt,\n                               &(output->caoth[isp].tipa),\n                               input.tipa,\n                               input.atm.sza,\n                               input.atm.phi0,\n                               lower_wl_id,\n                               upper_wl_id,\n                               input.rte.mc.tipa);\n        if (status)\n          return fct_err_out (status, \"tipa_dirtilt\", ERROR_POSITION);\n      }\n  }\n#endif\n\n  /************************/\n  /* loop over wavelength */\n  /************************/\n  int iv_count = 0;\n  for (iv = lower_wl_id; iv <= upper_wl_id; iv++) {\n\n    /***********************************************************/\n    /* iterate over wavelengths, required for raman scattering */\n    /***********************************************************/\n\n    irs = 0;\n    if (input.raman_fast && iv > lower_wl_id)\n      irs = 1; /* AK20110407: All the elastic wavelengths are done for  */\n               /* iv=lower_wl_id and stored. Thus only need to do       */\n               /* the inelastic part for remaining wavelengths.         */\n\n    for (ir = irs; ir < nr; ir++) {\n\n      /* solar zenith angle at this wavelength */\n      rte_in->umu0 = cos (output->atm.sza_r[iv] * PI / 180.0);\n\n      /* calculate 3D caoth properties for this wavelength */\n\n      if (input.rte.solver == SOLVER_MONTECARLO || input.rte.solver == SOLVER_DYNAMIC_TENSTREAM) {\n        int isp_hiddencore = -1, isp_wc3D = -1;\n        for (isp = 0; isp < input.n_caoth; isp++) {\n          if (strcmp (input.caoth[isp].name, \"molecular_3d\") != 0) {\n            status = convert_caoth_mystic (input, input.caoth[isp], output, &(output->caoth[isp]), &(output->caoth3d[isp]), iv);\n            if (status)\n              return fct_err_out (status, \"convert_caoth_mystic\", ERROR_POSITION);\n\n            if (strcmp (input.caoth[isp].name, \"hiddencore_dummy\") == 0)\n              isp_hiddencore = isp;\n\n            if (strcmp (input.caoth[isp].name, \"wc\") == 0)\n              isp_wc3D = isp;\n          }\n        }\n\n        /**\n           Section to find the veiled core. Author: Paul Ockenfuß, Bernhard Mayer\n           Modifies the parameters ext, g1, g2, ssa and ff in the profiles \"wc\" and \"hiddencore_dummy\"\n           Important developer information: Units in caoth3d: ext[...] 1/m; atm.dxcld & atm.dycld in m, atm.zd_common in km!\n           -z-Index=\"0\" means surface in caoth3d.\n           -z-Index=\"0\" means TOA in \"atm\"!\n        */\n        if (input.rte.mc.core_isactive && (iv_count == 0 || output->caoth3d[isp_wc3D].cldproperties == CLD_LWCREFF ||\n                                           output->caoth3d[isp_wc3D].cldproperties == CLD_LWCREFFCF)) {\n          assert (isp_hiddencore >= 0);\n          assert (isp_wc3D >= 0);\n          assert ((output->caoth3d[isp_wc3D]).nthreed > 0);\n          assert ((output->caoth3d[isp_hiddencore]).nthreed > 0);\n          if (!input.quiet)\n            fprintf (stderr, \"Found wc3D; starting to modify core\\n\");\n          int      nx     = (output->caoth3d[isp_wc3D]).Nx;\n          int      ny     = (output->caoth3d[isp_wc3D]).Ny;\n          int      nz     = (output->caoth3d[isp_wc3D]).nlyr;\n          int*     threed = (output->caoth3d[isp_wc3D]).threed;\n          float    dx = output->atm.dxcld, dy = output->atm.dycld;\n          float*** core;\n          float*** distances;\n          if (!(distances = calloc_float_3D (nz, nx, ny, \"distances\")))\n            return -1;\n\n          if (input.rte.mc.core_inputfile) { /*If the user specified the cloud core*/\n            int    core_nx, core_ny, core_nz, core_rows, core_flag = 0, status = 0;\n            double core_dx, core_dy;\n            float* core_dz;\n            status = read_3D_caoth_header (input.rte.mc.core_inputfile,\n                                           &core_nx,\n                                           &core_ny,\n                                           &core_nz,\n                                           &core_flag,\n                                           &core_dx,\n                                           &core_dy,\n                                           &core_dz,\n                                           &core_rows);\n            if (status != 0) {\n              return -1;\n            }\n            if (core_flag != 4) {\n              fprintf (\n                stderr,\n                \"!!Warning: when reading %s, another flag than 4 was found! Is this really a file describing a cloud core?\\n\",\n                input.rte.mc.core_inputfile);\n            }\n            core_dx *= 1000;\n            core_dy *= 1000;\n            if (nx != core_nx || ny != core_ny || dx != core_dx || dy != core_dy) {\n              fprintf (stderr,\n                       \"Error when reading core profile %s: The horizontal grid of the core must be the same as in wc_file 3D!\\n\",\n                       input.rte.mc.core_inputfile);\n              return -1;\n            }\n            float*** column4;\n            int*     core_threed = calloc (core_nz, sizeof (int));\n            if (!(column4 = calloc_float_3D (core_nz, core_nx, core_ny, \"column4\")))\n              return -1;\n            int* indz = calloc (core_rows - 2, sizeof (int));\n            status    = read_3D_caoth_data (input.rte.mc.core_inputfile,\n                                         core_nx,\n                                         core_ny,\n                                         core_nz,\n                                         core_rows,\n                                         &column4,\n                                         NULL,\n                                         NULL,\n                                         NULL,\n                                         NULL,\n                                         indz);\n            if (status != 0) {\n              return -1;\n            }\n            for (size_t i = 0; i < core_rows - 2; i++) {\n              core_threed[indz[i]] = 1;\n            }\n\n            status = redistribute_3D (&column4, nx, ny, core_dz, core_nz, output->atm.zd_common, nz, core_threed, threed, 0);\n            core   = column4;\n\n            free (indz);\n            free (core_threed);\n          } else { /*If the user specified no cloud core, start the corefinder*/\n            if (!(core = calloc_float_3D (nz, nx, ny, \"core\")))\n              return -1;\n            // Initialize array with scattering coefficients from wc3D profile\n            // This profile can contain layers which are not 3D. They are coming from interpolation\n            // to other grids (e.g. ic_file). Therefore, wc scattering is always zero in these layers.\n            arr3d_f* k_scat = calloc3d_float (nx, ny, nz);\n            for (size_t i = 0; i < k_scat->nx; i++) {\n              for (size_t j = 0; j < k_scat->ny; j++) {\n                for (size_t k = 0; k < k_scat->nz; k++) {\n                  if ((output->caoth3d[isp_wc3D]).threed[k])\n                    set3d_f (k_scat,\n                             i,\n                             j,\n                             k,\n                             ((output->caoth3d[isp_wc3D]).ext[k][i][j]) * ((output->caoth3d[isp_wc3D]).ssa[k][i][j]));\n                  else\n                    set3d_f (k_scat, i, j, k, 0.0);\n                }\n              }\n            }\n            //calculate layer distances in atmosphere\n            float* deltaz = malloc (k_scat->nz * sizeof (float));\n            for (size_t i = 0; i < k_scat->nz; i++)\n              deltaz[i] =\n                1000 * (output->atm.zd_common[k_scat->nz - i - 1] - output->atm.zd_common[k_scat->nz - i]);  //convert to meters\n\n            // Calculate starting points for the corefinder: every specified zout-level will create one xy-layer of starting points\n            // Notebook entry 21\n            size_t  total_starts = output->atm.nzout_user * k_scat->nx * k_scat->ny;\n            size_t* xstart       = calloc (total_starts, sizeof (size_t));\n            size_t* ystart       = calloc (total_starts, sizeof (size_t));\n            size_t* zstart       = calloc (total_starts, sizeof (size_t));\n            size_t* z_index      = calloc (output->atm.nzout_user, sizeof (size_t));\n\n            int iz_index = 0;\n            int kc       = 0;\n            for (kc = 0; kc < (output->caoth3d[isp_wc3D]).nlyr; kc++)\n              if (output->mc.sample.sample[kc])\n                z_index[iz_index++] = kc;\n\n            // At TOA, the first layer below TOA is used for starting points\n            if (output->mc.sample.sample[kc])\n              z_index[iz_index++] = kc - 1;\n\n            if (!input.quiet) {\n              fprintf (stderr, \"Corefinder starting points:\\n\");\n              for (size_t i = 0; i < output->atm.nzout_user; i++)\n                fprintf (stderr, \"%d\\n\", (int)z_index[i]);\n            }\n\n            // consistency check\n            if (iz_index != output->atm.nzout_user) {\n              fprintf (stderr, \"Error, number of output levels not matching in corefinder\\n\");\n              return -1;\n            }\n\n            for (size_t k = 0; k < output->atm.nzout_user; k++)\n              for (size_t j = 0; j < k_scat->ny; j++)\n                for (size_t i = 0; i < k_scat->nx; i++) {\n                  xstart[k * k_scat->ny * k_scat->nx + j * k_scat->nx + i] = i;\n                  ystart[k * k_scat->ny * k_scat->nx + j * k_scat->nx + i] = j;\n                  zstart[k * k_scat->ny * k_scat->nx + j * k_scat->nx + i] = z_index[k];\n                }\n\n            //Start to find the core\n            arr3d_i* core_linarray = calloc3d_int (k_scat->nx, k_scat->ny, k_scat->nz);\n            if (!input.quiet)\n              fprintf (stderr, \"...start finding core. Threshold: %.2f\\n\", input.rte.mc.core_threshold);\n            arr3d_f* distances_linarray =\n              get_distances2 (*k_scat, dx, dy, deltaz, xstart, ystart, zstart, total_starts, input.rte.mc.core_threshold);\n            black_white_filter (distances_linarray, input.rte.mc.core_threshold, core_linarray);\n\n            for (size_t i = 0; i < nx; i++) {\n              for (size_t j = 0; j < ny; j++) {\n                for (size_t k = 0; k < nz; k++) {\n                  core[k][i][j]      = (float)get3d_i (core_linarray, i, j, k);\n                  distances[k][i][j] = get3d_f (distances_linarray, i, j, k);\n                }\n              }\n            }\n\n            free (xstart);\n            free (ystart);\n            free (zstart);\n            free (z_index);\n            free (deltaz);\n            free3d_float (k_scat);\n            free3d_int (core_linarray);\n            free3d_float (distances_linarray);\n          } /*END Corefinder*/\n\n          //Optionally: Save the core to the file given by input.rte.mc.core_savefile\n          if (input.rte.mc.core_savefile) {\n            if (!input.quiet)\n              fprintf (stderr, \"...saving core to %s\\n\", input.rte.mc.core_savefile);\n\n            FILE* fp;\n            if ((fp = fopen (input.rte.mc.core_savefile, \"w\")) == NULL) {\n              fprintf (stderr, \"Could not open %s!\\n\", input.rte.mc.core_savefile);\n              return -1;\n            }\n            fprintf (fp, \"%d %d %d 4\\n\", nx, ny, nz);\n            fprintf (fp, \"%g %g\", output->atm.dxcld / 1000.0, output->atm.dycld / 1000.0);\n\n            for (size_t i = 0; i < nz + 1; i++)\n              fprintf (fp, \" %g\", output->atm.zd_common[nz - i]);\n            fprintf (fp, \"\\n#IndexX IndexY IndexZ Core Distance\\n\");\n            for (int i = 0; i < nx; i++) {\n              for (int j = 0; j < ny; j++) {\n                for (int k = 0; k < nz; k++) {\n                  if (threed[k]) {\n                    if (core[k][i][j] == 0.0 && input.rte.mc.core_inputfile == NULL) {\n                      fprintf (fp, \"%d\\t%d\\t%d\\t%.1f\\t%g\\n\", i + 1, j + 1, k + 1, core[k][i][j], distances[k][i][j]);\n                    } else {\n                      fprintf (fp, \"%d\\t%d\\t%d\\t%.1f\\tnan\\n\", i + 1, j + 1, k + 1, core[k][i][j]);\n                    }\n                  }\n                  // else //do also print the non-threed (non-cloud) zeros\n                  // {\n                  //   fprintf(fp, \"%d\\t%d\\t%d\\t%.1f\\n\", i + 1, j + 1, k + 1, 0.0);\n                  // }\n                }\n              }\n            }\n            fclose (fp);\n          }\n          //Start to create a delta-scaled profile for the area inside the core\n          if (!input.quiet)\n            fprintf (stderr, \"...start delta scaling core\\n\");\n\n          int counter   = 0;\n          int counter3d = 0;\n          for (size_t k = 0; k < nz; k++) {\n            if (threed[k]) {\n              counter3d++;\n              for (size_t i = 0; i < nx; i++) {\n                for (size_t j = 0; j < ny; j++) {\n                  if (core[k][i][j] > 0.5) {\n                    counter++;\n                    float g         = (output->caoth3d[isp_wc3D]).g1[k][i][j];\n                    float w0        = (output->caoth3d[isp_wc3D]).ssa[k][i][j];\n                    float ext       = (output->caoth3d[isp_wc3D]).ext[k][i][j];\n                    float f_scaling = input.rte.mc.core_scale;\n                    if (f_scaling < 0.0)\n                      f_scaling = g;\n\n                    (output->caoth3d[isp_wc3D]).ext[k][i][j]       = 0.0;\n                    (output->caoth3d[isp_hiddencore]).ext[k][i][j] = (1 - w0 * f_scaling) * ext;\n                    (output->caoth3d[isp_hiddencore]).ssa[k][i][j] = (1 - f_scaling) * w0 / (1 - w0 * f_scaling);\n                    (output->caoth3d[isp_hiddencore]).g1[k][i][j]  = (g - f_scaling) / (1 - f_scaling);\n                    (output->caoth3d[isp_hiddencore]).g2[k][i][j]  = 0.0;\n                    (output->caoth3d[isp_hiddencore]).ff[k][i][j]  = 0.0;\n                  } else {\n                    (output->caoth3d[isp_hiddencore]).ext[k][i][j] = 0.0;\n                  }\n                }\n              }\n            }\n          }\n\n          if (!input.quiet)\n            fprintf (stderr,\n                     \"scaled %d pixels of %d 3d pixels! (%.2f%%)\\n\",\n                     counter,\n                     counter3d * nx * ny,\n                     100 * counter / ((float)counter3d * nx * ny));\n\n          free_float_3D (core);\n          free_float_3D (distances);\n        } /* End Section to find hidden core */\n      }\n\n      /********************************/\n      /* loop over independent pixels */\n      /********************************/\n      for (ipa = 0; ipa < output->nipa; ipa++) {\n        for (iipa = 0; iipa < output->niipa; iipa++) {\n          for (jipa = 0; jipa < output->njipa; jipa++) {\n\n            if (!input.quiet && (output->niipa > 1 || output->njipa > 1))\n              fprintf (stderr, \" ... ipa loop over iipa=%d, jipa=%d\\n\", iipa, jipa);\n\n            if (input.verbose && output->nipa == 1)\n              fprintf (stderr,\n                       \"\\n\\n*** wavelength: iv = %d, %f nm, albedo = %f \\n\",\n                       iv,\n                       output->wl.lambda_r[iv],\n                       output->alb.albedo_r[iv]);\n\n            if (input.verbose && output->nipa > 1)\n              fprintf (stderr,\n                       \"\\n\\n*** wavelength: iv = %d, %f nm, looking at column %d, albedo = %f\\n\",\n                       iv,\n                       output->wl.lambda_r[iv],\n                       ipa,\n                       output->alb.albedo_r[iv]);\n\n            /* copy pixel number ipa to 1D caoth data, ulrike: allow ipa3d\n\t   (and tipa dir) for caoth */\n            for (isp = 0; isp < input.n_caoth; isp++) {\n              if (input.caoth[isp].ipa || (input.ipa3d && input.caoth[isp].source == CAOTH_FROM_3D)) {\n\n                /* copy everything except the single scattering properties */\n                if (input.caoth[isp].ipa) {\n                  status = cp_caoth_out (&(output->caoth[isp]), output->caoth_ipa[isp][ipa], 0, 0, input.quiet);\n                  if (status)\n                    return fct_err_out (status, \"cp_cld_out\", ERROR_POSITION);\n                }\n\n                if (input.ipa3d) {\n                  if (!input.quiet)\n                    fprintf (stderr, \" ... copying 3d to 1d for %s\\n\", output->caoth[isp].fullname);\n\n                  status = cp_caoth3d_out (&(output->caoth[isp]), output->caoth3d[isp], input.quiet, iipa, jipa);\n                  if (status)\n                    return fct_err_out (status, \"cp_caoth3d_out\", ERROR_POSITION);\n\n                  /* copy cloud fraction, if available */\n                  if (output->caoth3d[isp].cldproperties == CLD_LWCREFFCF) {\n                    if (!input.quiet)\n                      fprintf (stderr, \" ... copying cloud fraction from caoth %d\\n\", isp);\n\n                    /* need to allocate memory for cloud fraction profile? */\n                    if (output->cf.nlev == 0) {\n                      if (!input.quiet)\n                        fprintf (stderr, \" ... allocating memory for cloud fraction profile\\n\");\n\n                      output->cf.nlev = output->atm.nlev - 1;\n                      output->cf.zd   = calloc (output->cf.nlev, sizeof (float));\n                      output->cf.cf   = calloc (output->cf.nlev, sizeof (float));\n\n                      for (lu = 0; lu < output->cf.nlev; lu++)\n                        output->cf.zd[lu] = output->atm.zd[lu];\n                    }\n\n                    status = cp_caoth3d_cf_out (output->cf.cf, output->caoth3d[isp], input.quiet, iipa, jipa);\n                    if (status)\n                      return fct_err_out (status, \"cp_caoth3d_cf_out\", ERROR_POSITION);\n                  }\n                }\n\n#if HAVE_TIPA\n                if (input.tipa == TIPA_DIR) { /* ulrike: calculate tilted dtau for caoth */\n                  status = tipa_calcdtau (input.caoth[isp],\n                                          output->caoth3d[isp],\n                                          iipa,\n                                          jipa,\n                                          iv,\n                                          input,\n                                          output->wl,\n                                          &(output->caoth[isp]),\n                                          &(output->caoth[isp].tipa));\n                  if (status)\n                    return fct_err_out (status, \"tipa_calcdtau\", ERROR_POSITION);\n                }\n#endif\n\n                /* calculate optical properties for the caoth properties\n\t       specified in the input-file (ulrike) */\n                status = caoth_prop_switch (input, input.caoth[isp], output->wl, iv, &(output->caoth[isp]));\n                if (status)\n                  return fct_err_out (status, \"caoth_prop_switch\", ERROR_POSITION);\n\n                /* overwrite these properties with user-defined optical thickness, ssa, etc */\n                status = apply_user_defined_properties_to_caoth (input.caoth[isp],\n                                                                 output->wl.nlambda_r,\n                                                                 output->wl.lambda_r,\n                                                                 output->alt.altitude,\n                                                                 &(output->caoth[isp]));\n                if (status)\n                  return fct_err_out (status, \"apply_user_defined_properties_to_cld\", ERROR_POSITION);\n              } /*ulrike: end of \"if (input.caoth[isp].ipa || input.ipa3d)\"*/\n            }   /* end loop isp */\n\n            if (input.rte.solver == SOLVER_TWOMAXRND && output->cf.nlev == 0) {\n              fprintf (stderr, \"Error, rte_solver twomaxrnd makes only sense with cloud_fraction_file\\n\");\n              fprintf (stderr, \"or cloud fraction defined in 3D cloud file.\\n\");\n              return -1;\n            }\n\n            /* ulrike: for testing */\n            /*\t  if (input.tipa==TIPA_DIR) {\n\t   fprintf(stderr,\"\\nThus, for water clouds we have\\n\");\n\t    for (iz=0; iz<(output->wc.tipa.nztilt); iz++)\n\t      {\n\t\tfprintf(stderr,\"\\nAt level= %e km there are totlev[iz=%d]=%d intersection levels\\n\",output->wc.tipa.level[iz],iz,output->wc.tipa.totlev[iz]);\n\t\tfprintf(stderr,\" tipa->taudircld[iv=%d][iz=%d]=%e\\n\",iv,iz,output->wc.tipa.taudircld[iv][iz]);\n\t      }\n\t   fprintf(stderr,\"\\nThus, for ice clouds we have \\n\");\n\t    for (iz=0; iz<(output->ic.tipa.nztilt); iz++)\n\t      {\n\t\tfprintf(stderr,\"\\nAt level= %e km there are totlev[iz=%d]=%d intersection levels\\n\",output->ic.tipa.level[iz],iz,output->ic.tipa.totlev[iz]);\n\t\tfprintf(stderr,\" tipa->taudircld[iv=%d][iz=%d]=%e\\n\",iv,iz,output->ic.tipa.taudircld[iv][iz]);\n\t      }\n\t  }*/\n            /* *************************************************************** */\n\n            if (input.ipa) {\n              /* copy cloud fraction structure, if needed */\n              switch (input.cloud_overlap) {\n              case CLOUD_OVERLAP_MAX:\n              case CLOUD_OVERLAP_MAXRAND: /* target */ /* source */ /* alloc */\n                if (input.rte.solver != SOLVER_TWOMAXRND && input.rte.solver != SOLVER_TWOMAXRND3C &&\n                    input.rte.solver != SOLVER_DYNAMIC_TWOSTREAM) {\n                  status = copy_cloud_fraction (&(output->cf), output->cfipa[ipa], FALSE); /* in cloud.c */\n                  if (status != 0) {\n                    fprintf (stderr, \"Error %d copying output->cfipa[ipa] to output->cf\\n\", status);\n                    return status;\n                  }\n                }\n                /* For (lc=0;lc<output->cf.nlev;lc++) fprintf (stderr, \" %s ipa=%3d lc=%3d %f \\n\", __func__, ipa, lc, output->cf.cf[lc]); */\n                break;\n              case CLOUD_OVERLAP_RAND:\n              case CLOUD_OVERLAP_OFF:\n                /* nothing to do here */\n                break;\n              default:\n                fprintf (stderr,\n                         \"Error, unknown cloud_overlap assumption %d. (line %d, function %s in %s)\\n\",\n                         input.cloud_overlap,\n                         __LINE__,\n                         __func__,\n                         __FILE__);\n                return -1;\n              }\n            }\n\n            /* IPA molecular absorption and aerosols */\n\n            /* these lines also optimise the iq-loop for corr-k schemes, also if there is no ipa */\n            /* CE: with spectral importance sampling number of calculations always corresponds to maximum number of bands  */\n            if (input.ck_scheme == CK_LOWTRAN && !input.rte.mc.spectral_is)\n              output->atm.nq_r[iv] = output->crs_ck.profile[0][iv].ngauss;\n\n            /* If only one subband is used in the LOWTRAN parameterization, */\n            /* the photon weights of the three subbands are added; this is  */\n            /* necessary because the number of subbands changes with        */\n            /* concentration and is therefore not known beforehand.         */\n            /* The correct use of mc_photons_file for LOWTRAN is then       */\n            /* to always distribute the photons over three subbands;        */\n            /* uvspec decides automatically if only one is needed           */\n\n            if (input.ck_scheme == CK_LOWTRAN) {\n              if (output->atm.nq_r[iv] == 1)\n                for (iq = 1; iq < LOWTRAN_MAXINT; iq++)\n                  output->mc_photons_r[iv][0] += output->mc_photons_r[iv][iq];\n              /* fprintf (stderr, \"mc_photons = %f\\n\", output->mc_photons_r[iv][0]); */\n            }\n\n            /*  if (input.verbose) { */\n            /*    fprintf (stderr, \"*** wavelength: iv = %d, %f nm, albedo = %f\\n\", iv, output->wl.lambda_r[iv], output->alb.albedo_r[iv]); */\n            /*    fprintf (stderr, \"    atm.nmom + 1 = %d phase function moments\\n\", output->atm.nmom+1); */\n            /*    fprintf (stderr, \" --------------------------------------------------------------------------------------------\\n\"); */\n            /*    fprintf (stderr, \"   lu |    z[km] |      aerosol      |    water cloud    |    ice cloud      | tau_molecular \\n\"); */\n            /*    fprintf (stderr, \"      |          |        dtau  nmom |        dtau  nmom |        dtau  nmom |               \\n\"); */\n            /*    fprintf (stderr, \" --------------------------------------------------------------------------------------------\\n\"); */\n            /*    for (lu=0; lu<output->atm.nlyr; lu++) */\n            /*      fprintf (stderr, \"%5d | %8.2f | %11.6f %5d | %11.6f %5d | %11.6f %5d | %11.6f \\n\",  */\n            /* \t  lu, output->atm.zd[lu+1], */\n            /* \t  0.0,0, /\\*output->aer.dtau[iv][lu], output->aer.nmom[iv][lu],*\\/ */\n            /* \t  output->wc.optprop.dtau [iv][lu], output->wc.optprop.nmom[iv][lu], */\n            /* \t  output->ic.optprop.dtau [iv][lu], output->ic.optprop.nmom[iv][lu], */\n            /*          output->atm.optprop.tau_molabs_r[lu][iv][0]); */\n            /*      fprintf (stderr, \" ---------------------------------------------------------------------------\\n\"); */\n            /*  } */\n\n            /* need to load data during first call of mystic() for each band/wavelength */\n            mc_loaddata = 1;\n\n            /* reset band integral */\n            reset_rte_output (&rte_outband,\n                              input,\n                              output->atm.nzout,\n                              output->atm.Nxcld,\n                              output->atm.Nycld,\n                              output->atm.Nzcld,\n                              output->mc.sample.Nx,\n                              output->mc.sample.Ny,\n                              output->mc.alis.Nc,\n                              output->mc.alis.nlambda_abs,\n                              output->atm.nlev - 1,\n                              output->atm.threed,\n                              output->mc.sample.passback3D,\n                              output->mc.triangular_surface.N_triangles);\n\n            if (input.raman) {\n              if (ir == 0) {\n                if (input.raman_fast) {\n                  lower_iq_id          = output->wl.nlambda_rte_lower;\n                  output->atm.nq_r[iv] = output->wl.nlambda_rte_upper;\n                } else {\n                  output->atm.nq_r[iv] = output->crs.number_of_ramanwavelengths;\n                }\n                upper_iq_id = output->atm.nq_r[iv];\n              } else if (ir == 1) {\n                output->atm.nq_r[iv] = 1;\n                lower_iq_id          = 0;\n                upper_iq_id          = output->atm.nq_r[iv];\n              }\n            } else {\n              lower_iq_id = 0;\n              upper_iq_id = output->atm.nq_r[iv];\n            }\n\n            /******************************************/\n            /* loop over quadrature points (subbands) */\n            /******************************************/\n            for (iq = lower_iq_id; iq < upper_iq_id; iq++) {\n\n              if (input.verbose && (input.ck_scheme != CK_CRS))\n                fprintf (stderr,\n                         \"\\n*** wavelength: iv = %d, %f nm, looking at column %d, quadrature point nr %d, albedo = %f\\n\",\n                         iv,\n                         output->wl.lambda_r[iv],\n                         ipa,\n                         iq,\n                         output->alb.albedo_r[iv]);\n\n              if (input.verbose && (input.ck_scheme == CK_RAMAN))\n                fprintf (stderr,\n                         \"\\n*** wavelength: iv = %d, %f nm, looking at column %d, quadrature point nr %d, wvl = %f\\n\",\n                         iv,\n                         output->wl.lambda_r[iv],\n                         ipa,\n                         iq,\n                         output->wl.lambda_r[iq]);\n\n              /* set number of photons for this band */\n              if (input.rte.solver == SOLVER_MONTECARLO && !input.rte.mc.spectral_is)\n                output->mc_photons = (long int)(output->mc_photons_r[iv][iq] * (double)input.rte.mc.photons + 0.5);\n              /* run at least MIN_MCPHOTONS for each band */\n              /* no need to increase for backward direct because backward direct is (nearly) exact */\n              if (output->mc.sample.backward != MCBACKWARD_EDIR && output->mc.sample.backward != MCBACKWARD_FDIR) {\n                if (input.rte.mc.minphotons) { /* set by user */\n                  if (output->mc_photons < (long int)input.rte.mc.minphotons)\n                    output->mc_photons = input.rte.mc.minphotons;\n                } else { /* default */\n                  if (output->mc_photons < MIN_MCPHOTONS)\n                    output->mc_photons = MIN_MCPHOTONS;\n                }\n              } else { /* however, we need at least one photon for direct */\n                if (output->mc_photons < 1)\n                  output->mc_photons = 1;\n              }\n              /* For spectral importance sampling, only one wavelength is */\n              /* calculated, therefore no distribution of photons required.  */\n              if (input.rte.mc.spectral_is)\n                output->mc_photons = input.rte.mc.photons;\n\n              if (input.verbose)\n                fprintf (stderr, \" ... ck weight %9.7f\\n\", output->atm.wght_r[iv][iq]);\n\n              /* if the level number of cloud fraction data is more than 0, than ... */\n              if (input.cloud_overlap != CLOUD_OVERLAP_OFF && input.rte.solver != SOLVER_TWOMAXRND &&\n                  input.rte.solver != SOLVER_TWOMAXRND3C && input.rte.solver != SOLVER_DYNAMIC_TWOSTREAM) {\n\n                /* Save optical properties for wavelength iv. This is necessary because averaged optical properties \n\t       are calulated for each subband and put into output->wc.optprop.... */\n                if (iq == 0) {\n\n                  for (lc = 0; lc < output->atm.nlev - 1; lc++) {\n                    if (input.i_wc != -1) {\n                      /* optical depth */\n                      save_cloud->tauw[lc] = output->caoth[input.i_wc].optprop.dtau[iv][lc];\n                      /* asymmetry parameter */\n                      save_cloud->g1d[lc] = output->caoth[input.i_wc].optprop.g1[iv][lc];\n                      save_cloud->g2d[lc] = output->caoth[input.i_wc].optprop.g2[iv][lc];\n                      save_cloud->fd[lc]  = output->caoth[input.i_wc].optprop.ff[iv][lc];\n                      /* single scattering albedo */\n                      save_cloud->ssaw[lc] = output->caoth[input.i_wc].optprop.ssa[iv][lc];\n                    } else {\n                      save_cloud->tauw[lc] = 0.0;\n                      save_cloud->g1d[lc]  = 0.0;\n                      save_cloud->g2d[lc]  = 0.0;\n                      save_cloud->fd[lc]   = 0.0;\n                      save_cloud->ssaw[lc] = 0.0;\n                    }\n\n                    if (input.i_ic != -1) {\n                      /* optical depth */\n                      save_cloud->taui[lc] = output->caoth[input.i_ic].optprop.dtau[iv][lc];\n                      /* asymmetry parameter */\n                      save_cloud->g1i[lc] = output->caoth[input.i_ic].optprop.g1[iv][lc];\n                      save_cloud->g2i[lc] = output->caoth[input.i_ic].optprop.g2[iv][lc];\n                      save_cloud->fi[lc]  = output->caoth[input.i_ic].optprop.ff[iv][lc];\n                      /* single scattering albedo */\n                      save_cloud->ssai[lc] = output->caoth[input.i_ic].optprop.ssa[iv][lc];\n                    } else {\n                      save_cloud->taui[lc] = 0.0;\n                      save_cloud->g1i[lc]  = 0.0;\n                      save_cloud->g2i[lc]  = 0.0;\n                      save_cloud->fi[lc]   = 0.0;\n                      save_cloud->ssai[lc] = 0.0;\n                    }\n                  }\n                }\n\n                /* calculate effective cloud optical properties for fractional cloud cover */\n                status = generate_effective_cloud (input, output, save_cloud, iv, iq, input.verbose); /* in solve_rte.c */\n                CHKERR (status);\n              }\n\n              /* 3DAbs include caoth3d for 3D molecular atmosphere, right place here ??? */\n              if (input.rte.solver == SOLVER_MONTECARLO && output->molecular3d)\n                optical_properties_molecular3d (input, output, &(output->caoth3d[CAOTH_FIR]), iv, iq);\n\n              /* setup optical properties and call the RTE solver */\n              status = setup_and_call_solver (input,\n                                              output,\n                                              rte_in,\n                                              rte_out,\n                                              raman_qsrc_components,\n                                              iv,\n                                              iq,\n                                              ir,\n                                              output->atm.threed,\n                                              mc_loaddata);\n\n              CHKERR (status);\n\n              /* verbose output */\n              if (input.verbose) {\n                fprintf (stderr,\n                         \"  iv = %d, %f nm, iq = %d, flux_dir[lu=0] = %13.7e, flux_dn[lu=0] = %13.7e, flux_up[lu=0] = %13.7e, \"\n                         \"weight_r = %13.7e \\n\",\n                         iv,\n                         output->wl.lambda_r[iv],\n                         iq,\n                         rte_out->rfldir[0],\n                         rte_out->rfldn[0],\n                         rte_out->flup[0],\n                         output->atm.wght_r[iv][iq]);\n              }\n\n              /* data need to be loaded only once per iv */\n              mc_loaddata = 0;\n\n              if (input.heating != HEAT_NONE)\n                calc_spectral_heating (input,\n                                       output,\n                                       dz,\n                                       rho_mass_zout,\n                                       k_abs,\n                                       k_abs_layer,\n                                       rte_in->pol.outlevels,\n                                       rte_out,\n                                       rte_out->heat,\n                                       rte_out->emis,\n                                       rte_out->w_zout,\n                                       iv);\n\n              /**********************************************************************/\n              /* Store intensities for later use in second round of raman iteration */\n              /**********************************************************************/\n              if (input.raman) {\n                if (ir == 0) {\n                  if (input.raman_fast) {\n                    for (lu = 0; lu < output->atm.nlyr; lu++)\n                      raman_qsrc_components->dtauc[lu][iq] = (double)output->dtauc[lu];\n                    raman_qsrc_components->fbeam[iq] = rte_in->fbeam;\n                    for (lu = 0; lu < output->atm.nzout; lu++) {\n                      raman_qsrc_components->uavgso[lu][iq] = (double)rte_out->uavgso[lu];\n                      raman_qsrc_components->uavgdn[lu][iq] = (double)rte_out->uavgdn[lu];\n                      raman_qsrc_components->uavgup[lu][iq] = (double)rte_out->uavgup[lu];\n                      raman_qsrc_components->rfldir[lu][iq] = (double)rte_out->rfldir[lu];\n                      raman_qsrc_components->rfldn[lu][iq]  = (double)rte_out->rfldn[lu];\n                      raman_qsrc_components->flup[lu][iq]   = (double)rte_out->flup[lu];\n                      for (iu = 0; iu < input.rte.nstr; iu++) {\n                        raman_qsrc_components->u0u[lu][input.rte.cmuind[iu]][iq] = (double)rte_out->u0u[lu][input.rte.cmuind[iu]];\n                        for (j = 0; j < input.rte.nphi; j++) {\n                          raman_qsrc_components->uu[lu][j][input.rte.cmuind[iu]][iq] =\n                            (double)rte_out->uu[j][lu][input.rte.cmuind[iu]];\n                        }\n                      }\n                      for (iu = 0; iu < input.rte.numu - input.rte.nstr; iu++) {\n                        raman_qsrc_components->u0u[lu][input.rte.umuind[iu]][iq] = (double)rte_out->u0u[lu][input.rte.umuind[iu]];\n                        for (j = 0; j < input.rte.nphi; j++) {\n                          raman_qsrc_components->uu[lu][j][input.rte.umuind[iu]][iq] =\n                            (double)rte_out->uu[j][lu][input.rte.umuind[iu]];\n                        }\n                      }\n                    }\n\n                    for (lu = 0; lu < output->atm.nzout; lu++) {\n                      for (j = 0; j < input.rte.nstr; j++) {\n                        for (iu = 0; iu < input.rte.numu; iu++) {\n                          raman_qsrc_components->uum[lu][j][iu][iq] = (double)rte_out->uum[j][lu][iu];\n                        }\n                      }\n                    }\n                  } else {\n                    raman_qsrc_components->fbeam[iq] = (double)rte_in->fbeam;\n                    if (input.verbose)\n                      fprintf (stderr,\n                               \"Storing Raman quantities for iq: %3d out of %3d.\\n\",\n                               iq,\n                               output->crs.number_of_ramanwavelengths - 1);\n                    if (iq == output->crs.number_of_ramanwavelengths - 1) {\n                      /* Only store radiation for the wanted wavelength which should be at the last index */\n                      for (lu = 0; lu < output->atm.nlyr; lu++)\n                        raman_qsrc_components->dtauc[lu][iq] = (double)output->dtauc[lu];\n                      for (lu = 0; lu < output->atm.nzout; lu++) {\n                        uavgso_raman[lu]    = rte_out->uavgso[lu];\n                        uavgdn_raman[lu]    = rte_out->uavgdn[lu];\n                        uavgup_raman[lu]    = rte_out->uavgup[lu];\n                        rfldir_raman[lu]    = rte_out->rfldir[lu];\n                        rfldn_raman[lu]     = rte_out->rfldn[lu];\n                        flup_raman[lu]      = rte_out->flup[lu];\n                        rte_out->rfldir[lu] = 0;\n                        rte_out->rfldn[lu]  = 0;\n                        rte_out->flup[lu]   = 0;\n                        for (iu = 0; iu < input.rte.nstr; iu++) {\n                          u0u_raman[lu][input.rte.cmuind[iu]] = rte_out->u0u[lu][input.rte.cmuind[iu]];\n                          for (j = 0; j < input.rte.nphi; j++) {\n                            uu_raman[lu][j][input.rte.cmuind[iu]] = rte_out->uu[j][lu][input.rte.cmuind[iu]];\n                          }\n                        }\n                        for (iu = 0; iu < input.rte.numu - input.rte.nstr; iu++) {\n                          u0u_raman[lu][input.rte.umuind[iu]] = rte_out->u0u[lu][input.rte.umuind[iu]];\n                          for (j = 0; j < input.rte.nphi; j++) {\n                            uu_raman[lu][j][input.rte.umuind[iu]] = rte_out->uu[j][lu][input.rte.umuind[iu]];\n                          }\n                        }\n                      }\n                    }\n\n                    /* Store source components at all shifted wavelengths. Store uum for all wavelengths, */\n                    /* including the last index which contains the wanted wavelength                      */\n\n                    for (lu = 0; lu < output->atm.nlyr; lu++)\n                      raman_qsrc_components->dtauc[lu][iq] = (double)output->dtauc[lu];\n                    for (lu = 0; lu < output->atm.nzout; lu++) {\n                      for (j = 0; j < input.rte.nstr; j++) {\n                        for (iu = 0; iu < input.rte.numu; iu++) {\n                          raman_qsrc_components->uum[lu][j][iu][iq] = (double)rte_out->uum[j][lu][iu];\n                        }\n                      }\n                    }\n                  }\n                } else if (ir == 1) {\n\n                  add = 1;\n                  if (input.raman_fast) {\n                    ivr = iv + output->wl.nlambda_rte_lower;\n                    for (lu = 0; lu < output->atm.nzout; lu++) {\n                      rte_out->uavgso[lu] += (double)raman_qsrc_components->uavgso[lu][ivr];\n                      rte_out->uavgup[lu] += (double)raman_qsrc_components->uavgup[lu][ivr];\n                      rte_out->uavgdn[lu] += (double)raman_qsrc_components->uavgdn[lu][ivr];\n                      rte_out->rfldir[lu] += (double)raman_qsrc_components->rfldir[lu][ivr];\n                      rte_out->rfldn[lu] += (double)raman_qsrc_components->rfldn[lu][ivr];\n                      rte_out->flup[lu] += (double)raman_qsrc_components->flup[lu][ivr];\n                      for (iu = 0; iu < input.rte.nstr; iu++) {\n                        rte_out->u0u[lu][input.rte.cmuind[iu]] += (double)raman_qsrc_components->u0u[lu][input.rte.cmuind[iu]][ivr];\n                        for (j = 0; j < input.rte.nphi; j++) {\n                          rte_out->uu[j][lu][input.rte.cmuind[iu]] +=\n                            (double)raman_qsrc_components->uu[lu][j][input.rte.cmuind[iu]][ivr];\n                        }\n                      }\n                      for (iu = 0; iu < input.rte.numu - input.rte.nstr; iu++) {\n                        rte_out->u0u[lu][input.rte.umuind[iu]] += (double)raman_qsrc_components->u0u[lu][input.rte.umuind[iu]][ivr];\n                        for (j = 0; j < input.rte.nphi; j++) {\n                          rte_out->uu[j][lu][input.rte.umuind[iu]] +=\n                            (double)raman_qsrc_components->uu[lu][j][input.rte.umuind[iu]][ivr];\n                        }\n                      }\n                    }\n                  } else {\n                    for (lu = 0; lu < output->atm.nzout; lu++) {\n                      if (add) {\n                        rte_out->uavgso[lu] += uavgso_raman[lu];\n                        rte_out->uavgdn[lu] += uavgdn_raman[lu];\n                        rte_out->uavgup[lu] += uavgup_raman[lu];\n                        rte_out->rfldir[lu] += rfldir_raman[lu];\n                        rte_out->rfldn[lu] += rfldn_raman[lu];\n                        rte_out->flup[lu] += flup_raman[lu];\n                        for (iu = 0; iu < input.rte.nstr; iu++) {\n                          rte_out->u0u[lu][input.rte.cmuind[iu]] += u0u_raman[lu][input.rte.cmuind[iu]];\n                          for (j = 0; j < input.rte.nphi; j++) {\n                            rte_out->uu[j][lu][input.rte.cmuind[iu]] += uu_raman[lu][j][input.rte.cmuind[iu]];\n                          }\n                        }\n                        for (iu = 0; iu < input.rte.numu - input.rte.nstr; iu++) {\n                          rte_out->u0u[lu][input.rte.umuind[iu]] += u0u_raman[lu][input.rte.umuind[iu]];\n                          for (j = 0; j < input.rte.nphi; j++) {\n                            rte_out->uu[j][lu][input.rte.umuind[iu]] += uu_raman[lu][j][input.rte.umuind[iu]];\n                          }\n                        }\n                      }\n                    }\n                  }\n                }\n              }\n\n              /* add result for the current quadrature point considering quadrature weight */\n              if (!input.raman || (input.raman && ir == 0 && iq == output->crs.number_of_ramanwavelengths - 1) ||\n                  (input.raman && ir == 1)) {\n\n                if (input.raman) {\n                  if (ir == 0)\n                    weight = 0;\n                  else if (ir == 1)\n                    weight = 1;\n                } else\n                  weight = output->atm.wght_r[iv][iq];\n\n                if (input.rte.mc.spectral_is)\n                  for (iv_alis = 0; iv_alis < output->mc.alis.nlambda_abs; iv_alis++)\n                    weight_spectral[iv_alis] = output->atm.wght_r[iv_alis][iq];\n\n                status = add_rte_output (rte_outband,\n                                         rte_out,\n                                         weight,\n                                         weight_spectral,\n                                         input,\n                                         output->atm.nzout,\n                                         output->atm.Nxcld,\n                                         output->atm.Nycld,\n                                         output->atm.Nzcld,\n                                         output->mc.alis.Nc,\n                                         output->atm.nlev - 1,\n                                         output->mc.alis.nlambda_abs,\n                                         output->atm.threed,\n                                         output->mc.sample.passback3D,\n                                         output->islower,\n                                         output->isupper,\n                                         output->jslower,\n                                         output->jsupper,\n                                         output->isstep,\n                                         output->jsstep);\n                CHKERR (status);\n              }\n\n            } /* for (iq=0; iq<output->atm.nq_r[iv]; iq++) { ...   == 'loop over quadrature points' */\n\n            /************************************************/\n            /* add result for the current independent pixel */\n            /************************************************/\n\n            if (input.rte.solver == SOLVER_POLRADTRAN) {\n              for (lu = 0; lu < output->atm.nzout; lu++) {\n\n                output->rfldir_r[lu][iv] += output->ipaweight[ipa] * rte_outband->rfldir[lu];\n                output->heat_r[lu][iv] += output->ipaweight[ipa] * rte_outband->heat[lu];\n                output->emis_r[lu][iv] += output->ipaweight[ipa] * rte_outband->emis[lu];\n                output->w_zout_r[lu][iv] += output->ipaweight[ipa] * rte_outband->w_zout[lu];\n\n                for (is = 0; is < input.rte.polradtran[POLRADTRAN_NSTOKES]; is++) {\n\n                  output->up_flux_r[lu][is][iv] += output->ipaweight[ipa] * rte_outband->polradtran_up_flux[lu][is];\n\n                  output->down_flux_r[lu][is][iv] += output->ipaweight[ipa] * rte_outband->polradtran_down_flux[lu][is];\n\n                  for (j = 0; j < input.rte.nphi; j++) {\n                    for (iu = 0; iu < input.rte.numu; iu++) {\n                      output->down_rad_r[lu][j][iu][is][iv] +=\n                        output->ipaweight[ipa] * rte_outband->polradtran_down_rad[lu][j][iu][is];\n                      output->up_rad_r[lu][j][iu][is][iv] += output->ipaweight[ipa] * rte_outband->polradtran_up_rad[lu][j][iu][is];\n                    }\n                  }\n                }\n              }\n            } else if (rte_in->ibcnd) {\n              for (iu = 0; iu < input.rte.numu; iu++) {\n                output->albmed_r[iu][iv] += rte_outband->albmed[iu];\n                output->trnmed_r[iu][iv] += rte_outband->trnmed[iu];\n              }\n            } else {\n              for (lu = 0; lu < output->atm.nzout; lu++) {\n                output->rfldir_r[lu][iv] += output->ipaweight[ipa] * rte_outband->rfldir[lu];\n                output->rfldn_r[lu][iv] += output->ipaweight[ipa] * rte_outband->rfldn[lu];\n                output->flup_r[lu][iv] += output->ipaweight[ipa] * rte_outband->flup[lu];\n                output->uavg_r[lu][iv] += output->ipaweight[ipa] * rte_outband->uavg[lu];\n                output->uavgdn_r[lu][iv] += output->ipaweight[ipa] * rte_outband->uavgdn[lu];\n                output->uavgso_r[lu][iv] += output->ipaweight[ipa] * rte_outband->uavgso[lu];\n                output->uavgup_r[lu][iv] += output->ipaweight[ipa] * rte_outband->uavgup[lu];\n                output->heat_r[lu][iv] += output->ipaweight[ipa] * rte_outband->heat[lu];\n                output->emis_r[lu][iv] += output->ipaweight[ipa] * rte_outband->emis[lu];\n                output->w_zout_r[lu][iv] += output->ipaweight[ipa] * rte_outband->w_zout[lu];\n                output->sslidar_nphot_r[lu][iv] += output->ipaweight[ipa] * rte_outband->sslidar_nphot[lu];\n                output->sslidar_nphot_q_r[lu][iv] += output->ipaweight[ipa] * rte_outband->sslidar_nphot_q[lu];\n                output->sslidar_ratio_r[lu][iv] += output->ipaweight[ipa] * rte_outband->sslidar_ratio[lu];\n\n                /* intensities */\n                for (iu = 0; iu < input.rte.numu; iu++) {\n                  output->u0u_r[lu][iu][iv] += output->ipaweight[ipa] * rte_outband->u0u[lu][iu];\n\n                  for (j = 0; j < input.rte.nphi; j++)\n                    output->uu_r[lu][j][iu][iv] += output->ipaweight[ipa] * rte_outband->uu[j][lu][iu];\n                }\n\n                /* 3D fields */ /* ulrike: I added \"&& input.rte.solver == SOLVER_MONTECARLO\" */\n                if (output->mc.sample.passback3D && input.rte.solver == SOLVER_MONTECARLO) {\n                  for (is = output->islower; is <= output->isupper; is += output->isstep) {\n                    for (js = output->jslower; js <= output->jsupper; js += output->jsstep) {\n\n                      output->rfldir3d_r[lu][is][js][iv] += output->ipaweight[ipa] * rte_outband->rfldir3d[lu][is][js];\n\n                      output->rfldn3d_r[lu][is][js][iv] += output->ipaweight[ipa] * rte_outband->rfldn3d[lu][is][js];\n\n                      output->flup3d_r[lu][is][js][iv] += output->ipaweight[ipa] * rte_outband->flup3d[lu][is][js];\n\n                      output->uavgso3d_r[lu][is][js][iv] += output->ipaweight[ipa] * rte_outband->uavgso3d[lu][is][js];\n\n                      output->uavgdn3d_r[lu][is][js][iv] += output->ipaweight[ipa] * rte_outband->uavgdn3d[lu][is][js];\n\n                      output->uavgup3d_r[lu][is][js][iv] += output->ipaweight[ipa] * rte_outband->uavgup3d[lu][is][js];\n\n                      if (output->mc.sample.spectral_is || output->mc.sample.concentration_is)\n                        for (ic = 0; ic < output->mc.alis.Nc; ic++) {\n                          for (ivs = 0; ivs < output->mc.alis.nlambda_abs; ivs++) {\n                            output->fl3d_is_r[lu][is][js][ic][ivs] +=\n                              output->ipaweight[ipa] * rte_outband->fl3d_is[lu][ic][is][js][ivs];\n                          }\n                        }\n\n                      for (ip = 0; ip < input.rte.mc.nstokes; ip++) {\n                        if (output->mc.sample.spectral_is || output->mc.sample.concentration_is) {\n                          for (ivs = 0; ivs < output->mc.alis.nlambda_abs; ivs++) {\n                            for (ic = 0; ic < output->mc.alis.Nc; ic++) {\n                              output->radiance3d_r[lu][is][js][ip][ic][ivs] +=\n                                output->ipaweight[ipa] * rte_outband->radiance3d_is[lu][ic][is][js][ip][ivs];\n                            }\n                          }\n                        } else\n                          output->radiance3d_r[lu][is][js][ip][0][iv] +=\n                            output->ipaweight[ipa] * rte_outband->radiance3d[lu][is][js][ip];\n                      }\n\n                      if (input.rte.mc.jacobian[DIM_1D]) {\n                        for (isp = 0; isp < input.n_caoth + 2; isp++) {\n                          for (ijac = 0; ijac < 2; ijac++) {\n                            /* scattering and absorption */\n                            for (lc = 0; lc < output->atm.nlyr; lc++) {\n                              output->jacobian_r[lu][is][js][isp][ijac][lc][iv] +=\n                                output->ipaweight[ipa] * rte_outband->jacobian[lu][is][js][isp][ijac][lc];\n                            }\n                          }\n                        }\n                      }\n\n                      if (input.rte.mc.backward.absorption)\n                        output->absback3d_r[lu][is][js][iv] += output->ipaweight[ipa] * rte_outband->absback3d[lu][is][js];\n\n                      /* variances */\n                      if (input.rte.mc.std) {\n\n                        /* variance is weighted with square of weight */\n                        weight2 = output->ipaweight[ipa] * output->ipaweight[ipa];\n\n                        output->rfldir3d_var_r[lu][is][js][iv] += weight2 * rte_outband->rfldir3d_var[lu][is][js];\n\n                        output->rfldn3d_var_r[lu][is][js][iv] += weight2 * rte_outband->rfldn3d_var[lu][is][js];\n\n                        output->flup3d_var_r[lu][is][js][iv] += weight2 * rte_outband->flup3d_var[lu][is][js];\n\n                        output->uavgso3d_var_r[lu][is][js][iv] += weight2 * rte_outband->uavgso3d_var[lu][is][js];\n\n                        output->uavgdn3d_var_r[lu][is][js][iv] += weight2 * rte_outband->uavgdn3d_var[lu][is][js];\n\n                        output->uavgup3d_var_r[lu][is][js][iv] += weight2 * rte_outband->uavgup3d_var[lu][is][js];\n\n                        for (ip = 0; ip < input.rte.mc.nstokes; ip++)\n                          output->radiance3d_var_r[lu][is][js][ip][iv] += weight2 * rte_outband->radiance3d_var[lu][is][js][ip];\n\n                        if (input.rte.mc.backward.absorption)\n                          output->absback3d_var_r[lu][is][js][iv] += weight2 * rte_outband->absback3d_var[lu][is][js];\n                      }\n                    }\n                  }\n                } else if (input.ipa3d) {\n                  /*ulrike: 3d-fields (without _r) are not needed*/\n\n                  /* BM 3.7.2020: removed factor ipaweight[]; see comment above */\n                  output->rfldir3d_r[lu][iipa][jipa][iv] += rte_outband->rfldir[lu];\n                  output->rfldn3d_r[lu][iipa][jipa][iv] += rte_outband->rfldn[lu];\n                  output->flup3d_r[lu][iipa][jipa][iv] += rte_outband->flup[lu];\n                  output->uavgso3d_r[lu][iipa][jipa][iv] += rte_outband->uavgso[lu];\n                  output->uavgdn3d_r[lu][iipa][jipa][iv] += rte_outband->uavgdn[lu];\n                  output->uavgup3d_r[lu][iipa][jipa][iv] += rte_outband->uavgup[lu];\n\n                  /* ulrike: missing: emis, w_zout ????????????? */\n                  /*ulrike: 4.5.2010 use absback3d_r to save the ipa_3d-heating rates!*/\n                  if (input.rte.mc.backward.absorption)\n                    output->absback3d_r[lu][iipa][jipa][iv] += output->ipaweight[ipa] * rte_outband->heat[lu];\n\n                } /*ulrike: end of: else if (input.ipa3d)*/\n              }   /*ulrike: end for-loop over lev lu*/\n\n              /* 3D absorption; ulrike added && input.rte.solver == SOLVER_MONTECARLO */\n              if (output->mc.sample.passback3D && input.rte.mc.absorption != MCFORWARD_ABS_NONE &&\n                  input.rte.solver == SOLVER_MONTECARLO)\n                for (ks = 0; ks < output->atm.Nzcld; ks++)\n                  if (output->atm.threed[ks]) /* only for 3D layers, BM07122005 */\n                    for (is = 0; is < output->atm.Nxcld; is++)\n                      for (js = 0; js < output->atm.Nycld; js++) { /* **CK added bracket  */\n                        output->abs3d_r[ks][is][js][iv] += output->ipaweight[ipa] * rte_outband->abs3d[ks][is][js];\n                        if (input.rte.mc.std) /* **CK added for forward mc_std */\n                          output->abs3d_var_r[ks][is][js][iv] += output->ipaweight[ipa] * rte_outband->abs3d_var[ks][is][js];\n                      }\n\n            } /* endof of if(input.rte.solver == SOLVER_POLRADTRAN) elsif {rte_in->ibcnd} else {} */\n\n            if (rte_outband->triangle_results) {  // Add triangle result -> output->result\n              const double factor = output->ipaweight[ipa];\n              status = add_triangular_surface_result (factor, rte_outband->triangle_results, output->triangle_results_r[iv]);\n              CHKERR (status);\n            }\n\n            /* verbose output */\n            if (input.verbose) {\n              fprintf (stderr,\n                       \"  iv = %d, %f nm, sum iq, flux_dir[lu=0] = %13.7e, flux_dn[lu=0] = %13.7e, flux_up[lu=0] = %13.7e \\n\",\n                       iv,\n                       output->wl.lambda_r[iv],\n                       output->rfldir_r[0][iv],\n                       output->rfldn_r[0][iv],\n                       output->flup_r[0][iv]);\n            }\n          } /* for (jipa=0; ipa<output->njipa; jipa++) independent pixel (ulrike) */\n        }   /* for (iipa=0; ipa<output->niipa; iipa++) independent pixel (ulrike) */\n      }     /* for (ipa=0; ipa<output->nipa; ipa++) independent pixel */\n\n      /* change unit of the solar spectrum [e.g. W/(m2 nm)] or terrestral spectrum [e.g. W/(m2 cm-1)]  */\n      /* to output units wanted by the user: 'output per_nm', 'output per_cm', or 'output per_band' */\n      /* but only, when dealing with unit (not transmission or reflectivity).                          */\n      /* Unit conversion must happen before interpolate transmittance, as some unit conversions        */\n      /* use the internal thermal bandwidths or correlated-k bandwidth.                                */\n      /* UH 2006-03                                                                                    */\n\n      if (output->wl.use_reptran)\n        unit_factor = 1; /* conversion is done in internal_to_transmittance_grid() */\n      else\n        unit_factor = get_unit_factor (input, output, iv);\n\n      if (unit_factor <= 0) {\n        fprintf (stderr, \"Error, calculating unit_factor = %f in %s (%s)\\n\", unit_factor, function_name, file_name);\n        return -1;\n      }\n\n      switch (input.source) {\n      case SRC_THERMAL:\n        ffactor = unit_factor;\n        rfactor = unit_factor;\n        break;\n\n      case SRC_SOLAR:\n      case SRC_BLITZ: /* BCA */\n      case SRC_LIDAR: /* BCA */\n        switch (input.processing) {\n        case PROCESS_INT:\n        case PROCESS_SUM:\n        case PROCESS_RGB:\n        case PROCESS_RGBNORM:\n          ffactor = unit_factor;\n          rfactor = unit_factor;\n          break;\n\n        case PROCESS_NONE:\n        case PROCESS_RAMAN:\n          switch (input.calibration) {\n          case OUTCAL_ABSOLUTE:\n            ffactor = unit_factor;\n            rfactor = unit_factor;\n            break;\n\n          case OUTCAL_TRANSMITTANCE:\n            ffactor = 1.0;\n            rfactor = 1.0;\n            break;\n\n          case OUTCAL_REFLECTIVITY:\n            ffactor = 1.0;\n            rfactor = 1.0;\n            break;\n\n          default:\n            fprintf (stderr, \"Error, unknown output calibration %d\\n\", input.calibration);\n            return -1;\n          }\n\n          break;\n\n        default:\n          fprintf (stderr, \"Error, unknown output processing %d\\n\", input.processing);\n          return -1;\n        }\n\n        break;\n\n      default:\n        fprintf (stderr, \"Error, unknown source %d\\n\", input.source);\n        return -1;\n      }\n\n      hfactor = unit_factor;\n\n      /*****************************************************************************************/\n      /* now scale irradiances with ffactor, radiances with rfactor, heating rate with hfactor */\n      /*****************************************************************************************/\n      status = scale_output (input,\n                             &(output->rfldir_r),\n                             &(output->rfldn_r),\n                             &(output->flup_r),\n                             &(output->albmed_r),\n                             &(output->trnmed_r),\n                             &(output->uavgso_r),\n                             &(output->uavgdn_r),\n                             &(output->uavgup_r),\n                             &(output->uavg_r),\n                             &(output->u0u_r),\n                             &(output->uu_r),\n                             &(output->heat_r),\n                             &(output->emis_r),\n                             &(output->w_zout_r),\n                             &(output->down_flux_r),\n                             &(output->up_flux_r),\n                             &(output->down_rad_r),\n                             &(output->up_rad_r),\n                             &(output->rfldir3d_r),\n                             &(output->rfldn3d_r),\n                             &(output->flup3d_r),\n                             &(output->fl3d_is_r),\n                             &(output->uavgso3d_r),\n                             &(output->uavgdn3d_r),\n                             &(output->uavgup3d_r),\n                             &(output->radiance3d_r),\n                             &(output->jacobian_r),\n                             &(output->absback3d_r),\n                             &(output->rfldir3d_var_r),\n                             &(output->rfldn3d_var_r),\n                             &(output->flup3d_var_r),\n                             &(output->uavgso3d_var_r),\n                             &(output->uavgdn3d_var_r),\n                             &(output->uavgup3d_var_r),\n                             &(output->radiance3d_var_r),\n                             &(output->abs3d_var_r),\n                             &(output->absback3d_var_r),\n                             output->atm.nzout,\n                             output->atm.Nxcld,\n                             output->atm.Nycld,\n                             output->atm.Nzcld,\n                             output->mc.alis.Nc,\n                             output->atm.nlev - 1,\n                             output->atm.threed,\n                             output->mc.sample.passback3D,\n                             output->islower,\n                             output->isupper,\n                             output->jslower,\n                             output->jsupper,\n                             output->isstep,\n                             output->jsstep,\n                             &(output->abs3d_r),\n                             output->triangle_results_r,\n                             ffactor,\n                             rfactor,\n                             hfactor,\n                             iv);\n      /* in ancillary.c */ /* **CK added  &(output->abs3d_var_r), for forward mc_std  */\n      CHKERR (status);\n\n      /* free 3D cloud properties */\n      if (input.rte.solver == SOLVER_MONTECARLO)\n        for (isp = 0; isp < input.n_caoth; isp++) {\n          status = free_caoth_mystic (input.caoth[isp].properties, &(output->caoth3d[isp]));\n          CHKERR (status);\n        }\n    } /*   for (ir=0; ir<nr; ir++) */\n    iv_count++;\n\n  } /* for (iv=output->wl.nlambda_rte_lower; iv<=output->wl.nlambda_rte_upper; iv++) */\n\n  /* ulrike: free msorted and zsorted (for tipa dir!!! for tipa\n             dirdiff msorted is freed already),\n             output->(w/i)c.tipa.taudircld, ... */\n  if (input.tipa == TIPA_DIR || input.rte.mc.tipa == TIPA_DIR) {\n    for (isp = 0; isp < input.n_caoth; isp++)\n      if (input.caoth[isp].source == CAOTH_FROM_3D) {\n        /* free m-and z-sorted for caoth */\n        for (iz = 0; iz < (output->caoth[isp].tipa.nztilt); iz++) {\n          for (ks = 0; ks < (output->caoth[isp].tipa.totlev[iz]); ks++)\n            free ((output->caoth[isp].tipa.msorted)[iz][ks]);\n          free ((output->caoth[isp].tipa.msorted)[iz]);\n          free ((output->caoth[isp].tipa.zsorted)[iz]);\n        }\n        free (output->caoth[isp].tipa.msorted);\n        free (output->caoth[isp].tipa.zsorted);\n\n        for (js = 0; js < (upper_wl_id - lower_wl_id + 1); js++) /* free taudircld for wc */\n          free ((output->caoth[isp].tipa.taudircld)[js]);\n        free (output->caoth[isp].tipa.taudircld);\n      }\n  }\n\n  /* free temporary memory */\n\n  status = free_rte_output (rte_out,\n                            input,\n                            output->atm.nzout,\n                            output->atm.Nxcld,\n                            output->atm.Nycld,\n                            output->atm.Nzcld,\n                            output->mc.sample.Nx,\n                            output->mc.sample.Ny,\n                            output->mc.alis.Nc,\n                            output->atm.nlyr - 1,\n                            output->mc.alis.nlambda_abs,\n                            output->atm.threed,\n                            output->mc.sample.passback3D);\n  CHKERR (status);\n\n  status = free_rte_output (rte_outband,\n                            input,\n                            output->atm.nzout,\n                            output->atm.Nxcld,\n                            output->atm.Nycld,\n                            output->atm.Nzcld,\n                            output->mc.sample.Nx,\n                            output->mc.sample.Ny,\n                            output->mc.alis.Nc,\n                            output->atm.nlyr - 1,\n                            output->mc.alis.nlambda_abs,\n                            output->atm.threed,\n                            output->mc.sample.passback3D);\n  CHKERR (status);\n\n  if (input.rte.solver == SOLVER_POLRADTRAN) {\n    free (rte_in->pol.height);\n    free (rte_in->pol.temperatures);\n    free (rte_in->pol.gas_extinct);\n  }\n  free (rte_in->pol.outlevels);\n  free (rte_in->hl);\n  free (rte_in->utau);\n  free (rte_in);\n  if (input.rte.solver == SOLVER_DISORT && input.raman) {\n    if (uu_raman != NULL)\n      ASCII_free_double_3D (uu_raman, output->atm.nzout, input.rte.nphi);\n    ASCII_free_double (u0u_raman, output->atm.nzout);\n    free (uavgso_raman);\n    free (uavgdn_raman);\n    free (uavgup_raman);\n    free (rfldir_raman);\n    free (rfldn_raman);\n    free (flup_raman);\n  }\n\n  if (input.raman) {\n    free_raman_qsrc_components (raman_qsrc_components,\n                                input.raman_fast,\n                                output->atm.nzout,\n                                input.rte.maxumu,\n                                input.rte.nphi,\n                                input.rte.nstr);\n  }\n\n  if (input.heating != HEAT_NONE) {\n    free (dz);\n    free (k_abs_layer);\n    free (k_abs);\n  }\n\n  if (save_cloud != NULL) {\n    free (save_cloud->tauw);\n    free (save_cloud->taui);\n    free (save_cloud->g1d);\n    free (save_cloud->g2d);\n    free (save_cloud->fd);\n    free (save_cloud->g1i);\n    free (save_cloud->g2i);\n    free (save_cloud->fi);\n    free (save_cloud->ssaw);\n    free (save_cloud->ssai);\n    free (save_cloud);\n  }\n\n#if HAVE_LIBGSL\n#ifdef WRITERANDOMSTATUS\n  if (remove (input.filename[FN_RANDOMSTATUS]) != 0)\n    fprintf (stderr, \"Error deleting randomstatusfile\");\n#endif\n#endif\n\n  return 0;\n}\n\n/* small function to get factor for unit conversion */\ndouble get_unit_factor (input_struct input, output_struct* output, int iv) {\n  double unit_factor = 0.0;\n\n  char function_name[] = \"get_unit_factor\";\n  char file_name[]     = \"solve_rte.c\";\n\n  switch (output->spectrum_unit) {\n  case UNIT_PER_NM:\n    switch (input.output_unit) {\n    case UNIT_PER_NM:\n      unit_factor = 1.0;\n      break;\n    case UNIT_PER_CM_1:\n      /* unit_factor = (lambda/k) */ /* (lambda/k) = (lambda**2) / 1.0e+7 */ /* 1.0e+7 == cm -> nm; */\n      unit_factor = (output->wl.lambda_r[iv] * output->wl.lambda_r[iv]) / 1.0e+7;\n      break;\n    case UNIT_PER_BAND:\n      /* unit_factor = delta_lambda */ /* lambda_max = 1.0e+7 / k_lower;  lambda_min = 1.0e+7 / k_upper */\n      unit_factor = 1.0e+7 / output->wl.wvnmlo_r[iv] - 1.0e+7 / output->wl.wvnmhi_r[iv];\n      break;\n    case UNIT_NOT_DEFINED:\n      unit_factor = 1.0;\n      break;\n    default:\n      fprintf (stderr,\n               \"Error: Program bug, unsupported output unit %d in %s (%s). \\n\",\n               input.output_unit,\n               function_name,\n               file_name);\n      return -1;\n    }\n    break;\n  case UNIT_PER_CM_1:\n    switch (input.output_unit) {\n    case UNIT_PER_NM:\n      /* unit_factor = (k/lambda) */ /* (k/lambda)= 1.0e+7 / (lambda**2) */ /* 1.0e+7 == cm -> nm; */\n      /* k wavenumber in 1/cm**-1, lambda in nm */\n      unit_factor = 1.0e+7 / (output->wl.lambda_r[iv] * output->wl.lambda_r[iv]);\n      break;\n    case UNIT_PER_CM_1:\n      unit_factor = 1.0;\n      break;\n    case UNIT_PER_BAND:\n      /* unit_factor = delta_k */\n      unit_factor = output->wl.wvnmhi_r[iv] - output->wl.wvnmlo_r[iv];\n      break;\n    case UNIT_NOT_DEFINED:\n      unit_factor = 1.0;\n      break;\n    default:\n      fprintf (stderr,\n               \"Error: Program bug, unsupported output unit %d in %s (%s). \\n\",\n               input.output_unit,\n               function_name,\n               file_name);\n      return -1;\n    }\n    break;\n  case UNIT_PER_BAND:\n    switch (input.output_unit) {\n    case UNIT_PER_NM:\n      /* unit_factor = 1 / delta_lambda */ /* lambda_max = 1.0e+7 / k_lower;  lambda_min = 1.0e+7 / k_upper */\n      unit_factor = 1.0 / (1.0e7 / output->wl.wvnmlo_r[iv] - 1.0e7 / output->wl.wvnmhi_r[iv]);\n      break;\n    case UNIT_PER_CM_1:\n      /* unit_factor = 1 / delta_k */\n      unit_factor = 1.0 / (output->wl.wvnmhi_r[iv] - output->wl.wvnmlo_r[iv]);\n      break;\n    case UNIT_PER_BAND:\n      unit_factor = 1.0;\n      break;\n    case UNIT_NOT_DEFINED: /* not defined */\n      unit_factor = 1.0;\n      break;\n    default:\n      fprintf (stderr, \"Error, program bug, unsupported output unit %d\\n\", input.output_unit);\n      return -1;\n    }\n    break;\n  case UNIT_NOT_DEFINED:\n    switch (input.output_unit) {\n    case UNIT_PER_NM:\n    case UNIT_PER_CM_1:\n    case UNIT_PER_BAND:\n      fprintf (stderr, \"Error, can not convert undefined solar spectrum to output with units\\n\");\n      fprintf (stderr, \"       please use 'solar_file filename unit' in order to specify the unit of the spectrum\\n\");\n      return -1;\n      break;\n    case UNIT_NOT_DEFINED: /* not defined */\n      unit_factor = 1.0;\n      break;\n    default:\n      fprintf (stderr, \"Error, program bug, unsupported output unit %d\\n\", input.output_unit);\n      return -1;\n    }\n    break;\n  default:\n    fprintf (stderr, \"Error: Program bug, unsupported unit of solar_file %d\\n\", output->spectrum_unit);\n    return -1;\n  }\n\n  return unit_factor;\n}\n\nint setup_result (input_struct   input,\n                  output_struct* output,\n                  float**        p_dz,\n                  double**       p_rho_mass_zout,\n                  float**        p_k_abs_layer,\n                  float**        p_k_abs,\n                  float**        p_k_abs_outband) {\n  int status  = 0;\n  int nlambda = 0;\n  int lc = 0, lu = 0, is = 0, js = 0, ip = 0, ic = 0;\n\n  /* FIX 3DAbs need to be initialized when aerosol is not set up, now redundant ??? */\n  /* output->mc.alis.Nc=1; */\n\n  if ((status = ASCII_calloc_float (&output->flup_r, output->atm.nzout, output->wl.nlambda_r)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->rfldir_r, output->atm.nzout, output->wl.nlambda_r)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->rfldn_r, output->atm.nzout, output->wl.nlambda_r)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->uavg_r, output->atm.nzout, output->wl.nlambda_r)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->uavgdn_r, output->atm.nzout, output->wl.nlambda_r)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->uavgso_r, output->atm.nzout, output->wl.nlambda_r)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->uavgup_r, output->atm.nzout, output->wl.nlambda_r)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->heat_r, output->atm.nzout, output->wl.nlambda_r)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->emis_r, output->atm.nzout, output->wl.nlambda_r)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->w_zout_r, output->atm.nzout, output->wl.nlambda_r)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->sslidar_nphot_r, output->atm.nzout, output->wl.nlambda_r)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->sslidar_nphot_q_r, output->atm.nzout, output->wl.nlambda_r)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->sslidar_ratio_r, output->atm.nzout, output->wl.nlambda_r)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->albmed_r, input.rte.numu, output->wl.nlambda_r)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->trnmed_r, input.rte.numu, output->wl.nlambda_r)) != 0)\n    return status;\n\n  /* variables in order to calculate heating rates (by actinic flux) */\n  if (input.heating != HEAT_NONE) {\n\n    *p_dz = calloc (output->atm.nlyr, sizeof (float)); /* dz in m for all (nlyr) layers */\n    CHKPOINTER (*p_dz);\n\n    /* Initialisation */\n    for (lc = 0; lc < output->atm.nlyr; lc++) {\n      (*p_dz)[lc] = (output->atm.zd[lc] - output->atm.zd[lc + 1]) * 1000.0; /* km -> m */\n    }\n\n    *p_rho_mass_zout = calloc (output->atm.nzout, sizeof (double));\n    CHKPOINTER (*p_rho_mass_zout);\n\n    *p_k_abs_layer = calloc (output->atm.nlyr, sizeof (float));\n    CHKPOINTER (*p_k_abs_layer);\n\n    *p_k_abs = calloc (output->atm.nzout, sizeof (float));\n    CHKPOINTER (*p_k_abs);\n\n    *p_k_abs_outband = calloc (output->atm.nzout, sizeof (float));\n    CHKPOINTER (*p_k_abs_outband);\n  }\n\n  if (input.rte.numu > 0) {\n    status = ASCII_calloc_float_3D (&output->u0u_r, output->atm.nzout, input.rte.numu, output->wl.nlambda_r);\n    CHKERR (status);\n  }\n\n  if (input.rte.numu > 0 && input.rte.nphi > 0) {\n    status = ASCII_calloc_float_4D (&output->uu_r, output->atm.nzout, input.rte.nphi, input.rte.numu, output->wl.nlambda_r);\n    CHKERR (status);\n  }\n\n  if (output->mc.sample.passback3D) {\n\n    if (!input.quiet)\n      fprintf (stderr,\n               \" ... allocating %d x %d x %d x %d = %d pixels (%d bytes) for 3D output\\n\",\n               output->atm.nzout,\n               (output->isupper - output->islower + 1),\n               (output->jsupper - output->jslower + 1),\n               output->wl.nlambda_r,\n               output->atm.nzout * (output->isupper - output->islower + 1) * (output->jsupper - output->jslower + 1) *\n                 output->wl.nlambda_r,\n               output->atm.nzout * (output->isupper - output->islower + 1) * (output->jsupper - output->jslower + 1) *\n                 output->wl.nlambda_r * (int)sizeof (float));\n\n    /* allocate only output pixels which are actually required  */\n    /* (defined by mc_backward islower jslower isupper jsupper) */\n\n    output->rfldir3d_r   = calloc (output->atm.nzout, sizeof (float***));\n    output->rfldn3d_r    = calloc (output->atm.nzout, sizeof (float***));\n    output->flup3d_r     = calloc (output->atm.nzout, sizeof (float***));\n    output->uavgso3d_r   = calloc (output->atm.nzout, sizeof (float***));\n    output->uavgdn3d_r   = calloc (output->atm.nzout, sizeof (float***));\n    output->uavgup3d_r   = calloc (output->atm.nzout, sizeof (float***));\n    output->radiance3d_r = calloc (output->atm.nzout, sizeof (float*****));\n\n    if (input.rte.mc.spectral_is || input.rte.mc.concentration_is)\n      if ((status = ASCII_calloc_float_5D (&output->fl3d_is_r,\n                                           output->atm.nzout,\n                                           output->mc.sample.Nx,\n                                           output->mc.sample.Ny,\n                                           output->mc.alis.Nc,\n                                           output->wl.nlambda_r)) != 0)\n        return status;\n\n    /* So far we allow only 1D output for postprocessing */\n    if (input.rte.mc.jacobian[DIM_1D])\n      if ((status = ASCII_calloc_float_7D (&output->jacobian_r,\n                                           output->atm.nzout,\n                                           1,\n                                           1,\n                                           input.n_caoth + 2,\n                                           2,\n                                           output->atm.nlev - 1,\n                                           output->wl.nlambda_r)) != 0)\n        return status;\n\n    if (input.rte.mc.backward.absorption)\n      output->absback3d_r = calloc (output->atm.nzout, sizeof (float***));\n\n    /* variances */\n    if (input.rte.mc.std) {\n      output->rfldir3d_var_r   = calloc (output->atm.nzout, sizeof (float***));\n      output->rfldn3d_var_r    = calloc (output->atm.nzout, sizeof (float***));\n      output->flup3d_var_r     = calloc (output->atm.nzout, sizeof (float***));\n      output->uavgso3d_var_r   = calloc (output->atm.nzout, sizeof (float***));\n      output->uavgdn3d_var_r   = calloc (output->atm.nzout, sizeof (float***));\n      output->uavgup3d_var_r   = calloc (output->atm.nzout, sizeof (float***));\n      output->radiance3d_var_r = calloc (output->atm.nzout, sizeof (float****));\n\n      if (input.rte.mc.backward.absorption)\n        output->absback3d_var_r = calloc (output->atm.nzout, sizeof (float***));\n    }\n\n    for (lu = 0; lu < output->atm.nzout; lu++) {\n      output->rfldir3d_r[lu]   = calloc (output->mc.sample.Nx, sizeof (float**));\n      output->rfldn3d_r[lu]    = calloc (output->mc.sample.Nx, sizeof (float**));\n      output->flup3d_r[lu]     = calloc (output->mc.sample.Nx, sizeof (float**));\n      output->uavgso3d_r[lu]   = calloc (output->mc.sample.Nx, sizeof (float**));\n      output->uavgdn3d_r[lu]   = calloc (output->mc.sample.Nx, sizeof (float**));\n      output->uavgup3d_r[lu]   = calloc (output->mc.sample.Nx, sizeof (float**));\n      output->radiance3d_r[lu] = calloc (output->mc.sample.Nx, sizeof (float****));\n\n      if (input.rte.mc.backward.absorption)\n        output->absback3d_r[lu] = calloc (output->mc.sample.Nx, sizeof (float**));\n\n      /* variances */\n      if (input.rte.mc.std) {\n        output->rfldir3d_var_r[lu]   = calloc (output->mc.sample.Nx, sizeof (float**));\n        output->rfldn3d_var_r[lu]    = calloc (output->mc.sample.Nx, sizeof (float**));\n        output->flup3d_var_r[lu]     = calloc (output->mc.sample.Nx, sizeof (float**));\n        output->uavgso3d_var_r[lu]   = calloc (output->mc.sample.Nx, sizeof (float**));\n        output->uavgdn3d_var_r[lu]   = calloc (output->mc.sample.Nx, sizeof (float**));\n        output->uavgup3d_var_r[lu]   = calloc (output->mc.sample.Nx, sizeof (float**));\n        output->radiance3d_var_r[lu] = calloc (output->mc.sample.Nx, sizeof (float***));\n\n        if (input.rte.mc.backward.absorption)\n          output->absback3d_var_r[lu] = calloc (output->mc.sample.Nx, sizeof (float**));\n      }\n\n      for (is = output->islower; is <= output->isupper; is += output->isstep) {\n        output->rfldir3d_r[lu][is]   = calloc (output->mc.sample.Ny, sizeof (float*));\n        output->rfldn3d_r[lu][is]    = calloc (output->mc.sample.Ny, sizeof (float*));\n        output->flup3d_r[lu][is]     = calloc (output->mc.sample.Ny, sizeof (float*));\n        output->uavgso3d_r[lu][is]   = calloc (output->mc.sample.Ny, sizeof (float*));\n        output->uavgdn3d_r[lu][is]   = calloc (output->mc.sample.Ny, sizeof (float*));\n        output->uavgup3d_r[lu][is]   = calloc (output->mc.sample.Ny, sizeof (float*));\n        output->radiance3d_r[lu][is] = calloc (output->mc.sample.Ny, sizeof (float***));\n\n        if (input.rte.mc.backward.absorption)\n          output->absback3d_r[lu][is] = calloc (output->mc.sample.Ny, sizeof (float*));\n\n        /* variances */\n        if (input.rte.mc.std) {\n          output->rfldir3d_var_r[lu][is]   = calloc (output->mc.sample.Ny, sizeof (float*));\n          output->rfldn3d_var_r[lu][is]    = calloc (output->mc.sample.Ny, sizeof (float*));\n          output->flup3d_var_r[lu][is]     = calloc (output->mc.sample.Ny, sizeof (float*));\n          output->uavgso3d_var_r[lu][is]   = calloc (output->mc.sample.Ny, sizeof (float*));\n          output->uavgdn3d_var_r[lu][is]   = calloc (output->mc.sample.Ny, sizeof (float*));\n          output->uavgup3d_var_r[lu][is]   = calloc (output->mc.sample.Ny, sizeof (float*));\n          output->radiance3d_var_r[lu][is] = calloc (output->mc.sample.Ny, sizeof (float**));\n\n          if (input.rte.mc.backward.absorption)\n            output->absback3d_var_r[lu][is] = calloc (output->mc.sample.Ny, sizeof (float*));\n        }\n\n        for (js = output->jslower; js <= output->jsupper; js += output->jsstep) {\n          output->rfldir3d_r[lu][is][js]   = calloc (output->wl.nlambda_r, sizeof (float));\n          output->rfldn3d_r[lu][is][js]    = calloc (output->wl.nlambda_r, sizeof (float));\n          output->flup3d_r[lu][is][js]     = calloc (output->wl.nlambda_r, sizeof (float));\n          output->uavgso3d_r[lu][is][js]   = calloc (output->wl.nlambda_r, sizeof (float));\n          output->uavgdn3d_r[lu][is][js]   = calloc (output->wl.nlambda_r, sizeof (float));\n          output->uavgup3d_r[lu][is][js]   = calloc (output->wl.nlambda_r, sizeof (float));\n          output->radiance3d_r[lu][is][js] = calloc (input.rte.mc.nstokes, sizeof (float**));\n\n          for (ip = 0; ip < input.rte.mc.nstokes; ip++) {\n            output->radiance3d_r[lu][is][js][ip] = calloc (output->mc.alis.Nc, sizeof (float*));\n\n            for (ic = 0; ic < output->mc.alis.Nc; ic++)\n              output->radiance3d_r[lu][is][js][ip][ic] = calloc (output->wl.nlambda_r, sizeof (float));\n          }\n\n          if (input.rte.mc.backward.absorption)\n            output->absback3d_r[lu][is][js] = calloc (output->wl.nlambda_r, sizeof (float));\n\n          /* variances */\n          if (input.rte.mc.std) {\n            output->rfldir3d_var_r[lu][is][js]   = calloc (output->wl.nlambda_r, sizeof (float));\n            output->rfldir3d_var_r[lu][is][js]   = calloc (output->wl.nlambda_r, sizeof (float));\n            output->rfldn3d_var_r[lu][is][js]    = calloc (output->wl.nlambda_r, sizeof (float));\n            output->flup3d_var_r[lu][is][js]     = calloc (output->wl.nlambda_r, sizeof (float));\n            output->uavgso3d_var_r[lu][is][js]   = calloc (output->wl.nlambda_r, sizeof (float));\n            output->uavgdn3d_var_r[lu][is][js]   = calloc (output->wl.nlambda_r, sizeof (float));\n            output->uavgup3d_var_r[lu][is][js]   = calloc (output->wl.nlambda_r, sizeof (float));\n            output->radiance3d_var_r[lu][is][js] = calloc (input.rte.mc.nstokes, sizeof (float*));\n\n            for (ip = 0; ip < input.rte.mc.nstokes; ip++)\n              output->radiance3d_var_r[lu][is][js][ip] = calloc (output->wl.nlambda_r, sizeof (float));\n\n            if (input.rte.mc.backward.absorption)\n              output->absback3d_var_r[lu][is][js] = calloc (output->wl.nlambda_r, sizeof (float));\n          }\n        }\n      }\n    }\n\n    /* 3d absorption */\n    if (input.rte.mc.absorption != MCFORWARD_ABS_NONE || input.ipa3d) { /*ulrike: added || input.ipa3d*/ /* **CK added bracket */\n      output->abs3d_r =\n        calloc_spectral_abs3d (output->atm.Nxcld, output->atm.Nycld, output->atm.Nzcld, output->wl.nlambda_r, output->atm.threed);\n      CHKPOINTEROUT (output->abs3d_r, \"Error allocating memory for output->abs3d_r\");\n\n      if (input.rte.mc.std) {\n        output->abs3d_var_r =\n          calloc_spectral_abs3d (output->atm.Nxcld, output->atm.Nycld, output->atm.Nzcld, output->wl.nlambda_r, output->atm.threed);\n        CHKPOINTEROUT (output->abs3d_var_r, \"Error allocating memory for output->abs3d_var_r\");\n      }\n    }\n  }\n\n  /* need to allocate enough memory for both output->wl.nlambda_s */\n  /* and output->wl.nlambda_h, hence using whichever is larger    */\n  nlambda = (output->wl.nlambda_h > output->wl.nlambda_s ? output->wl.nlambda_h : output->wl.nlambda_s);\n\n  if ((status = ASCII_calloc_float (&output->flup, output->atm.nzout, nlambda)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->rfldn, output->atm.nzout, nlambda)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->rfldir, output->atm.nzout, nlambda)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->uavg, output->atm.nzout, nlambda)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->uavgdn, output->atm.nzout, nlambda)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->uavgso, output->atm.nzout, nlambda)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->uavgup, output->atm.nzout, nlambda)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->heat, output->atm.nzout, nlambda)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->emis, output->atm.nzout, nlambda)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->albmed, input.rte.numu, nlambda)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->trnmed, input.rte.numu, nlambda)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float (&output->w_zout, output->atm.nzout, nlambda)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float_3D (&output->down_flux, output->atm.nzout, input.rte.polradtran[POLRADTRAN_NSTOKES], nlambda)) !=\n      0)\n    return status;\n\n  if ((status = ASCII_calloc_float_3D (&output->down_flux_r,\n                                       output->atm.nzout,\n                                       input.rte.polradtran[POLRADTRAN_NSTOKES],\n                                       output->wl.nlambda_r)) != 0)\n    return status;\n\n  if ((status = ASCII_calloc_float_3D (&output->up_flux, output->atm.nzout, input.rte.polradtran[POLRADTRAN_NSTOKES], nlambda)) !=\n      0)\n    return status;\n\n  if ((status = ASCII_calloc_float_3D (&output->up_flux_r,\n                                       output->atm.nzout,\n                                       input.rte.polradtran[POLRADTRAN_NSTOKES],\n                                       output->wl.nlambda_r)) != 0)\n    return status;\n\n  if (input.rte.nphi > 0) {\n    if ((status = ASCII_calloc_float_5D (&output->down_rad,\n                                         output->atm.nzout,\n                                         input.rte.nphi,\n                                         input.rte.numu,\n                                         input.rte.polradtran[POLRADTRAN_NSTOKES],\n                                         nlambda)) != 0)\n      return status;\n\n    if ((status = ASCII_calloc_float_5D (&output->down_rad_r,\n                                         output->atm.nzout,\n                                         input.rte.nphi,\n                                         input.rte.numu,\n                                         input.rte.polradtran[POLRADTRAN_NSTOKES],\n                                         output->wl.nlambda_r)) != 0)\n      return status;\n\n    if ((status = ASCII_calloc_float_5D (&output->up_rad,\n                                         output->atm.nzout,\n                                         input.rte.nphi,\n                                         input.rte.numu,\n                                         input.rte.polradtran[POLRADTRAN_NSTOKES],\n                                         nlambda)) != 0)\n      return status;\n\n    if ((status = ASCII_calloc_float_5D (&output->up_rad_r,\n                                         output->atm.nzout,\n                                         input.rte.nphi,\n                                         input.rte.numu,\n                                         input.rte.polradtran[POLRADTRAN_NSTOKES],\n                                         output->wl.nlambda_r)) != 0)\n      return status;\n  }\n\n  if (input.rte.numu > 0)\n    if ((status = ASCII_calloc_float_3D (&output->u0u, output->atm.nzout, input.rte.numu, nlambda)) != 0)\n      return status;\n\n  if (input.rte.numu > 0 && input.rte.nphi > 0)\n    if ((status = ASCII_calloc_float_4D (&output->uu, output->atm.nzout, input.rte.nphi, input.rte.numu, nlambda)) != 0)\n      return status;\n\n  if ((status = ASCII_calloc_float (&output->sslidar_nphot, output->atm.nzout, nlambda)) != 0)\n    return status;\n  if ((status = ASCII_calloc_float (&output->sslidar_nphot_q, output->atm.nzout, nlambda)) != 0)\n    return status;\n  if ((status = ASCII_calloc_float (&output->sslidar_ratio, output->atm.nzout, nlambda)) != 0)\n    return status;\n\n  if (output->mc.sample.passback3D) {\n\n    /* allocate only output pixels which are actually required  */\n    /* (defined by mc_backward islower jslower isupper jsupper) */\n\n    output->rfldir3d   = calloc (output->atm.nzout, sizeof (float***));\n    output->rfldn3d    = calloc (output->atm.nzout, sizeof (float***));\n    output->flup3d     = calloc (output->atm.nzout, sizeof (float***));\n    output->uavgso3d   = calloc (output->atm.nzout, sizeof (float***));\n    output->uavgdn3d   = calloc (output->atm.nzout, sizeof (float***));\n    output->uavgup3d   = calloc (output->atm.nzout, sizeof (float***));\n    output->radiance3d = calloc (output->atm.nzout, sizeof (float*****));\n\n    if (input.rte.mc.spectral_is || input.rte.mc.concentration_is) {\n      if ((status = ASCII_calloc_float_5D (&output->fl3d_is,\n                                           output->atm.nzout,\n                                           output->mc.sample.Nx,\n                                           output->mc.sample.Ny,\n                                           output->mc.alis.Nc,\n                                           nlambda)) != 0)\n        return status;\n    }\n\n    if (input.rte.mc.jacobian[DIM_1D])\n      if ((status = ASCII_calloc_float_7D (&output->jacobian,\n                                           output->atm.nzout,\n                                           1,\n                                           1,\n                                           input.n_caoth + 2,\n                                           2,\n                                           output->atm.nlev - 1,\n                                           nlambda)) != 0)\n        return status;\n\n    if (input.rte.mc.backward.absorption)\n      output->absback3d = calloc (output->atm.nzout, sizeof (float***));\n\n    /* variances */\n    if (input.rte.mc.std) {\n      output->rfldir3d_var   = calloc (output->atm.nzout, sizeof (float***));\n      output->rfldn3d_var    = calloc (output->atm.nzout, sizeof (float***));\n      output->flup3d_var     = calloc (output->atm.nzout, sizeof (float***));\n      output->uavgso3d_var   = calloc (output->atm.nzout, sizeof (float***));\n      output->uavgdn3d_var   = calloc (output->atm.nzout, sizeof (float***));\n      output->uavgup3d_var   = calloc (output->atm.nzout, sizeof (float***));\n      output->radiance3d_var = calloc (output->atm.nzout, sizeof (float****));\n\n      if (input.rte.mc.backward.absorption)\n        output->absback3d_var = calloc (output->atm.nzout, sizeof (float***));\n    }\n\n    for (lu = 0; lu < output->atm.nzout; lu++) {\n      output->rfldir3d[lu]   = calloc (output->mc.sample.Nx, sizeof (float**));\n      output->rfldn3d[lu]    = calloc (output->mc.sample.Nx, sizeof (float**));\n      output->flup3d[lu]     = calloc (output->mc.sample.Nx, sizeof (float**));\n      output->uavgso3d[lu]   = calloc (output->mc.sample.Nx, sizeof (float**));\n      output->uavgdn3d[lu]   = calloc (output->mc.sample.Nx, sizeof (float**));\n      output->uavgup3d[lu]   = calloc (output->mc.sample.Nx, sizeof (float**));\n      output->radiance3d[lu] = calloc (output->mc.sample.Nx, sizeof (float****));\n\n      if (input.rte.mc.backward.absorption)\n        output->absback3d[lu] = calloc (output->mc.sample.Nx, sizeof (float**));\n\n      /* variances */\n      if (input.rte.mc.std) {\n        output->rfldir3d_var[lu]   = calloc (output->mc.sample.Nx, sizeof (float**));\n        output->rfldn3d_var[lu]    = calloc (output->mc.sample.Nx, sizeof (float**));\n        output->flup3d_var[lu]     = calloc (output->mc.sample.Nx, sizeof (float**));\n        output->uavgso3d_var[lu]   = calloc (output->mc.sample.Nx, sizeof (float**));\n        output->uavgdn3d_var[lu]   = calloc (output->mc.sample.Nx, sizeof (float**));\n        output->uavgup3d_var[lu]   = calloc (output->mc.sample.Nx, sizeof (float**));\n        output->radiance3d_var[lu] = calloc (output->mc.sample.Nx, sizeof (float***));\n\n        if (input.rte.mc.backward.absorption)\n          output->absback3d_var[lu] = calloc (output->mc.sample.Nx, sizeof (float**));\n      }\n\n      for (is = output->islower; is <= output->isupper; is += output->isstep) {\n        output->rfldir3d[lu][is]   = calloc (output->mc.sample.Ny, sizeof (float*));\n        output->rfldn3d[lu][is]    = calloc (output->mc.sample.Ny, sizeof (float*));\n        output->flup3d[lu][is]     = calloc (output->mc.sample.Ny, sizeof (float*));\n        output->uavgso3d[lu][is]   = calloc (output->mc.sample.Ny, sizeof (float*));\n        output->uavgdn3d[lu][is]   = calloc (output->mc.sample.Ny, sizeof (float*));\n        output->uavgup3d[lu][is]   = calloc (output->mc.sample.Ny, sizeof (float*));\n        output->radiance3d[lu][is] = calloc (output->mc.sample.Ny, sizeof (float***));\n\n        if (input.rte.mc.backward.absorption)\n          output->absback3d[lu][is] = calloc (output->mc.sample.Ny, sizeof (float*));\n\n        /* variances */\n        if (input.rte.mc.std) {\n          output->rfldir3d_var[lu][is]   = calloc (output->mc.sample.Ny, sizeof (float*));\n          output->rfldn3d_var[lu][is]    = calloc (output->mc.sample.Ny, sizeof (float*));\n          output->flup3d_var[lu][is]     = calloc (output->mc.sample.Ny, sizeof (float*));\n          output->uavgso3d_var[lu][is]   = calloc (output->mc.sample.Ny, sizeof (float*));\n          output->uavgdn3d_var[lu][is]   = calloc (output->mc.sample.Ny, sizeof (float*));\n          output->uavgup3d_var[lu][is]   = calloc (output->mc.sample.Ny, sizeof (float*));\n          output->radiance3d_var[lu][is] = calloc (output->mc.sample.Ny, sizeof (float**));\n\n          if (input.rte.mc.backward.absorption)\n            output->absback3d_var[lu][is] = calloc (output->mc.sample.Ny, sizeof (float*));\n        }\n\n        for (js = output->jslower; js <= output->jsupper; js += output->jsstep) {\n          output->rfldir3d[lu][is][js]   = calloc (nlambda, sizeof (float));\n          output->rfldn3d[lu][is][js]    = calloc (nlambda, sizeof (float));\n          output->flup3d[lu][is][js]     = calloc (nlambda, sizeof (float));\n          output->uavgso3d[lu][is][js]   = calloc (nlambda, sizeof (float));\n          output->uavgdn3d[lu][is][js]   = calloc (nlambda, sizeof (float));\n          output->uavgup3d[lu][is][js]   = calloc (nlambda, sizeof (float));\n          output->radiance3d[lu][is][js] = calloc (input.rte.mc.nstokes, sizeof (float**));\n\n          for (ip = 0; ip < input.rte.mc.nstokes; ip++) {\n            output->radiance3d[lu][is][js][ip] = calloc (output->mc.alis.Nc, sizeof (float*));\n\n            for (ic = 0; ic < output->mc.alis.Nc; ic++) {\n              output->radiance3d[lu][is][js][ip][ic] = calloc (nlambda, sizeof (float));\n            }\n          }\n\n          if (input.rte.mc.backward.absorption)\n            output->absback3d[lu][is][js] = calloc (nlambda, sizeof (float));\n\n          /* variances */\n          if (input.rte.mc.std) {\n            output->rfldir3d_var[lu][is][js]   = calloc (nlambda, sizeof (float));\n            output->rfldn3d_var[lu][is][js]    = calloc (nlambda, sizeof (float));\n            output->flup3d_var[lu][is][js]     = calloc (nlambda, sizeof (float));\n            output->uavgso3d_var[lu][is][js]   = calloc (nlambda, sizeof (float));\n            output->uavgdn3d_var[lu][is][js]   = calloc (nlambda, sizeof (float));\n            output->uavgup3d_var[lu][is][js]   = calloc (nlambda, sizeof (float));\n            output->radiance3d_var[lu][is][js] = calloc (input.rte.mc.nstokes, sizeof (float*));\n\n            for (ip = 0; ip < input.rte.mc.nstokes; ip++)\n              output->radiance3d_var[lu][is][js][ip] = calloc (nlambda, sizeof (float));\n\n            if (input.rte.mc.backward.absorption)\n              output->absback3d_var[lu][is][js] = calloc (nlambda, sizeof (float));\n          }\n        }\n      }\n    }\n\n    /* 3D absorption */\n    if (input.rte.mc.absorption != MCFORWARD_ABS_NONE || input.ipa3d) {\n      output->abs3d = calloc_spectral_abs3d (output->atm.Nxcld, output->atm.Nycld, output->atm.Nzcld, nlambda, output->atm.threed);\n      CHKPOINTEROUT (output->abs3d, \"Error allocating memory for output->abs3d\");\n\n      if (input.rte.mc.std) {\n        output->abs3d_var =\n          calloc_spectral_abs3d (output->atm.Nxcld, output->atm.Nycld, output->atm.Nzcld, nlambda, output->atm.threed);\n        CHKPOINTEROUT (output->abs3d_var, \"Error allocating memory for output->abs3d_var\");\n      }\n    }\n  }\n\n  output->sza_h = calloc (output->wl.nlambda_h, sizeof (float));\n  CHKPOINTER (output->sza_h);\n\n  {  // allocate triangle output\n    output->triangle_results_r = NULL;\n    output->triangle_results_t = NULL;\n    output->triangle_results_o = NULL;\n\n    const int ierr = init_spectral_triangular_surface_result_struct (output->wl.nlambda_r,\n                                                                     output->mc.triangular_surface.N_triangles,\n                                                                     &(output->triangle_results_r));\n    CHKERR (ierr);\n  }\n\n  return 0;\n} /*ulrike: end of setup_result*/\n\nstatic int reverse_profiles (input_struct input, output_struct* output) {\n  int    lu = 0, iu = 0;\n  double tmp = 0;\n\n  for (lu = 0; lu < output->atm.nlyr / 2; lu++) {\n\n    /* reverse profile of optical depth dtauc */\n    tmp                                      = output->dtauc[output->atm.nlyr - lu - 1];\n    output->dtauc[output->atm.nlyr - lu - 1] = output->dtauc[lu];\n    output->dtauc[lu]                        = tmp;\n\n    /* reverse profile of single scattering albedo ssalb */\n    tmp                                      = output->ssalb[output->atm.nlyr - lu - 1];\n    output->ssalb[output->atm.nlyr - lu - 1] = output->ssalb[lu];\n    output->ssalb[lu]                        = tmp;\n\n    /* reverse profile of phase function pmom */\n    for (iu = 0; iu <= input.rte.nstr; iu++) {\n      tmp                                            = output->pmom[output->atm.nlyr - lu - 1][0][iu];\n      output->pmom[output->atm.nlyr - lu - 1][0][iu] = output->pmom[lu][0][iu];\n      output->pmom[lu][0][iu]                        = tmp;\n    }\n  }\n  return 0;\n}\n\n/* allocate memory for Raman scattering components needed for calculation of */\n/* source function for second iteration                                      */\nraman_qsrc_components* calloc_raman_qsrc_components (int raman_fast, int nzout, int maxumu, int nphi, int nstr, int nlambda) {\n  raman_qsrc_components* result = calloc (1, sizeof (raman_qsrc_components));\n\n  if (raman_fast) {\n    ASCII_calloc_double (&result->uavgso, nzout, nlambda);\n    ASCII_calloc_double (&result->uavgdn, nzout, nlambda);\n    ASCII_calloc_double (&result->uavgup, nzout, nlambda);\n    ASCII_calloc_double (&result->rfldir, nzout, nlambda);\n    ASCII_calloc_double (&result->rfldn, nzout, nlambda);\n    ASCII_calloc_double (&result->flup, nzout, nlambda);\n    ASCII_calloc_double_3D (&result->u0u, nzout, maxumu, nlambda);\n    ASCII_calloc_double_4D (&result->uu, nzout, maxumu, maxumu, nlambda);\n  }\n  result->fbeam = (double*)calloc (nlambda, sizeof (double));\n  ASCII_calloc_double (&result->dtauc, nzout, nlambda);\n  ASCII_calloc_double_4D (&result->uum, nzout, maxumu, maxumu, nlambda);\n\n  return result;\n}\n\n/* free memory for Raman scattering components needed for calculation of */\n/* source function for second iteration                                      */\nstatic void free_raman_qsrc_components (raman_qsrc_components* result, int raman_fast, int nzout, int maxumu, int nphi, int nstr) {\n  if (raman_fast) {\n    if (result->uavgso != NULL)\n      ASCII_free_double (result->uavgso, nzout);\n    if (result->uavgup != NULL)\n      ASCII_free_double (result->uavgup, nzout);\n    if (result->uavgdn != NULL)\n      ASCII_free_double (result->uavgdn, nzout);\n    if (result->rfldir != NULL)\n      ASCII_free_double (result->rfldir, nzout);\n    if (result->rfldn != NULL)\n      ASCII_free_double (result->rfldn, nzout);\n    if (result->flup != NULL)\n      ASCII_free_double (result->flup, nzout);\n    if (result->u0u != NULL)\n      ASCII_free_double_3D (result->u0u, nzout, maxumu);\n    if (result->uu != NULL)\n      ASCII_free_double_4D (result->uu, nzout, maxumu, maxumu);\n  }\n  if (result->fbeam != NULL)\n    free (result->fbeam);\n  if (result->dtauc != NULL)\n    ASCII_free_double (result->dtauc, nzout);\n  if (result->uum != NULL)\n    ASCII_free_double_4D (result->uum, nzout, maxumu, maxumu);\n\n  free (result);\n}\n\n/* allocate temporary memory optical properties */\nstatic save_optprop* calloc_save_optprop (int Nlev) {\n  save_optprop* result = calloc (1, sizeof (save_optprop));\n\n  result->tauw = (float*)calloc (Nlev, sizeof (float));\n  result->taui = (float*)calloc (Nlev, sizeof (float));\n  result->g1d  = (float*)calloc (Nlev, sizeof (float));\n  result->g2d  = (float*)calloc (Nlev, sizeof (float));\n  result->fd   = (float*)calloc (Nlev, sizeof (float));\n  result->g1i  = (float*)calloc (Nlev, sizeof (float));\n  result->g2i  = (float*)calloc (Nlev, sizeof (float));\n  result->fi   = (float*)calloc (Nlev, sizeof (float));\n  result->ssaw = (float*)calloc (Nlev, sizeof (float));\n  result->ssai = (float*)calloc (Nlev, sizeof (float));\n\n  return result;\n}\n\n/* allocate temporary memory for the RTE solvers */\nstatic rte_output* calloc_rte_output (input_struct input,\n                                      int          nzout,\n                                      int          Nxcld,\n                                      int          Nycld,\n                                      int          Nzcld,\n                                      int          Nxsample,\n                                      int          Nysample,\n                                      int          Ncsample,\n                                      int          Nlambda,\n                                      int          Nlyr,\n                                      int*         threed,\n                                      int          passback3D,\n                                      const size_t N_triangles) {\n  int status = 0;\n\n  rte_output* result = calloc (1, sizeof (rte_output));\n\n  result->albmed          = calloc (input.rte.maxumu, sizeof (float));\n  result->trnmed          = calloc (input.rte.maxumu, sizeof (float));\n  result->dfdt            = calloc (nzout, sizeof (float));\n  result->flup            = calloc (nzout, sizeof (float));\n  result->rfldir          = calloc (nzout, sizeof (float));\n  result->rfldn           = calloc (nzout, sizeof (float));\n  result->uavg            = calloc (nzout, sizeof (float));\n  result->uavgdn          = calloc (nzout, sizeof (float));\n  result->uavgso          = calloc (nzout, sizeof (float));\n  result->uavgup          = calloc (nzout, sizeof (float));\n  result->heat            = calloc (nzout, sizeof (float));\n  result->emis            = calloc (nzout, sizeof (float));\n  result->w_zout          = calloc (nzout, sizeof (float));\n  result->sslidar_nphot   = calloc (nzout, sizeof (float));\n  result->sslidar_nphot_q = calloc (nzout, sizeof (float));\n  result->sslidar_ratio   = calloc (nzout, sizeof (float));\n\n  if (input.rte.maxumu > 0)\n    if ((status = ASCII_calloc_float (&(result->u0u), nzout, input.rte.maxumu)) != 0)\n      return NULL;\n\n  if (input.rte.maxphi > 0 && input.rte.maxumu > 0)\n    if ((status = ASCII_calloc_float_3D (&(result->uu), input.rte.maxphi, nzout, input.rte.maxumu)) != 0)\n      return NULL;\n\n  if (input.rte.solver == SOLVER_DISORT && input.raman)\n    if ((status = ASCII_calloc_float_3D (&(result->uum), input.rte.nstr, nzout, input.rte.maxumu)) != 0)\n      return NULL;\n\n  /* PolRadtran-specific */\n  if (input.rte.solver == SOLVER_POLRADTRAN) {\n    result->polradtran_mu_values = (double*)calloc (input.rte.nstr / 2 + input.rte.numu, sizeof (double));\n\n    if ((status = ASCII_calloc_double (&(result->polradtran_up_flux), nzout, input.rte.polradtran[POLRADTRAN_NSTOKES])) != 0)\n      return NULL;\n\n    if ((status = ASCII_calloc_double (&(result->polradtran_down_flux), nzout, input.rte.polradtran[POLRADTRAN_NSTOKES])) != 0)\n      return NULL;\n\n    if ((status = ASCII_calloc_double_4D (&(result->polradtran_up_rad),\n                                          nzout,\n                                          input.rte.nphi,\n                                          input.rte.nstr / 2 + input.rte.numu,\n                                          input.rte.polradtran[POLRADTRAN_NSTOKES])) != 0)\n      return NULL;\n\n    if ((status = ASCII_calloc_double_4D (&(result->polradtran_down_rad),\n                                          nzout,\n                                          input.rte.nphi,\n                                          input.rte.nstr / 2 + input.rte.numu,\n                                          input.rte.polradtran[POLRADTRAN_NSTOKES])) != 0)\n      return NULL;\n\n    if ((status = ASCII_calloc_double_4D (&(result->polradtran_up_rad_q),\n                                          nzout,\n                                          input.rte.polradtran[POLRADTRAN_AZIORDER] + 1,\n                                          input.rte.nstr / 2 + input.rte.numu,\n                                          input.rte.polradtran[POLRADTRAN_NSTOKES])) != 0)\n      return NULL;\n\n    if ((status = ASCII_calloc_double_4D (&(result->polradtran_down_rad_q),\n                                          nzout,\n                                          input.rte.polradtran[POLRADTRAN_AZIORDER] + 1,\n                                          input.rte.nstr / 2 + input.rte.numu,\n                                          input.rte.polradtran[POLRADTRAN_NSTOKES])) != 0)\n      return NULL;\n  }\n\n  /* 3d fields */\n  if (passback3D) {\n\n    status += ASCII_calloc_float_3D (&(result->rfldir3d), nzout, Nxsample, Nysample);\n    status += ASCII_calloc_float_3D (&(result->rfldn3d), nzout, Nxsample, Nysample);\n    status += ASCII_calloc_float_3D (&(result->flup3d), nzout, Nxsample, Nysample);\n    status += ASCII_calloc_float_3D (&(result->uavgso3d), nzout, Nxsample, Nysample);\n    status += ASCII_calloc_float_3D (&(result->uavgdn3d), nzout, Nxsample, Nysample);\n    status += ASCII_calloc_float_3D (&(result->uavgup3d), nzout, Nxsample, Nysample);\n    status += ASCII_calloc_float_4D (&(result->radiance3d), nzout, Nxsample, Nysample, input.rte.mc.nstokes);\n    status += ASCII_calloc_float_6D (&(result->radiance3d_is), nzout, Ncsample, Nxsample, Nysample, input.rte.mc.nstokes, Nlambda);\n\n    if (input.rte.mc.spectral_is || input.rte.mc.concentration_is)\n      status += ASCII_calloc_float_5D (&(result->fl3d_is), nzout, Ncsample, Nxsample, Nysample, Nlambda);\n\n    if (input.rte.mc.jacobian[DIM_1D]) {\n      /* fprintf(stderr, \"calloc jacobian nzout %d  Nxsample %d Nysample %d input.n_caoth %d abs/sca %d Nzcld %d \\n\", nzout, Nxsample, Nysample, input.n_caoth, 2, Nlyr);  */\n      status += ASCII_calloc_float_6D (&(result->jacobian), nzout, 1, 1, input.n_caoth + 2, 2, Nlyr);\n    }\n\n    if (input.rte.mc.backward.absorption)\n      status += ASCII_calloc_float_3D (&(result->absback3d), nzout, Nxsample, Nysample);\n\n    if (input.rte.mc.absorption != MCFORWARD_ABS_NONE || input.ipa3d) /*ulrike: added || input.ipa3d*/\n      if ((result->abs3d = calloc_abs3d (Nxcld, Nycld, Nzcld, threed)) == NULL)\n        return NULL;\n\n    /* variances */\n    if (input.rte.mc.std) {\n\n      status += ASCII_calloc_float_3D (&(result->rfldir3d_var), nzout, Nxsample, Nysample);\n      status += ASCII_calloc_float_3D (&(result->rfldn3d_var), nzout, Nxsample, Nysample);\n      status += ASCII_calloc_float_3D (&(result->flup3d_var), nzout, Nxsample, Nysample);\n      status += ASCII_calloc_float_3D (&(result->uavgso3d_var), nzout, Nxsample, Nysample);\n      status += ASCII_calloc_float_3D (&(result->uavgdn3d_var), nzout, Nxsample, Nysample);\n      status += ASCII_calloc_float_3D (&(result->uavgup3d_var), nzout, Nxsample, Nysample);\n      status += ASCII_calloc_float_4D (&(result->radiance3d_var), nzout, Nxsample, Nysample, input.rte.mc.nstokes);\n\n      if (input.rte.mc.backward.absorption)\n        status += ASCII_calloc_float_3D (&(result->absback3d_var), nzout, Nxsample, Nysample);\n\n      if (input.rte.mc.absorption != MCFORWARD_ABS_NONE)\n        if ((result->abs3d_var = calloc_abs3d (Nxcld, Nycld, Nzcld, threed)) == NULL)\n          return NULL;\n    }\n  }\n\n  result->triangle_results = NULL;\n  status += init_triangular_surface_result_struct (N_triangles, &(result->triangle_results));\n\n  if (status != 0) {\n    fprintf (stderr, \"Error allocating memory for 3D fields\\n\");\n    return NULL;\n  }\n\n  return result;\n}\n\n/* reset rte_output structure */\nstatic int reset_rte_output (rte_output** rte,\n                             input_struct input,\n                             int          nzout,\n                             int          Nxcld,\n                             int          Nycld,\n                             int          Nzcld,\n                             int          Nxsample,\n                             int          Nysample,\n                             int          Ncsample,\n                             int          Nlambda,\n                             int          Nlyr,\n                             int*         threed,\n                             int          passback3D,\n                             const size_t N_triangles) {\n  const int ierr =\n    free_rte_output (*rte, input, nzout, Nxcld, Nycld, Nzcld, Nxsample, Nysample, Ncsample, Nlyr, Nlambda, threed, passback3D);\n  CHKERR (ierr);\n  *rte = calloc_rte_output (input,\n                            nzout,\n                            Nxcld,\n                            Nycld,\n                            Nzcld,\n                            Nxsample,\n                            Nysample,\n                            Ncsample,\n                            Nlambda,\n                            Nlyr,\n                            threed,\n                            passback3D,\n                            N_triangles);\n\n  return 0; /* if o.k. */\n}\n\nstatic int add_rte_output (rte_output*        rte,\n                           const rte_output*  add,\n                           const double       factor,\n                           const double*      factor_spectral,\n                           const input_struct input,\n                           const int          nzout,\n                           const int          Nxcld,\n                           const int          Nycld,\n                           const int          Nzcld,\n                           const int          Nc,\n                           const int          Nlyr,\n                           const int          Nlambda,\n                           const int*         threed,\n                           const int          passback3D,\n                           const int          islower,\n                           const int          isupper,\n                           const int          jslower,\n                           const int          jsupper,\n                           const int          isstep,\n                           const int          jsstep) {\n  const double factor2 = factor * factor;\n\n  for (int lu = 0; lu < nzout; lu++) {\n    rte->rfldir[lu] += factor * add->rfldir[lu];\n    rte->rfldn[lu] += factor * add->rfldn[lu];\n    rte->flup[lu] += factor * add->flup[lu];\n    rte->uavg[lu] += factor * add->uavg[lu];\n    rte->uavgdn[lu] += factor * add->uavgdn[lu];\n    rte->uavgso[lu] += factor * add->uavgso[lu];\n    rte->uavgup[lu] += factor * add->uavgup[lu];\n    rte->dfdt[lu] += factor * add->dfdt[lu];\n    rte->heat[lu] += factor * add->heat[lu];\n    rte->emis[lu] += factor * add->emis[lu];\n    rte->w_zout[lu] += factor * add->w_zout[lu];\n    rte->sslidar_nphot[lu] += factor * add->sslidar_nphot[lu];\n    rte->sslidar_nphot_q[lu] += factor * add->sslidar_nphot_q[lu];\n    rte->sslidar_ratio[lu] += factor * add->sslidar_ratio[lu];\n\n    for (int iu = 0; iu < input.rte.numu; iu++) {\n      rte->u0u[lu][iu] += factor * add->u0u[lu][iu];\n\n      for (int j = 0; j < input.rte.nphi; j++)\n        rte->uu[j][lu][iu] += factor * add->uu[j][lu][iu];\n    }\n  }\n\n  for (int iu = 0; iu < input.rte.numu; iu++) {\n    rte->albmed[iu] += factor * add->albmed[iu];\n    rte->trnmed[iu] += factor * add->trnmed[iu];\n  }\n\n  /* PolRadtran-specific */\n  if (input.rte.solver == SOLVER_POLRADTRAN) {\n    for (int lu = 0; lu < nzout; lu++) {\n      for (int is = 0; is < input.rte.polradtran[POLRADTRAN_NSTOKES]; is++) {\n\n        rte->polradtran_up_flux[lu][is] += factor * add->polradtran_up_flux[lu][is];\n        rte->polradtran_down_flux[lu][is] += factor * add->polradtran_down_flux[lu][is];\n\n        for (int j = 0; j < input.rte.nphi; j++) {\n          for (int iu = 0; iu < input.rte.nstr / 2 + input.rte.numu; iu++) {\n            rte->polradtran_up_rad[lu][j][iu][is] += factor * add->polradtran_up_rad[lu][j][iu][is];\n            rte->polradtran_down_rad[lu][j][iu][is] += factor * add->polradtran_down_rad[lu][j][iu][is];\n          }\n        }\n      }\n    }\n  }\n\n  if (passback3D) {\n    for (int ks = 0; ks < nzout; ks++) {\n      for (int is = islower; is <= isupper; is += isstep) {\n        for (int js = jslower; js <= jsupper; js += jsstep) {\n          rte->rfldir3d[ks][is][js] += factor * add->rfldir3d[ks][is][js];\n          rte->rfldn3d[ks][is][js] += factor * add->rfldn3d[ks][is][js];\n          rte->flup3d[ks][is][js] += factor * add->flup3d[ks][is][js];\n          rte->uavgso3d[ks][is][js] += factor * add->uavgso3d[ks][is][js];\n          rte->uavgdn3d[ks][is][js] += factor * add->uavgdn3d[ks][is][js];\n          rte->uavgup3d[ks][is][js] += factor * add->uavgup3d[ks][is][js];\n          if (input.rte.mc.concentration_is)\n            for (int ic = 0; ic < Nc; ic++)\n              rte->fl3d_is[ks][ic][is][js][0] += factor * add->fl3d_is[ks][ic][is][js][0];\n\n          else if (input.rte.mc.spectral_is)\n            for (int iv_alis = 0; iv_alis < Nlambda; iv_alis++) {\n              rte->fl3d_is[ks][0][is][js][iv_alis] += factor_spectral[iv_alis] * add->fl3d_is[ks][0][is][js][iv_alis];\n            }\n\n          for (int ip = 0; ip < input.rte.mc.nstokes; ip++) {\n            rte->radiance3d[ks][is][js][ip] += factor * add->radiance3d[ks][is][js][ip];\n\n            /* FIXCE spectral and concentration importance sampling together not */\n            /* yet working correctly */\n            if (input.rte.mc.concentration_is)\n              for (int ic = 0; ic < Nc; ic++) {\n                rte->radiance3d_is[ks][ic][is][js][ip][0] += factor * add->radiance3d_is[ks][ic][is][js][ip][0];\n              }\n\n            if (input.rte.mc.spectral_is) {\n              for (int ic = 0; ic < Nc; ic++) {\n                for (int iv_alis = 0; iv_alis < Nlambda; iv_alis++) {\n                  rte->radiance3d_is[ks][ic][is][js][ip][iv_alis] +=\n                    factor_spectral[iv_alis] * add->radiance3d_is[ks][ic][is][js][ip][iv_alis];\n                }\n              }\n            }\n          }\n\n          if (input.rte.mc.backward.absorption)\n            rte->absback3d[ks][is][js] += factor * add->absback3d[ks][is][js];\n\n          /* variances */\n          if (input.rte.mc.std) {\n\n            rte->rfldir3d_var[ks][is][js] += factor2 * add->rfldir3d_var[ks][is][js];\n            rte->rfldn3d_var[ks][is][js] += factor2 * add->rfldn3d_var[ks][is][js];\n            rte->flup3d_var[ks][is][js] += factor2 * add->flup3d_var[ks][is][js];\n            rte->uavgso3d_var[ks][is][js] += factor2 * add->uavgso3d_var[ks][is][js];\n            rte->uavgdn3d_var[ks][is][js] += factor2 * add->uavgdn3d_var[ks][is][js];\n            rte->uavgup3d_var[ks][is][js] += factor2 * add->uavgup3d_var[ks][is][js];\n\n            for (int ip = 0; ip < input.rte.mc.nstokes; ip++)\n              rte->radiance3d_var[ks][is][js][ip] += factor2 * add->radiance3d_var[ks][is][js][ip];\n\n            if (input.rte.mc.backward.absorption)\n              rte->absback3d_var[ks][is][js] += factor2 * add->absback3d_var[ks][is][js];\n          }\n        }\n      }\n    }\n\n    if (input.rte.mc.absorption != MCFORWARD_ABS_NONE)\n      for (int ks = 0; ks < Nzcld; ks++)\n        if (threed[ks]) /* only for 3D layers, BM07122005 */\n          for (int is = 0; is < Nxcld; is++)\n            for (int js = 0; js < Nycld; js++) { /* **CK added bracket */\n              rte->abs3d[ks][is][js] += factor * add->abs3d[ks][is][js];\n              if (input.rte.mc.std) /* **CK added for forward mc_std */\n                rte->abs3d_var[ks][is][js] += factor2 * add->abs3d_var[ks][is][js];\n            }\n  }\n\n  if (rte->triangle_results) {\n    const int ierr = add_triangular_surface_result (factor, add->triangle_results, rte->triangle_results);\n    CHKERR (ierr);\n  }\n\n  return 0; /* if o.k. */\n}\n\n/* free temporary memory for the RTE solvers */\nstatic int free_rte_output (rte_output*  result,\n                            input_struct input,\n                            int          nzout,\n                            int          Nxcld,\n                            int          Nycld,\n                            int          Nzcld,\n                            int          Nxsample,\n                            int          Nysample,\n                            int          Ncsample,\n                            int          Nlyr,\n                            int          Nlambda,\n                            int*         threed,\n                            int          passback3D) {\n  CHKPOINTEROUT (result, \"rte_output cannot be freed, it is not allocated!\");\n\n  free (result->albmed);\n  result->albmed = NULL;\n  free (result->trnmed);\n  result->trnmed = NULL;\n  free (result->dfdt);\n  result->dfdt = NULL;\n  free (result->flup);\n  result->flup = NULL;\n  free (result->rfldir);\n  result->rfldir = NULL;\n  free (result->rfldn);\n  result->rfldn = NULL;\n  free (result->uavg);\n  result->uavg = NULL;\n  free (result->uavgdn);\n  result->uavgdn = NULL;\n  free (result->uavgso);\n  result->uavgso = NULL;\n  free (result->uavgup);\n  result->uavgup = NULL;\n  free (result->heat);\n  result->heat = NULL;\n  free (result->emis);\n  result->emis = NULL;\n  free (result->w_zout);\n  result->w_zout = NULL;\n  free (result->sslidar_nphot);\n  result->sslidar_nphot = NULL;\n  free (result->sslidar_nphot_q);\n  result->sslidar_nphot_q = NULL;\n  free (result->sslidar_ratio);\n  result->sslidar_ratio = NULL;\n\n  if (result->u0u != NULL) {\n    ASCII_free_float (result->u0u, nzout);\n    result->u0u = NULL;\n  }\n\n  if (result->uu != NULL) {\n    ASCII_free_float_3D (result->uu, input.rte.nphi, nzout);\n    result->uu = NULL;\n  }\n\n  if (result->uum != NULL) {\n    ASCII_free_float_3D (result->uum, input.rte.nstr, nzout);\n    result->uum = NULL;\n  }\n\n  if (input.rte.solver == SOLVER_POLRADTRAN) {\n    free (result->polradtran_mu_values);\n    result->polradtran_mu_values = NULL;\n\n    if (result->polradtran_up_flux != NULL) {\n      ASCII_free_double (result->polradtran_up_flux, nzout);\n      result->polradtran_up_flux = NULL;\n    }\n\n    if (result->polradtran_down_flux != NULL) {\n      ASCII_free_double (result->polradtran_down_flux, nzout);\n      result->polradtran_down_flux = NULL;\n    }\n\n    if (result->polradtran_up_rad != NULL) {\n      ASCII_free_double_4D (result->polradtran_up_rad, nzout, input.rte.nphi, input.rte.nstr / 2 + input.rte.numu);\n      result->polradtran_up_rad = NULL;\n    }\n\n    if (result->polradtran_down_rad != NULL) {\n      ASCII_free_double_4D (result->polradtran_down_rad, nzout, input.rte.nphi, input.rte.nstr / 2 + input.rte.numu);\n      result->polradtran_down_rad = NULL;\n    }\n\n    if (result->polradtran_up_rad_q != NULL) {\n      ASCII_free_double_4D (result->polradtran_up_rad_q,\n                            nzout,\n                            input.rte.polradtran[POLRADTRAN_AZIORDER] + 1,\n                            input.rte.nstr / 2 + input.rte.numu);\n      result->polradtran_up_rad_q = NULL;\n    }\n\n    if (result->polradtran_down_rad_q != NULL) {\n      ASCII_free_double_4D (result->polradtran_down_rad_q,\n                            nzout,\n                            input.rte.polradtran[POLRADTRAN_AZIORDER] + 1,\n                            input.rte.nstr / 2 + input.rte.numu);\n      result->polradtran_down_rad_q = NULL;\n    }\n  }\n\n  /* free 3d fields */\n  if (passback3D) {\n\n    if (result->rfldir3d != NULL) {\n      ASCII_free_float_3D (result->rfldir3d, nzout, Nxsample);\n      result->rfldir3d = NULL;\n    }\n\n    if (result->rfldn3d != NULL) {\n      ASCII_free_float_3D (result->rfldn3d, nzout, Nxsample);\n      result->rfldn3d = NULL;\n    }\n\n    if (result->flup3d != NULL) {\n      ASCII_free_float_3D (result->flup3d, nzout, Nxsample);\n      result->flup3d = NULL;\n    }\n\n    if (result->uavgso3d != NULL) {\n      ASCII_free_float_3D (result->uavgso3d, nzout, Nxsample);\n      result->uavgso3d = NULL;\n    }\n\n    if (result->uavgdn3d != NULL) {\n      ASCII_free_float_3D (result->uavgdn3d, nzout, Nxsample);\n      result->uavgdn3d = NULL;\n    }\n\n    if (result->uavgup3d != NULL) {\n      ASCII_free_float_3D (result->uavgup3d, nzout, Nxsample);\n      result->uavgup3d = NULL;\n    }\n\n    if (result->radiance3d != NULL) {\n      ASCII_free_float_4D (result->radiance3d, nzout, Nxsample, Nysample);\n      result->radiance3d = NULL;\n    }\n\n    if (input.rte.mc.spectral_is || input.rte.mc.concentration_is)\n      if (result->fl3d_is != NULL) {\n        ASCII_free_float_5D (result->fl3d_is, nzout, Ncsample, Nxsample, Nysample);\n        result->fl3d_is = NULL;\n      }\n\n    if (result->radiance3d_is != NULL) {\n      ASCII_free_float_6D (result->radiance3d_is, nzout, Ncsample, Nxsample, Nysample, input.rte.mc.nstokes);\n      result->radiance3d_is = NULL;\n    }\n\n    if (input.rte.mc.jacobian[DIM_1D])\n      if (result->jacobian != NULL) {\n        ASCII_free_float_6D (result->jacobian, nzout, Nxsample, Nysample, input.n_caoth + 2, 2);\n        result->jacobian = NULL;\n      }\n\n    if (input.rte.mc.backward.absorption)\n      if (result->absback3d != NULL) {\n        ASCII_free_float_3D (result->absback3d, nzout, Nxsample);\n        result->absback3d = NULL;\n      }\n\n    if (input.rte.mc.absorption != MCFORWARD_ABS_NONE || input.ipa3d) /*ulrike: added || input.ipa3d*/\n      if (result->abs3d != NULL) {\n        free_abs3d (result->abs3d, Nxcld, Nycld, Nzcld, threed);\n        result->abs3d = NULL;\n      }\n\n    /* variances */\n    if (input.rte.mc.std) {\n\n      if (result->rfldir3d_var != NULL) {\n        ASCII_free_float_3D (result->rfldir3d_var, nzout, Nxsample);\n        result->rfldir3d_var = NULL;\n      }\n      if (result->rfldn3d != NULL) {\n        ASCII_free_float_3D (result->rfldn3d_var, nzout, Nxsample);\n        result->rfldn3d = NULL;\n      }\n      if (result->flup3d != NULL) {\n        ASCII_free_float_3D (result->flup3d_var, nzout, Nxsample);\n        result->flup3d = NULL;\n      }\n      if (result->uavgso3d != NULL) {\n        ASCII_free_float_3D (result->uavgso3d_var, nzout, Nxsample);\n        result->uavgso3d = NULL;\n      }\n      if (result->uavgdn3d != NULL) {\n        ASCII_free_float_3D (result->uavgdn3d_var, nzout, Nxsample);\n        result->uavgdn3d = NULL;\n      }\n      if (result->uavgup3d != NULL) {\n        ASCII_free_float_3D (result->uavgup3d_var, nzout, Nxsample);\n        result->uavgup3d = NULL;\n      }\n      if (result->radiance3d != NULL) {\n        ASCII_free_float_4D (result->radiance3d_var, nzout, Nxsample, Nysample);\n        result->radiance3d = NULL;\n      }\n\n      if (input.rte.mc.backward.absorption)\n        if (result->absback3d != NULL) {\n          ASCII_free_float_3D (result->absback3d_var, nzout, Nxsample);\n          result->absback3d = NULL;\n        }\n\n      if (input.rte.mc.absorption != MCFORWARD_ABS_NONE || input.ipa3d) /*ulrike: added || input.ipa3d*/\n        if (result->abs3d != NULL) {\n          free_abs3d (result->abs3d_var, Nxcld, Nycld, Nzcld, threed);\n          result->abs3d = NULL;\n        }\n    }\n  }\n\n  const int ierr = free_triangular_surface_result_struct (result->triangle_results);\n  CHKERR (ierr);\n\n  free (result);\n  return 0;\n}\n\n/******************************************************/\n/* setup optical properties, do some initializations, */\n/* and call the RTE solver.                           */\n/******************************************************/\n\nstatic int setup_and_call_solver (input_struct           input,\n                                  output_struct*         output,\n                                  rte_input*             rte_in,\n                                  rte_output*            rte_out,\n                                  raman_qsrc_components* raman_qsrc_components,\n                                  int                    iv,\n                                  int                    ib,\n                                  int                    ir,\n                                  int*                   threed,\n                                  int                    mc_loaddata) {\n  int        status = 0, lu = 0, iv1 = 0, iv2 = 0, iv_alis = 0, il = 0, isp = 0;\n  static int first                   = 1;\n  static int verbose                 = 0;\n  int        rte_solver              = NOT_DEFINED_INTEGER;\n  int        skip_optical_properties = FALSE;\n\n  /* change rte solver to NULL solver for                                   */\n  /* solar simulations with sza > 90 degrees done by plane paralell solvers */\n\n  rte_solver = input.rte.solver;\n\n  switch (input.source) {\n  case SRC_THERMAL:\n    /* do not change solver */\n    break;\n  case SRC_SOLAR:\n  case SRC_BLITZ: /* BCA */\n  case SRC_LIDAR: /* BCA */\n    if (output->atm.sza_r[iv] >= 90.0) {\n      switch (input.rte.solver) {\n\n      /* plane parallel solvers */\n      case SOLVER_FDISORT1:\n      case SOLVER_FDISORT2:\n      case SOLVER_RODENTS:\n      case SOLVER_TWOSTREBE:\n      case SOLVER_TWOMAXRND:\n      case SOLVER_TWOMAXRND3C:\n      case SOLVER_DYNAMIC_TWOSTREAM:\n      case SOLVER_DYNAMIC_TENSTREAM:\n      case SOLVER_POLRADTRAN:\n      case SOLVER_SSS:\n      case SOLVER_SSSI:\n      case SOLVER_DISORT:  // aky 24022011, cdisort may produce results for sza>90 if intensity correction\n                           // are turned off. But results are a bit dubious if compared with mystic.\n                           /* change solver to SOLVER_NULL, as output is 0 anyway */\n        /* It is only 0 if pseudospherical is off aky 05022014 */\n        if (!input.rte.pseudospherical) {\n          rte_solver              = SOLVER_NULL;\n          skip_optical_properties = TRUE;\n          if (input.verbose)\n            fprintf (stderr, \" ... solar calculation with SZA>90 and pp solver, switch solver to NULL-solver \\n\");\n        }\n        break;\n\n      /* spherical solvers */\n      case SOLVER_SDISORT:\n      case SOLVER_SPSDISORT:\n      case SOLVER_FTWOSTR:\n      case SOLVER_TWOSTR:\n      case SOLVER_SOS:\n        /* do not change solver as these solvers should be   */\n        /* able to do solar calculations for sza > 90 degree */\n        break;\n\n      /* special solvers */\n      case SOLVER_MONTECARLO: /* user must know it */\n      case SOLVER_TZS:        /* only thermal anyway */\n      case SOLVER_SSLIDAR:\n        /* do nothing */\n        break;\n\n      case SOLVER_NULL:\n        break;\n      default:\n        fprintf (stderr, \"Error, unknown RTE solver %d\\n\", input.rte.solver);\n        break;\n      }\n    }\n    break;\n  default:\n    fprintf (stderr, \"Error, unknown source %d\\n\", input.source);\n    return -1;\n  }\n\n  if (input.raman) {\n    /* Optical properties are calculated just before calling qdisort in solve_rte.c */\n    skip_optical_properties = TRUE;\n    /* For raman_fast optical properties are calculated as usual */\n    if (input.raman_fast && ir == 0)\n      skip_optical_properties = FALSE;\n  }\n\n  verbose = input.verbose;\n\n  if (input.verbose && input.ck_scheme == CK_LOWTRAN)\n    verbose = 0; /* no verbose output for the following call of optical properties */\n\n  /* calculate optical properties from model input */\n  if (input.raman_fast) {\n    iv1 = ib;\n    iv2 = ib;\n  } else {\n    iv1 = iv;\n    iv2 = iv;\n  }\n\n  if (input.rte.mc.spectral_is) {\n    if (ib == 0) {\n      /* fprintf(stderr, \"alloc ALIS struct iv %d\\n\", iv); */\n      output->mc.alis.dt = calloc (output->mc.alis.nlambda_abs, sizeof (double**));\n      output->mc.alis.om = calloc (output->mc.alis.nlambda_abs, sizeof (double**));\n      for (iv_alis = 0; iv_alis < output->mc.alis.nlambda_abs; iv_alis++) {\n        output->mc.alis.dt[iv_alis] = calloc (input.n_caoth + 2, sizeof (double*));\n        output->mc.alis.om[iv_alis] = calloc (input.n_caoth + 2, sizeof (double*));\n      }\n      for (iv_alis = 0; iv_alis < output->mc.alis.nlambda_abs; iv_alis++) {\n        for (isp = 0; isp < input.n_caoth + 2; isp++) {\n          output->mc.alis.dt[iv_alis][isp] = calloc (output->atm.nlev_common - 1, sizeof (double));\n          output->mc.alis.om[iv_alis][isp] = calloc (output->atm.nlev_common - 1, sizeof (double));\n        }\n      }\n    }\n\n    for (iv_alis = 0; iv_alis < output->mc.alis.nlambda_abs; iv_alis++) {\n      status = optical_properties (input, output, 0.0, ir, iv_alis, iv_alis, ib, verbose, skip_optical_properties);\n    }\n\n    /* spatially constant spectral Lambertian albedo */\n    output->mc.alis.albedo = calloc (output->mc.alis.nlambda_abs, sizeof (double));\n    for (iv_alis = 0; iv_alis < output->mc.alis.nlambda_abs; iv_alis++)\n      output->mc.alis.albedo[iv_alis] = output->alb.albedo_r[iv_alis];\n\n    /* 2D spectral Lambertian albedo */\n    if (output->surfaces.n > 0 && output->surfaces.albedo_r != NULL) {\n      output->mc.alis.alb_type = calloc (output->surfaces.n, sizeof (double*));\n\n      for (il = 0; il < output->surfaces.n; il++) {\n        output->mc.alis.alb_type[il] = calloc (output->mc.alis.nlambda_abs, sizeof (double));\n\n        for (iv_alis = 0; iv_alis < output->mc.alis.nlambda_abs; iv_alis++)\n          output->mc.alis.alb_type[il][iv_alis] = output->surfaces.albedo_r[il][iv_alis];\n      }\n    }\n\n    if (output->mc.alis.dt[iv][0][output->atm.nlev_common - 2] * (1.0 - output->mc.alis.om[iv][0][output->atm.nlev_common - 2]) >\n        0.5) {\n      fprintf (stderr, \" ... Warning: Absorption is very high at the calculation wavelength for\\n\");\n      fprintf (stderr, \" ...          spectral importance sampling. In order to improve the result \\n\");\n      fprintf (stderr, \" ...          please select another calculation wavelength using the option\\n\");\n      fprintf (stderr, \" ...          *mc_spectral_is_wvl*. \\n\");\n      fprintf (stderr,\n               \" ...          (Absorption optical depth in lowest layer is %g) \\n\",\n               output->mc.alis.dt[iv][0][output->atm.nlev_common - 2] *\n                 (1.0 - output->mc.alis.om[iv][0][output->atm.nlev_common - 2]));\n    }\n  }\n\n  //TODO: else statement? call optical properties twice -> double allocating etc\n  status = optical_properties (input, output, 0.0, ir, iv1, iv2, ib, verbose, skip_optical_properties); /* in ancillary.c */\n  if (status != 0) {\n    fprintf (stderr,\n             \"Error %d returned by optical_properties (line %d, function %s in %s)\\n\",\n             status,\n             __LINE__,\n             __func__,\n             __FILE__);\n    return status;\n  }\n\n  /* 3DAbs may be here ??? */\n  /* else{ */\n  /*   status = optical_properties_atmosphere3D(input, output, iv, ib, verbose); */\n  /*   if (status!=0) { */\n  /*     fprintf (stderr, \"Error %d returned by optical_properties_atmosphere3D (line %d, function %s in %s)\\n\",  */\n  /* \t       status, __LINE__, __func__, __FILE__); */\n  /*     return status; */\n  /*   } */\n  /* } */\n\n  if (input.ck_scheme == CK_LOWTRAN) {\n\n    /* this is a little inefficient as we need first the scattering optical */\n    /* properties to calculate the absorption coefficients and then         */\n    /* recalculate the optical properties; the reason is that SBDART        */\n    /* requires the total scattering cross section as input, and this       */\n    /* quantity is only available after the call to optical_properties      */\n\n    /* ??? where to get the mixing ratio of N2 from ??? */\n    /* ??? setting this value to -1                 ??? */\n    status = sbdart_profile (output->atm.microphys.temper,\n                             output->atm.microphys.press,\n                             output->atm.zd,\n                             output->atm.microphys.dens[MOL_H2O],\n                             output->atm.microphys.dens[MOL_O3],\n                             -1.0,\n                             output->mixing_ratio[MX_O2],\n                             output->mixing_ratio[MX_CO2],\n                             output->mixing_ratio[MX_CH4],\n                             output->mixing_ratio[MX_N2O],\n                             output->mixing_ratio[MX_NO2],\n                             input.ck_abs[CK_ABS_O4],\n                             input.ck_abs[CK_ABS_N2],\n                             input.ck_abs[CK_ABS_CO],\n                             input.ck_abs[CK_ABS_SO2],\n                             input.ck_abs[CK_ABS_NH3],\n                             input.ck_abs[CK_ABS_NO],\n                             input.ck_abs[CK_ABS_HNO3],\n                             output->dtauc,\n                             output->ssalb,\n                             output->atm.nlev,\n                             output->atm.sza_r[iv],\n                             output->wl.lambda_r[iv],\n                             iv,\n                             output->crs_ck.profile[0],\n                             input.rte.mc.spectral_is);\n\n    if (status != 0) {\n      fprintf (stderr, \"Error %d returned by sbdart_profile (line %d, function %s in %s)\\n\", status, __LINE__, __func__, __FILE__);\n      return status;\n    }\n\n    /* allocate memory for absorption coefficient profile */\n    if (first) {\n      status = ASCII_calloc_float (&output->kabs.kabs, output->atm.nlev, output->wl.nlambda_r);\n      if (status != 0) {\n        fprintf (stderr, \"Error %d allocating memory for output->kabs.kabs\\n\", status);\n        return status;\n      }\n\n      first = 0;\n    }\n\n    /* set absorption coefficient */\n    for (lu = 0; lu < output->atm.nlyr; lu++)\n      output->kabs.kabs[lu][iv] = output->crs_ck.profile[0][iv].crs[0][0][lu][ib];\n\n    if (input.rte.mc.spectral_is) {\n      for (iv_alis = 0; iv_alis < output->mc.alis.nlambda_abs; iv_alis++) {\n        status = optical_properties (input, output, 0.0, ir, iv_alis, iv_alis, ib, verbose, skip_optical_properties);\n      }\n    }\n\n    /* calculate optical properties from model input */\n    status = optical_properties (input, output, 0.0, ir, iv, iv, ib, input.verbose, skip_optical_properties); /* in ancillaries.c */\n\n    if (status != 0) {\n      fprintf (stderr,\n               \"Error %d returned by optical_properties (line %d, function %s in %s)\\n\",\n               status,\n               __LINE__,\n               __func__,\n               __FILE__);\n      return status;\n    }\n  }\n\n  /* translate output altitudes (zout) to optical depths (utau) */\n\n  switch (input.rte.solver) {\n  case SOLVER_FDISORT1:\n  case SOLVER_SDISORT:\n  case SOLVER_FTWOSTR:\n  case SOLVER_SOS:\n  case SOLVER_POLRADTRAN:\n  case SOLVER_FDISORT2:\n  case SOLVER_SPSDISORT:\n  case SOLVER_TZS:\n  case SOLVER_SSS:\n  case SOLVER_SSSI:\n    /* \"very old\" version, recycled */\n    F77_FUNC (setout, SETOUT)\n    (output->dtauc, &(output->atm.nlyr), &(output->atm.nzout), rte_in->utau, output->atm.zd, output->atm.zout_sur);\n\n    break;\n  case SOLVER_TWOSTR:\n  case SOLVER_TWOSTREBE:\n  case SOLVER_TWOMAXRND:\n  case SOLVER_TWOMAXRND3C:\n  case SOLVER_DYNAMIC_TWOSTREAM:\n  case SOLVER_DYNAMIC_TENSTREAM:\n  case SOLVER_RODENTS:\n  case SOLVER_DISORT:\n    /* \"old\" version */\n    /*\n    status = set_out (output->atm.zd, output->dtauc, output->atm.nlyr, \n\t\t      input.atm.zout, output->atm.nzout, rte_in->utau);\n\n    if (status!=0) {\n      fprintf (stderr, \"Error %d returned by set_out()\\n\", status);\n      return status;\n    }\n    */\n\n    status = c_setout (output->dtauc, output->atm.nlyr, output->atm.nzout, rte_in->utau, output->atm.zd, output->atm.zout_sur);\n    if (status) {\n      fprintf (stderr, \"Error returned by c_setout\\n\");\n      return -1;\n    }\n    break;\n  case SOLVER_MONTECARLO:\n  case SOLVER_SSLIDAR:\n  case SOLVER_NULL:\n    break;\n  default:\n    fprintf (stderr,\n             \"Error, unknown rte_solver %d (line %d, function '%s' in '%s')\\n\",\n             input.rte.solver,\n             __LINE__,\n             __func__,\n             __FILE__);\n    return -1;\n  }\n\n  /* reverse profiles, if required */\n  if (input.rte.reverse) {\n    status = reverse_profiles (input, output);\n    if (status != 0) {\n      fprintf (stderr, \"Error %d reversing profiles\\n\", status);\n      return status;\n    }\n  }\n\n  /**** Switch to SOLVER_NULL to run optical_properties tests without solving RTE, Bettina Richter ****/\n  if (input.test_optical_properties) {\n    fprintf (stderr, \" ... switch rte_solver to null_solver\\n\");\n    input.rte.solver = SOLVER_NULL;\n    rte_solver       = SOLVER_NULL;\n  }\n\n  /* call RTE solver */\n  status =\n    call_solver (input, output, rte_solver, rte_in, raman_qsrc_components, iv, ib, ir, rte_out, threed, mc_loaddata, input.verbose);\n  if (status != 0) {\n    fprintf (stderr, \"Error %d calling solver\\n\", status);\n    return status;\n  }\n\n  return 0; /* if o.k. */\n}\n\nstatic int call_solver (input_struct           input,\n                        output_struct*         output,\n                        int                    rte_solver,\n                        rte_input*             rte_in,\n                        raman_qsrc_components* raman_qsrc_comp,\n                        int                    iv,\n                        int                    ib,\n                        int                    ir,\n                        rte_output*            rte_out,\n                        int*                   threed,\n                        int                    mc_loaddata,\n                        int                    verbose) {\n  int                    status = 0;\n  int                    lev = 0, ivi = 0, imu = 0, iv_alis = 0;\n  double                 start = 0, end = 0, last = 0;\n  int                    lu = 0, is = 0;\n  raman_qsrc_components* tmp_raman_qsrc_comp = NULL;\n  double *               tmp_in_int = NULL, *tmp_out_int = NULL, *tmp_wl = NULL;\n\n#if HAVE_SOS\n  int k = 0;\n#endif\n\n  double*** tmp_crs = NULL;\n\n  /* CE: commented since I have introduced the option earth_radius, default value is 6370.0 */\n  /* float radius= 6370.0; */ /* Earth's radius in km */\n\n  /* c_disort and c_twostr double declarations as they expect all input in double */\n  /* and f77 disort and twostr is all float. AK 23.09.2010                        */\n\n  disort_state  ds_in, twostr_ds;\n  disort_output ds_out, twostr_out;\n  double*       c_twostr_gg = NULL;\n  double*       c_zd        = NULL;\n  double        c_r_earth   = (double)input.r_earth;\n  int           lc = 0, j = 0, maz = 0, iq = 0;\n\n  float*  twostr_gg         = NULL;\n  float*  twostr_gg_clr     = NULL;\n  float*  twostr_gg_cldk    = NULL;\n  float*  twostr_gg_cldn    = NULL;\n  float*  twostr_cf         = NULL;\n  float*  twostr_ff         = NULL;\n  float*  sdisort_beta      = NULL;\n  float*  sdisort_sig       = NULL;\n  float** sdisort_denstab   = NULL;\n  float*  tosdisort_denstab = NULL;\n  float * disort_pmom = NULL, *disort2_pmom = NULL, *sss_pmom = NULL, *disort2_phaso = NULL;\n  int     disort2_ntheta_default   = 0;\n  int*    disort2_ntheta           = &disort2_ntheta_default;\n  double* disort2_mup              = NULL;\n  int     intensity_correction     = TRUE;\n  int     old_intensity_correction = FALSE;\n  int     rodents_delta_method     = 0;\n\n  float qwanted_wvl[1];\n  float qfbeam[1];\n  float qalbedo[1];\n  int   iv1 = 0, iv2 = 0;\n  int   skip_optical_properties = FALSE;\n  int   planck_tempoff          = 0;\n\n  char function_name[] = \"call_solver\";\n  char file_name[]     = \"solve_rte.c\";\n\n  double** phase_back = NULL;\n\n#if HAVE_SOS\n  float** pmom_sos = NULL;\n#endif\n\n#if HAVE_POLRADTRAN\n  int iu = 0;\n\n  double* polradtran_down_flux = NULL;\n  double* polradtran_up_flux   = NULL;\n  double* polradtran_down_rad  = NULL;\n  double* polradtran_up_rad    = NULL;\n#endif\n\n  /* temporary Fortran arrays */\n  float *disort_u0u = NULL, *disort_uu = NULL;\n  /* float *tzs_u0u = NULL, *tzs_uu = NULL; */\n  float *sss_u0u = NULL, *sss_uu = NULL;\n\n#if HAVE_MYSTIC\n  int il              = 0;\n  int source          = 0;\n  int thermal_photons = 0;\n\n  double* weight_spectral = NULL;\n\n  /* temporary MC output (for thermal MC calculations, two calls   */\n  /* to mystic() are required, one for the surface and one for the */\n  /* atmospheric contribution                                      */\n  rte_output* tmp_out = NULL;\n\n  /* rpv arrays */\n  float* alb_type  = NULL;\n  float* rpv_rho0  = NULL;\n  float* rpv_k     = NULL;\n  float* rpv_theta = NULL;\n  float* rpv_scale = NULL;\n  float* rpv_sigma = NULL;\n  float* rpv_t1    = NULL;\n  float* rpv_t2    = NULL;\n\n  float* rossli_iso = NULL;\n  float* rossli_vol = NULL;\n  float* rossli_geo = NULL;\n\n  float* hapke_h  = NULL;\n  float* hapke_b0 = NULL;\n  float* hapke_w  = NULL;\n\n  int write_files = 0;\n\n  /* write MYSTIC monochromatic output only if monochromatic, non-ck uvspec calculation */\n  write_files = (output->wl.nlambda_r * output->atm.nq_r[output->wl.nlambda_rte_lower] > 1 ? 0 : 1);\n\n  /* RPB very dirty trick, please dont kill me for this!!! */\n  if (output->mc.sample.LidarLocEst)\n    write_files = 1;\n  /* write files for spectral/concentration importance sampling, but only if not spectrally post-processed */\n  if ((input.rte.mc.spectral_is || input.rte.mc.concentration_is) && input.processing == PROCESS_NONE)\n    write_files = 1;\n#endif\n\n  if (input.rte.mc.backward.writeback == 1)\n    write_files = 1;\n\n  if (verbose)\n    start = clock();\n\n  switch (rte_solver) { /* this is the ONLY use of rte_solver, everywhere else still input.rte.solver is used */\n\n  case SOLVER_MONTECARLO:\n#if HAVE_MYSTIC\n\n    if (ib == 0)\n      if (input.verbose)\n        fprintf (stderr, \" ... start Monte Carlo simulation for lambda = %10.2f nm \\n\", output->wl.lambda_r[iv]);\n\n    /* create rpv arrays */\n    /* BCA: this is not nice, especially case surf.n=0 and il=0, affects mystic.c and albedo.c */\n    if (output->surfaces.n > 0 && output->surfaces.rpv != NULL) {\n\n      rpv_rho0  = calloc (output->surfaces.n, sizeof (float));\n      rpv_k     = calloc (output->surfaces.n, sizeof (float));\n      rpv_theta = calloc (output->surfaces.n, sizeof (float));\n      rpv_scale = calloc (output->surfaces.n, sizeof (float));\n      rpv_sigma = calloc (output->surfaces.n, sizeof (float));\n      rpv_t1    = calloc (output->surfaces.n, sizeof (float));\n      rpv_t2    = calloc (output->surfaces.n, sizeof (float));\n\n      for (il = 0; il < output->surfaces.n; il++) {\n        rpv_rho0[il]  = output->surfaces.rpv[il].rho0_r[iv];\n        rpv_k[il]     = output->surfaces.rpv[il].k_r[iv];\n        rpv_theta[il] = output->surfaces.rpv[il].theta_r[iv];\n        rpv_scale[il] = output->surfaces.rpv[il].scale_r[iv];\n        rpv_sigma[il] = output->surfaces.rpv[il].sigma_r[iv];\n        rpv_t1[il]    = output->surfaces.rpv[il].t1_r[iv];\n        rpv_t2[il]    = output->surfaces.rpv[il].t2_r[iv];\n      }\n    } else {\n      rpv_rho0  = calloc (1, sizeof (float));\n      rpv_k     = calloc (1, sizeof (float));\n      rpv_theta = calloc (1, sizeof (float));\n      rpv_scale = calloc (1, sizeof (float));\n      rpv_sigma = calloc (1, sizeof (float));\n      rpv_t1    = calloc (1, sizeof (float));\n      rpv_t2    = calloc (1, sizeof (float));\n\n      rpv_rho0[0]  = output->rpv.rho0_r[iv];\n      rpv_k[0]     = output->rpv.k_r[iv];\n      rpv_theta[0] = output->rpv.theta_r[iv];\n      rpv_scale[0] = output->rpv.scale_r[iv];\n      rpv_sigma[0] = output->rpv.sigma_r[iv];\n      rpv_t1[0]    = output->rpv.t1_r[iv];\n      rpv_t2[0]    = output->rpv.t2_r[iv];\n    }\n\n    if (output->surfaces.n > 0 && output->surfaces.albedo_r != NULL) {\n      alb_type = calloc (output->surfaces.n, sizeof (float));\n\n      for (il = 0; il < output->surfaces.n; il++)\n        alb_type[il] = output->surfaces.albedo_r[il][iv];\n    } else {\n      alb_type    = calloc (1, sizeof (float));\n      alb_type[0] = output->alb.albedo_r[iv];\n    }\n\n    /* for rossli we don't have a surface type yet, but that */\n    /* would be straightforward to implement                  */\n    if (output->surfaces.n > 0 && output->surfaces.rossli != NULL) {\n\n      rossli_iso = calloc (output->surfaces.n, sizeof (float));\n      rossli_vol = calloc (output->surfaces.n, sizeof (float));\n      rossli_geo = calloc (output->surfaces.n, sizeof (float));\n\n      for (il = 0; il < output->surfaces.n; il++) {\n        rossli_iso[il] = output->surfaces.rossli[il].iso_r[iv];\n        rossli_vol[il] = output->surfaces.rossli[il].vol_r[iv];\n        rossli_geo[il] = output->surfaces.rossli[il].geo_r[iv];\n      }\n    } else {\n      rossli_iso = calloc (1, sizeof (float));\n      rossli_vol = calloc (1, sizeof (float));\n      rossli_geo = calloc (1, sizeof (float));\n\n      rossli_iso[0] = output->rossli.iso_r[iv];\n      rossli_vol[0] = output->rossli.vol_r[iv];\n      rossli_geo[0] = output->rossli.geo_r[iv];\n    }\n\n    /* for hapke we don't have a surface type yet, but that */\n    /* would be straightforward to implement                  */\n    hapke_w  = calloc (1, sizeof (float));\n    hapke_b0 = calloc (1, sizeof (float));\n    hapke_h  = calloc (1, sizeof (float));\n\n    /* also, wavelength dependence is missing, but that */\n    /* would also be straightforward to implement       */\n    hapke_w[0]  = output->hapke.w_r[iv];\n    hapke_b0[0] = output->hapke.b0_r[iv];\n    hapke_h[0]  = output->hapke.h_r[iv];\n\n    if (input.rte.mc.spectral_is)\n      weight_spectral = calloc (output->mc.alis.nlambda_abs, sizeof (double));\n\n    switch (input.source) {\n    case SRC_SOLAR: /* solar source */\n    case SRC_BLITZ: /* blitz source */\n    case SRC_LIDAR: /* lidar source */\n\n      switch (input.source) {\n      case SRC_SOLAR: /* solar source */\n        source = MCSRC_SOLAR;\n        break;\n      case SRC_BLITZ: /* blitz source */\n        source = MCSRC_BLITZ;\n        break;\n      case SRC_LIDAR: /* lidar source */\n        source = MCSRC_LIDAR;\n        break;\n      default:\n        fprintf (stderr, \"Error, source %d should not turn up here!\\n\", input.source);\n        return -1;\n      }\n\n      status = mystic (&output->atm.nlyr,\n                       threed,\n                       input.n_caoth + 2,\n                       output->mc.dt,\n                       output->mc.om,\n                       output->mc.g1,\n                       output->mc.g2,\n                       output->mc.ff,\n                       output->mc.ds,\n                       &(output->mc.alis),\n                       output->mc.refind,\n                       input.r_earth * 1000.0,\n                       input.rte.mc.refractive_index_pv,\n                       &(output->rayleigh_depol[iv]),\n                       output->caoth3d,\n                       output->mc.re,\n                       output->mc.temper,\n                       input.atmosphere3d,\n                       output->mc.z,\n                       output->mc.momaer,\n                       output->mc.nmomaer,\n                       output->mc.nthetaaer,\n                       output->mc.thetaaer,\n                       output->mc.muaer,\n                       output->mc.phaseaer,\n                       output->mc.nphamataer,\n                       &output->alb.albedo_r[iv],\n                       alb_type,\n                       output->atm.sza_r[iv],\n                       output->atm.phi0_r[iv],\n                       input.atm.sza_spher,\n                       input.atm.phi0_spher,\n                       output->mc_photons,\n                       &source,\n                       &(output->wl.wvnmlo_r[iv]),\n                       &(output->wl.wvnmhi_r[iv]),\n                       &(output->wl.lambda_r[iv]),\n                       output->atm.zout_sur,\n                       &(output->atm.nzout),\n                       rpv_rho0,\n                       rpv_k,\n                       rpv_theta,\n                       rpv_scale,\n                       rpv_sigma,\n                       rpv_t1,\n                       rpv_t2,\n                       hapke_h,\n                       hapke_b0,\n                       hapke_w,\n                       rossli_iso,\n                       rossli_vol,\n                       rossli_geo,\n                       input.rossli.hotspot,\n                       &(input.cm.param[BRDF_CAM_U10]),\n                       &(input.cm.param[BRDF_CAM_PCL]),\n                       &(input.cm.param[BRDF_CAM_SAL]),\n                       &(input.cm.param[BRDF_CAM_UPHI]),\n                       &(input.cm.solar_wind),\n                       &(input.bpdf.u10),\n                       &(input.rte.mc.tenstream),\n                       input.rte.mc.tenstream_options,\n                       &(input.rte.mc.nca), /* Carolin Klinger 2019 */\n                       input.rte.mc.nca_options,\n                       &(input.rte.mc.ipa),\n                       &(input.rte.mc.absorption),\n                       &(input.rte.mc.backward.thermal_heating_method),\n                       &mc_loaddata,\n                       &(output->mc.sample),\n                       &(output->mc.elev),\n                       &(output->mc.triangular_surface),\n                       &(output->mc.surftemp),\n                       input.rte.mc.filename[FN_MC_BASENAME],\n                       input.rte.mc.filename[FN_MC_UMU],\n                       input.rte.mc.filename[FN_MC_SUNSHAPE_FILE],\n                       input.rte.mc.filename[FN_MC_ALBEDO],\n                       input.rte.mc.filename[FN_MC_AMBRALS],\n                       input.rte.mc.filename[FN_MC_ROSSLI],\n                       input.rte.mc.filename[FN_MC_ALBEDO_TYPE],\n                       input.rte.mc.filename[FN_MC_RPV2D_TYPE],\n                       input.rte.mc.filename[FN_MC_AMBRALS_TYPE],\n                       output->surfaces.label,\n                       &(output->surfaces.n),\n                       &(input.rte.mc.delta_scaling_mucut), /*TZ ds*/\n                       &(input.rte.mc.truncate),\n                       &(input.rte.mc.reflectalways),\n                       input.quiet,\n                       rte_out->rfldir,\n                       rte_out->rfldn,\n                       rte_out->flup,\n                       rte_out->uavgso,\n                       rte_out->uavgdn,\n                       rte_out->uavgup,\n                       rte_out->rfldir3d,\n                       rte_out->rfldn3d,\n                       rte_out->flup3d,\n                       rte_out->fl3d_is,\n                       rte_out->uavgso3d,\n                       rte_out->uavgdn3d,\n                       rte_out->uavgup3d,\n                       rte_out->radiance3d,\n                       rte_out->absback3d,\n                       rte_out->abs3d,\n                       rte_out->radiance3d_is,\n                       rte_out->jacobian,\n                       rte_out->rfldir3d_var,\n                       rte_out->rfldn3d_var,\n                       rte_out->flup3d_var,\n                       rte_out->uavgso3d_var,\n                       rte_out->uavgdn3d_var,\n                       rte_out->uavgup3d_var,\n                       rte_out->radiance3d_var,\n                       rte_out->absback3d_var,\n                       rte_out->abs3d_var,\n                       rte_out->triangle_results,\n                       output->atm.Nxcld,\n                       output->atm.Nycld,\n                       output->atm.Nzcld,\n                       output->atm.dxcld,\n                       output->atm.dycld,\n                       input.filename[FN_PATH],\n                       input.filename[FN_RANDOMSTATUS],\n                       input.rte.mc.readrandomstatus,\n                       input.write_output_as_netcdf,\n                       write_files,\n                       input.rte.mc.visualize);\n\n      CHKERR (status);\n\n      break;\n\n    case SRC_THERMAL: /* thermal source */\n      /* normal atmospheric + surface emission */\n      switch (input.rte.mc.absorption) {\n      case MCFORWARD_ABS_NONE:\n      case MCFORWARD_ABS_ABSORPTION:\n      case MCFORWARD_ABS_HEATING:\n        if (!input.rte.mc.backward.yes) { /*TZ bt*/\n\n          thermal_photons = 0.5 * output->mc_photons;\n\n          /* thermal emission of the atmosphere */\n          if (ib == 0 && !input.quiet)\n            fprintf (stderr, \" ... thermal emission of the atmosphere\\n\");\n\n        } else {                                      /*TZ bt*/\n          thermal_photons = 1.0 * output->mc_photons; /*TZ bt*/\n          /* CE for spectral importance sampling, we run a MC */\n          /* calculation at only one wavelengths, even if input */\n          /* wavelength is not exactly included in */\n          /* molecular_tau_file   */\n          if (input.rte.mc.spectral_is)\n            thermal_photons = input.rte.mc.photons;\n          /* thermal emission into the atmosphere TZ bt*/\n          if (ib == 0 && !input.quiet)\n            fprintf (stderr, \" ... thermal backward emission into atmosphere\\n\"); /*TZ*/\n        }                                                                         /*TZ bt*/\n\n        if (!input.rte.mc.backward.yes) /*TZ bt*/\n          source = MCSRC_THERMAL_ATMOSPHERE;\n        else                               /*TZ bt*/\n          source = MCSRC_THERMAL_BACKWARD; /*TZ bt*/\n\n        status = mystic (&output->atm.nlyr,\n                         threed,\n                         input.n_caoth + 2,\n                         output->mc.dt,\n                         output->mc.om,\n                         output->mc.g1,\n                         output->mc.g2,\n                         output->mc.ff,\n                         output->mc.ds,\n                         &(output->mc.alis),\n                         output->mc.refind,\n                         input.r_earth * 1000.0,\n                         input.rte.mc.refractive_index_pv,\n                         &(output->rayleigh_depol[iv]),\n                         output->caoth3d,\n                         output->mc.re,\n                         output->mc.temper,\n                         input.atmosphere3d,\n                         output->mc.z,\n                         output->mc.momaer,\n                         output->mc.nmomaer,\n                         output->mc.nthetaaer,\n                         output->mc.thetaaer,\n                         output->mc.muaer,\n                         output->mc.phaseaer,\n                         output->mc.nphamataer,\n                         &output->alb.albedo_r[iv],\n                         alb_type,\n                         output->atm.sza_r[iv],\n                         output->atm.phi0_r[iv],\n                         input.atm.sza_spher,\n                         input.atm.phi0_spher,\n                         thermal_photons,\n                         &source,\n                         &(output->wl.wvnmlo_r[iv]),\n                         &(output->wl.wvnmhi_r[iv]),\n                         &(output->wl.lambda_r[iv]),\n                         output->atm.zout_sur,\n                         &(output->atm.nzout),\n                         rpv_rho0,\n                         rpv_k,\n                         rpv_theta,\n                         rpv_scale,\n                         rpv_sigma,\n                         rpv_t1,\n                         rpv_t2,\n                         hapke_h,\n                         hapke_b0,\n                         hapke_w,\n                         rossli_iso,\n                         rossli_vol,\n                         rossli_geo,\n                         input.rossli.hotspot,\n                         &(input.cm.param[BRDF_CAM_U10]),\n                         &(input.cm.param[BRDF_CAM_PCL]),\n                         &(input.cm.param[BRDF_CAM_SAL]),\n                         &(input.cm.param[BRDF_CAM_UPHI]),\n                         &(input.cm.solar_wind),\n                         &(input.bpdf.u10),\n                         &(input.rte.mc.tenstream),\n                         input.rte.mc.tenstream_options,\n                         &(input.rte.mc.nca), /* Carolin Klinger 2019 */\n                         input.rte.mc.nca_options,\n                         &(input.rte.mc.ipa),\n                         &(input.rte.mc.absorption),\n                         &(input.rte.mc.backward.thermal_heating_method),\n                         &mc_loaddata,\n                         &(output->mc.sample),\n                         &(output->mc.elev),\n                         &(output->mc.triangular_surface),\n                         &(output->mc.surftemp),\n                         input.rte.mc.filename[FN_MC_BASENAME],\n                         input.rte.mc.filename[FN_MC_UMU],\n                         input.rte.mc.filename[FN_MC_SUNSHAPE_FILE],\n                         input.rte.mc.filename[FN_MC_ALBEDO],\n                         input.rte.mc.filename[FN_MC_AMBRALS],\n                         input.rte.mc.filename[FN_MC_ROSSLI],\n                         input.rte.mc.filename[FN_MC_ALBEDO_TYPE],\n                         input.rte.mc.filename[FN_MC_RPV2D_TYPE],\n                         input.rte.mc.filename[FN_MC_AMBRALS_TYPE],\n                         output->surfaces.label,\n                         &(output->surfaces.n),\n                         &(input.rte.mc.delta_scaling_mucut), /*TZ ds*/\n                         &(input.rte.mc.truncate),\n                         &(input.rte.mc.reflectalways),\n                         input.quiet,\n                         rte_out->rfldir,\n                         rte_out->rfldn,\n                         rte_out->flup,\n                         rte_out->uavgso,\n                         rte_out->uavgdn,\n                         rte_out->uavgup,\n                         rte_out->rfldir3d,\n                         rte_out->rfldn3d,\n                         rte_out->flup3d,\n                         rte_out->fl3d_is,\n                         rte_out->uavgso3d,\n                         rte_out->uavgdn3d,\n                         rte_out->uavgup3d,\n                         rte_out->radiance3d,\n                         rte_out->absback3d,\n                         rte_out->abs3d,\n                         rte_out->radiance3d_is,\n                         rte_out->jacobian,\n                         rte_out->rfldir3d_var,\n                         rte_out->rfldn3d_var,\n                         rte_out->flup3d_var,\n                         rte_out->uavgso3d_var,\n                         rte_out->uavgdn3d_var,\n                         rte_out->uavgup3d_var,\n                         rte_out->radiance3d_var,\n                         rte_out->absback3d_var,\n                         rte_out->abs3d_var,\n                         rte_out->triangle_results,\n                         output->atm.Nxcld,\n                         output->atm.Nycld,\n                         output->atm.Nzcld,\n                         output->atm.dxcld,\n                         output->atm.dycld,\n                         input.filename[FN_PATH],\n                         input.filename[FN_RANDOMSTATUS],\n                         input.rte.mc.readrandomstatus,\n                         input.write_output_as_netcdf,\n                         write_files,\n                         input.rte.mc.visualize);\n\n        CHKERR (status);\n\n        /* thermal emission of the surface */\n        if (!input.rte.mc.backward.yes && !input.rte.mc.tenstream &&\n            !input.rte.mc.nca) { /*TZ bt, no separate surface emission needed*/ /* Carolin Klinger 2019 */\n          if (ib == 0 && !input.quiet)\n            fprintf (stderr, \" ... thermal emission of the surface\\n\");\n          /* data have already been loaded during the last MYSTIC call */\n          mc_loaddata = 0;\n\n          tmp_out = calloc_rte_output (input,\n                                       output->atm.nzout,\n                                       output->atm.Nxcld,\n                                       output->atm.Nycld,\n                                       output->atm.Nzcld,\n                                       output->mc.sample.Nx,\n                                       output->mc.sample.Ny,\n                                       output->mc.alis.Nc,\n                                       output->mc.alis.nlambda_abs,\n                                       output->atm.nlyr - 1,\n                                       output->atm.threed,\n                                       output->mc.sample.passback3D,\n                                       output->mc.triangular_surface.N_triangles);\n\n          source = MCSRC_THERMAL_SURFACE;\n\n          status = mystic (&output->atm.nlyr,\n                           threed,\n                           input.n_caoth + 2,\n                           output->mc.dt,\n                           output->mc.om,\n                           output->mc.g1,\n                           output->mc.g2,\n                           output->mc.ff,\n                           output->mc.ds,\n                           &(output->mc.alis),\n                           output->mc.refind,\n                           input.r_earth * 1000.0,\n                           input.rte.mc.refractive_index_pv,\n                           &(output->rayleigh_depol[iv]),\n                           output->caoth3d,\n                           output->mc.re,\n                           output->mc.temper,\n                           input.atmosphere3d,\n                           output->mc.z,\n                           output->mc.momaer,\n                           output->mc.nmomaer,\n                           output->mc.nthetaaer,\n                           output->mc.thetaaer,\n                           output->mc.muaer,\n                           output->mc.phaseaer,\n                           output->mc.nphamataer,\n                           &output->alb.albedo_r[iv],\n                           alb_type,\n                           output->atm.sza_r[iv],\n                           output->atm.phi0_r[iv],\n                           input.atm.sza_spher,\n                           input.atm.phi0_spher,\n                           thermal_photons,\n                           &source,\n                           &(output->wl.wvnmlo_r[iv]),\n                           &(output->wl.wvnmhi_r[iv]),\n                           &(output->wl.lambda_r[iv]),\n                           output->atm.zout_sur,\n                           &(output->atm.nzout),\n                           rpv_rho0,\n                           rpv_k,\n                           rpv_theta,\n                           rpv_scale,\n                           rpv_sigma,\n                           rpv_t1,\n                           rpv_t2,\n                           hapke_h,\n                           hapke_b0,\n                           hapke_w,\n                           rossli_iso,\n                           rossli_vol,\n                           rossli_geo,\n                           input.rossli.hotspot,\n                           &(input.cm.param[BRDF_CAM_U10]),\n                           &(input.cm.param[BRDF_CAM_PCL]),\n                           &(input.cm.param[BRDF_CAM_SAL]),\n                           &(input.cm.param[BRDF_CAM_UPHI]),\n                           &(input.cm.solar_wind),\n                           &(input.bpdf.u10),\n                           &(input.rte.mc.tenstream),\n                           input.rte.mc.tenstream_options,\n                           &(input.rte.mc.nca), /* Carolin Klinger 2019 */\n                           input.rte.mc.nca_options,\n                           &(input.rte.mc.ipa),\n                           &(input.rte.mc.absorption),\n                           &(input.rte.mc.backward.thermal_heating_method),\n                           &mc_loaddata,\n                           &(output->mc.sample),\n                           &(output->mc.elev),\n                           &(output->mc.triangular_surface),\n                           &(output->mc.surftemp),\n                           input.rte.mc.filename[FN_MC_BASENAME],\n                           input.rte.mc.filename[FN_MC_UMU],\n                           input.rte.mc.filename[FN_MC_SUNSHAPE_FILE],\n                           input.rte.mc.filename[FN_MC_ALBEDO],\n                           input.rte.mc.filename[FN_MC_AMBRALS],\n                           input.rte.mc.filename[FN_MC_ROSSLI],\n                           input.rte.mc.filename[FN_MC_ALBEDO_TYPE],\n                           input.rte.mc.filename[FN_MC_RPV2D_TYPE],\n                           input.rte.mc.filename[FN_MC_AMBRALS_TYPE],\n                           output->surfaces.label,\n                           &(output->surfaces.n),\n                           &(input.rte.mc.delta_scaling_mucut), /*TZ ds*/\n                           &(input.rte.mc.truncate),\n                           &(input.rte.mc.reflectalways),\n                           input.quiet,\n                           tmp_out->rfldir,\n                           tmp_out->rfldn,\n                           tmp_out->flup,\n                           tmp_out->uavgso,\n                           tmp_out->uavgdn,\n                           tmp_out->uavgup,\n                           tmp_out->rfldir3d,\n                           tmp_out->rfldn3d,\n                           tmp_out->flup3d,\n                           tmp_out->fl3d_is,\n                           tmp_out->uavgso3d,\n                           tmp_out->uavgdn3d,\n                           tmp_out->uavgup3d,\n                           tmp_out->radiance3d,\n                           rte_out->absback3d,\n                           tmp_out->abs3d,\n                           rte_out->radiance3d_is,\n                           rte_out->jacobian,\n                           tmp_out->rfldir3d_var,\n                           tmp_out->rfldn3d_var,\n                           tmp_out->flup3d_var,\n                           tmp_out->uavgso3d_var,\n                           tmp_out->uavgdn3d_var,\n                           tmp_out->uavgup3d_var,\n                           tmp_out->radiance3d_var,\n                           rte_out->absback3d_var,\n                           tmp_out->abs3d_var,\n                           rte_out->triangle_results,\n                           output->atm.Nxcld,\n                           output->atm.Nycld,\n                           output->atm.Nzcld,\n                           output->atm.dxcld,\n                           output->atm.dycld,\n                           input.filename[FN_PATH],\n                           input.filename[FN_RANDOMSTATUS],\n                           input.rte.mc.readrandomstatus,\n                           input.write_output_as_netcdf,\n                           write_files,\n                           input.rte.mc.visualize);\n\n          CHKERR (status);\n\n          /* add atmosphere and surface contributions to get total (rte_out) */\n          if (input.rte.mc.spectral_is)\n            for (iv_alis = 0; iv_alis < output->mc.alis.nlambda_abs; iv_alis++)\n              weight_spectral[iv_alis] = 1.0;\n\n          status = add_rte_output (rte_out,\n                                   tmp_out,\n                                   1.0,\n                                   weight_spectral,\n                                   input,\n                                   output->atm.nzout,\n                                   output->atm.Nxcld,\n                                   output->atm.Nycld,\n                                   output->atm.Nzcld,\n                                   output->mc.alis.Nc,\n                                   output->atm.nlyr - 1,\n                                   output->mc.alis.nlambda_abs,\n                                   output->atm.threed,\n                                   output->mc.sample.passback3D,\n                                   output->islower,\n                                   output->isupper,\n                                   output->jslower,\n                                   output->jsupper,\n                                   output->isstep,\n                                   output->jsstep);\n          CHKERR (status);\n\n          status = free_rte_output (tmp_out,\n                                    input,\n                                    output->atm.nzout,\n                                    output->atm.Nxcld,\n                                    output->atm.Nycld,\n                                    output->atm.Nzcld,\n                                    output->mc.sample.Nx,\n                                    output->mc.sample.Ny,\n                                    output->mc.alis.Nc,\n                                    output->atm.nlyr - 1,\n                                    output->mc.alis.nlambda_abs,\n                                    output->atm.threed,\n                                    output->mc.sample.passback3D);\n          CHKERR (status);\n        } /*TZ bt, no surface emission needed*/\n\n        break;\n\n      case MCFORWARD_ABS_EMISSION:\n\n        thermal_photons = 0;\n\n        /* 3D emission field */\n        if (!input.quiet)\n          fprintf (stderr, \" ... calculate 3D emission field \\n\");\n\n        source = MCSRC_THERMAL_ATMOSPHERE;\n\n        status = mystic (&output->atm.nlyr,\n                         threed,\n                         input.n_caoth + 2,\n                         output->mc.dt,\n                         output->mc.om,\n                         output->mc.g1,\n                         output->mc.g2,\n                         output->mc.ff,\n                         output->mc.ds,\n                         &(output->mc.alis),\n                         output->mc.refind,\n                         input.r_earth * 1000.0,\n                         input.rte.mc.refractive_index_pv,\n                         &(output->rayleigh_depol[iv]),\n                         output->caoth3d,\n                         output->mc.re,\n                         output->mc.temper,\n                         input.atmosphere3d,\n                         output->mc.z,\n                         output->mc.momaer,\n                         output->mc.nmomaer,\n                         output->mc.nthetaaer,\n                         output->mc.thetaaer,\n                         output->mc.muaer,\n                         output->mc.phaseaer,\n                         output->mc.nphamataer,\n                         &output->alb.albedo_r[iv],\n                         alb_type,\n                         output->atm.sza_r[iv],\n                         output->atm.phi0_r[iv],\n                         input.atm.sza_spher,\n                         input.atm.phi0_spher,\n                         thermal_photons,\n                         &source,\n                         &(output->wl.wvnmlo_r[iv]),\n                         &(output->wl.wvnmhi_r[iv]),\n                         &(output->wl.lambda_r[iv]),\n                         output->atm.zout_sur,\n                         &(output->atm.nzout),\n                         rpv_rho0,\n                         rpv_k,\n                         rpv_theta,\n                         rpv_scale,\n                         rpv_sigma,\n                         rpv_t1,\n                         rpv_t2,\n                         hapke_h,\n                         hapke_b0,\n                         hapke_w,\n                         rossli_iso,\n                         rossli_vol,\n                         rossli_geo,\n                         input.rossli.hotspot,\n                         &(input.cm.param[BRDF_CAM_U10]),\n                         &(input.cm.param[BRDF_CAM_PCL]),\n                         &(input.cm.param[BRDF_CAM_SAL]),\n                         &(input.cm.param[BRDF_CAM_UPHI]),\n                         &(input.cm.solar_wind),\n                         &(input.bpdf.u10),\n                         &(input.rte.mc.tenstream),\n                         input.rte.mc.tenstream_options,\n                         &(input.rte.mc.nca), /* Carolin Klinger 2019 */\n                         input.rte.mc.nca_options,\n                         &(input.rte.mc.ipa),\n                         &(input.rte.mc.absorption),\n                         &(input.rte.mc.backward.thermal_heating_method),\n                         &mc_loaddata,\n                         &(output->mc.sample),\n                         &(output->mc.elev),\n                         &(output->mc.triangular_surface),\n                         &(output->mc.surftemp),\n                         input.rte.mc.filename[FN_MC_BASENAME],\n                         input.rte.mc.filename[FN_MC_UMU],\n                         input.rte.mc.filename[FN_MC_SUNSHAPE_FILE],\n                         input.rte.mc.filename[FN_MC_ALBEDO],\n                         input.rte.mc.filename[FN_MC_AMBRALS],\n                         input.rte.mc.filename[FN_MC_ROSSLI],\n                         input.rte.mc.filename[FN_MC_ALBEDO_TYPE],\n                         input.rte.mc.filename[FN_MC_RPV2D_TYPE],\n                         input.rte.mc.filename[FN_MC_AMBRALS_TYPE],\n                         output->surfaces.label,\n                         &(output->surfaces.n),\n                         &(input.rte.mc.delta_scaling_mucut), /*TZ ds*/\n                         &(input.rte.mc.truncate),\n                         &(input.rte.mc.reflectalways),\n                         input.quiet,\n                         rte_out->rfldir,\n                         rte_out->rfldn,\n                         rte_out->flup,\n                         rte_out->uavgso,\n                         rte_out->uavgdn,\n                         rte_out->uavgup,\n                         rte_out->rfldir3d,\n                         rte_out->rfldn3d,\n                         rte_out->flup3d,\n                         rte_out->fl3d_is,\n                         rte_out->uavgso3d,\n                         rte_out->uavgdn3d,\n                         rte_out->uavgup3d,\n                         rte_out->radiance3d,\n                         rte_out->absback3d,\n                         rte_out->abs3d,\n                         rte_out->radiance3d_is,\n                         rte_out->jacobian,\n                         rte_out->rfldir3d_var,\n                         rte_out->rfldn3d_var,\n                         rte_out->flup3d_var,\n                         rte_out->uavgso3d_var,\n                         rte_out->uavgdn3d_var,\n                         rte_out->uavgup3d_var,\n                         rte_out->radiance3d_var,\n                         rte_out->absback3d_var,\n                         rte_out->abs3d_var,\n                         rte_out->triangle_results,\n                         output->atm.Nxcld,\n                         output->atm.Nycld,\n                         output->atm.Nzcld,\n                         output->atm.dxcld,\n                         output->atm.dycld,\n                         input.filename[FN_PATH],\n                         input.filename[FN_RANDOMSTATUS],\n                         input.rte.mc.readrandomstatus,\n                         input.write_output_as_netcdf,\n                         write_files,\n                         input.rte.mc.visualize);\n\n        CHKERR (status)\n\n        break;\n\n      default:\n        fprintf (stderr, \"Error, unknown absorption type %d\\n\", input.rte.mc.absorption);\n        CHKERR (-1);\n      }\n\n      break;\n\n    default:\n      CHKERROUT (-1, \"unknown source\");\n    }\n\n    /* free RPV arrays */\n    free (rpv_rho0);\n    free (rpv_k);\n    free (rpv_theta);\n    free (rpv_scale);\n    free (rpv_sigma);\n    free (rpv_t1);\n    free (rpv_t2);\n\n    /* free ROSSLI arrays */\n    free (rossli_iso);\n    free (rossli_vol);\n    free (rossli_geo);\n\n    /* free HAPKE arrays */\n    free (hapke_h);\n    free (hapke_b0);\n    free (hapke_w);\n\n    break;\n\n#else\n    fprintf (stderr, \"Error: MYSTIC solver not included in uvspec build.\\n\");\n    fprintf (stderr, \"Error: Please contact bernhard.mayer@lmu.de\\n\");\n    CHKERR (-1);\n#endif\n\n  case SOLVER_FDISORT1:\n  case SOLVER_FDISORT2:\n  case SOLVER_DISORT:\n\n    if (rte_solver != SOLVER_DISORT) {\n      disort_u0u = (float*)calloc (output->atm.nzout * input.rte.maxumu, sizeof (float));\n      disort_uu  = (float*)calloc (output->atm.nzout * input.rte.maxumu * input.rte.maxphi, sizeof (float));\n    }\n\n    /* ??? no need for thermal below 2um;                 ??? */\n    /* ??? need to do that to avoid numerical underflow;  ??? */\n    /* ??? however, this could be done without actually   ??? */\n    /* ??? calling the solver                             ??? */\n    if (rte_in->planck && output->wl.lambda_r[iv] < 2000.0) {\n      rte_in->planck = 0;\n      planck_tempoff = 1;\n    }\n\n    if (input.rte.solver == SOLVER_FDISORT1) {\n\n      if (iv == output->wl.nlambda_rte_lower && ib == 0) {\n        status = F77_FUNC (dcheck, DCHECK) (&output->atm.nlyr,\n                                            &output->atm.nzout,\n                                            &input.rte.nstr,\n                                            &input.rte.numu,\n                                            &input.rte.nphi,\n                                            &input.optimize_fortran,\n                                            &input.optimize_delta);\n        if (status != 0) {\n          fprintf (stderr, \"Error %d returned by dcheck in %s (%s)\\n\", status, function_name, file_name);\n          return status;\n        }\n      }\n\n      disort_pmom = c2fortran_3D_float_ary (output->atm.nlyr, 1, input.rte.nstr + 1, output->pmom);\n\n      if (((input.source == SRC_SOLAR) && (rte_in->umu0 > 0)) || (input.source == SRC_THERMAL)) {\n        /* no need to call disort otherwise as sun below horizon */\n        F77_FUNC (disort, DISORT)\n        (&output->atm.nlyr,\n         output->dtauc,\n         output->ssalb,\n         disort_pmom,\n         output->atm.microphys.temper[0][0],\n         &(output->wl.wvnmlo_r[iv]),\n         &(output->wl.wvnmhi_r[iv]),\n         &(rte_in->usrtau),\n         &output->atm.nzout,\n         rte_in->utau,\n         &input.rte.nstr,\n         &(rte_in->usrang),\n         &input.rte.numu,\n         input.rte.umu,\n         &input.rte.nphi,\n         input.rte.phi,\n         &(rte_in->ibcnd),\n         &(rte_in->fbeam),\n         &(rte_in->umu0),\n         &output->atm.phi0_r[iv],\n         &(rte_in->fisot),\n         &(rte_in->lamber),\n         &output->alb.albedo_r[iv],\n         rte_in->hl,\n         &(rte_in->btemp),\n         &(rte_in->ttemp),\n         &(rte_in->temis),\n         &input.rte.deltam,\n         &(rte_in->planck),\n         &(rte_in->onlyfl),\n         &(rte_in->accur),\n         rte_in->prndis,\n         rte_in->header,\n         &output->atm.nlyr,\n         &output->atm.nzout,\n         &input.rte.maxumu,\n         &input.rte.nstr,\n         &input.rte.maxphi,\n         rte_out->rfldir,\n         rte_out->rfldn,\n         rte_out->flup,\n         rte_out->dfdt,\n         rte_out->uavg,\n         disort_uu,\n         disort_u0u,\n         rte_out->albmed,\n         rte_out->trnmed,\n         rte_out->uavgdn,\n         rte_out->uavgso,\n         rte_out->uavgup,\n         &(input.quiet));\n\n        for (lev = 0; lev < output->atm.nzout; lev++)\n          rte_out->uavg[lev] = rte_out->uavgso[lev] + rte_out->uavgdn[lev] + rte_out->uavgup[lev];\n      }\n    } else if (input.rte.solver == SOLVER_FDISORT2) {\n\n      if (iv == output->wl.nlambda_rte_lower && ib == 0) {\n        status = F77_FUNC (dcheck, DCHECK) (&output->atm.nlyr,\n                                            &output->atm.nzout,\n                                            &input.rte.nstr,\n                                            &input.rte.numu,\n                                            &input.rte.nphi,\n                                            &input.optimize_fortran,\n                                            &input.optimize_delta);\n        if (status != 0) {\n          fprintf (stderr, \"Error %d returned by dcheck in %s (%s)\\n\", status, function_name, file_name);\n          return status;\n        }\n      }\n\n      /* BRDF or Lambertian albedo */\n      if (input.disort2_brdf != BRDF_NONE)\n        rte_in->lamber = 0;\n      else\n        rte_in->lamber = 1;\n\n      disort2_pmom = c2fortran_3D_float_ary (output->atm.nlyr, 1, output->atm.nmom + 1, output->pmom);\n\n      switch (input.rte.disort_icm) {\n      case DISORT_ICM_OFF:\n        intensity_correction = FALSE;\n        break;\n      case DISORT_ICM_MOMENTS:\n        intensity_correction     = TRUE;\n        old_intensity_correction = TRUE;\n        break;\n      case DISORT_ICM_PHASE:\n        intensity_correction     = TRUE;\n        old_intensity_correction = FALSE;\n        disort2_ntheta           = &(output->ntheta[0][0]);\n        disort2_phaso            = c2fortran_3D_float_ary (output->atm.nlyr, 1, output->ntheta[0][0], output->phase);\n        disort2_mup              = c2fortran_3D_double_ary (1, 1, output->ntheta[0][0], output->mu);\n        break;\n      default:\n        fprintf (stderr, \"Error: unknown disort_icm %d\\n\", input.rte.disort_icm);\n        fprintf (stderr, \"       (line %d, function '%s' in '%s')\\n\", __LINE__, __func__, __FILE__);\n        return -1;\n      }\n\n      if (((input.source == SRC_SOLAR) && (rte_in->umu0 > 0)) || (input.source == SRC_THERMAL)) {\n        /* no need to call disort2 otherwise, as sun below horizon */\n        F77_FUNC (disort2, DISORT2)\n        (&output->atm.nlyr,\n         output->dtauc,\n         output->ssalb,\n         &output->atm.nmom,\n         disort2_pmom,\n         disort2_ntheta,\n         disort2_phaso,\n         disort2_mup,\n         output->atm.microphys.temper[0][0],\n         &output->wl.wvnmlo_r[iv],\n         &output->wl.wvnmhi_r[iv],\n         &rte_in->usrtau,\n         &output->atm.nzout,\n         rte_in->utau,\n         &input.rte.nstr,\n         &rte_in->usrang,\n         &input.rte.numu,\n         input.rte.umu,\n         &input.rte.nphi,\n         input.rte.phi,\n         &rte_in->ibcnd,\n         &rte_in->fbeam,\n         &rte_in->umu0,\n         &output->atm.phi0_r[iv],\n         &rte_in->fisot,\n         &rte_in->lamber,\n         &output->alb.albedo_r[iv],\n         &rte_in->btemp,\n         &rte_in->ttemp,\n         &rte_in->temis,\n         &rte_in->planck,\n         &rte_in->onlyfl,\n         &rte_in->accur,\n         rte_in->prndis2,\n         rte_in->header,\n         &output->atm.nlyr,\n         &output->atm.nzout,\n         &input.rte.maxumu,\n         &input.rte.maxphi,\n         &output->atm.nmom,\n         rte_out->rfldir,\n         rte_out->rfldn,\n         rte_out->flup,\n         rte_out->dfdt,\n         rte_out->uavg,\n         disort_uu,\n         disort_u0u,\n         rte_out->albmed,\n         rte_out->trnmed,\n         rte_out->uavgdn,\n         rte_out->uavgso,\n         rte_out->uavgup,\n         &(input.disort2_brdf),\n         &(output->rpv.rho0_r[iv]),\n         &(output->rpv.k_r[iv]),\n         &(output->rpv.theta_r[iv]),\n         &(output->rpv.sigma_r[iv]),\n         &(output->rpv.t1_r[iv]),\n         &(output->rpv.t2_r[iv]),\n         &(output->rpv.scale_r[iv]),\n         &(output->rossli.iso_r[iv]),\n         &(output->rossli.vol_r[iv]),\n         &(output->rossli.geo_r[iv]),\n         &(input.cm.param[BRDF_CAM_U10]),\n         &(input.cm.param[BRDF_CAM_PCL]),\n         &(input.cm.param[BRDF_CAM_SAL]),\n         &intensity_correction,\n         &old_intensity_correction,\n         &(input.quiet));\n        for (lev = 0; lev < output->atm.nzout; lev++)\n          rte_out->uavg[lev] = rte_out->uavgso[lev] + rte_out->uavgdn[lev] + rte_out->uavgup[lev];\n      }\n    } else if (input.rte.solver == SOLVER_DISORT) {\n\n      if (input.flu.source != NOT_DEFINED_INTEGER) {  // We have included fluorescence as radiation source\n        rte_in->fbeam = output->wl.fbeam[iv];         // Need to do calibrated simulation.\n      }\n\n      if (input.raman) {\n\n        rte_in->gsrc              = 0;\n        ds_in.flag.general_source = FALSE; /* No extra source term for zero Raman scattering. */\n\n        if (ir == 0 && input.raman_fast) {\n          rte_in->fbeam = output->wl.fbeam[ib];\n        } else if (ir == 0 && !input.raman_fast) {\n\n          if (ib == 0) {\n            if ((status = ASCII_calloc_double_3D (&tmp_crs, output->atm.nlev, output->crs.number_of_ramanwavelengths, 3)) != 0) {\n              fprintf (stderr, \"Error %d allocating memory for tmp_crs\\n\", status);\n              fprintf (stderr, \"       (line %d, function '%s' in '%s')\\n\", __LINE__, __func__, __FILE__);\n              return status;\n            }\n\n            /* First time for each user wavelength calculate Raman shifted wavelengths and Raman cross section */\n            for (lu = 0; lu < output->atm.nlev; lu++) {\n              ivi    = 0;\n              status = crs_raman_N2 (output->wl.lambda_r[iv],\n                                     input.n_raman_transitions_N2,\n                                     output->atm.microphys.temper[lu][0][0],\n                                     &tmp_crs[lu],\n                                     &ivi,\n                                     verbose);\n              status = crs_raman_O2 (output->wl.lambda_r[iv],\n                                     input.n_raman_transitions_O2,\n                                     output->atm.microphys.temper[lu][0][0],\n                                     &tmp_crs[lu],\n                                     &ivi,\n                                     verbose);\n\n              /* Put the wanted wavelength last in the tmp_crs by doing the following */\n              /* and set correctly after sort                                         */\n              tmp_crs[lu][output->crs.number_of_ramanwavelengths - 1][0] = 999e+9;\n\n              /* sort cross section data in ascending order */\n              status = ASCII_sortarray (tmp_crs[lu], output->crs.number_of_ramanwavelengths, 3, 0, 0);\n\n              for (ivi = 0; ivi < output->crs.number_of_ramanshifts; ivi++) {\n                output->crs.wvl_of_ramanshifts[ivi] = tmp_crs[0][ivi][0];\n                output->crs.crs_raman_RL[lu][ivi]   = tmp_crs[lu][ivi][1];\n                output->crs.crs_raman_RG[lu][ivi]   = tmp_crs[lu][ivi][2];\n              }\n              ivi                                 = output->crs.number_of_ramanwavelengths - 1;\n              output->crs.wvl_of_ramanshifts[ivi] = output->wl.lambda_r[iv];\n              output->crs.crs_raman_RL[lu][ivi]   = 0.0;\n              output->crs.crs_raman_RG[lu][ivi]   = 0.0;\n            }\n            if (tmp_crs != NULL)\n              ASCII_free_double_3D (tmp_crs, output->atm.nlev, output->crs.number_of_ramanwavelengths);\n          }\n\n          /* Interpolate all optical quantities to the Raman shifted wavelength */\n\n          qwanted_wvl[0] = (float)output->crs.wvl_of_ramanshifts[ib];\n          status =\n            arb_wvn (output->wl.nlambda_r, output->wl.lambda_r, output->wl.fbeam, 1, qwanted_wvl, qfbeam, INTERP_METHOD_LINEAR, 0);\n          if (status != 0) {\n            fprintf (stderr, \" Error, interpolation of 'fbeam' for raman option\\n\");\n            fprintf (stderr, \"       (line %d, function '%s' in '%s')\\n\", __LINE__, __func__, __FILE__);\n            return -1;\n          }\n\n          /* FIXME, redistribute photons instead of interpolating spectrum */\n          rte_in->fbeam = qfbeam[0];\n          status        = arb_wvn (output->wl.nlambda_r,\n                            output->wl.lambda_r,\n                            output->alb.albedo_r,\n                            1,\n                            qwanted_wvl,\n                            qalbedo,\n                            INTERP_METHOD_LINEAR,\n                            0);\n          if (status != 0) {\n            fprintf (stderr, \" Error, interpolation of 'albedo_r' for raman option\\n\");\n            fprintf (stderr, \"       (line %d, function '%s' in '%s')\\n\", __LINE__, __func__, __FILE__);\n            return -1;\n          }\n\n          /* Find iv indices closest to ib wavelength above and below */\n          iv1 = closest_above (qwanted_wvl[0], output->wl.lambda_r, output->wl.nlambda_r);\n          iv2 = closest_below (qwanted_wvl[0], output->wl.lambda_r, output->wl.nlambda_r);\n          /* Calculate optical properties for closest wavelength above and below wanted wavelength,*/\n          /* and interpolate optical properties to wanted wavelength.       */\n          status = optical_properties (input,\n                                       output,\n                                       qwanted_wvl[0],\n                                       ir,\n                                       iv1,\n                                       iv2,\n                                       0,\n                                       verbose,\n                                       skip_optical_properties); /* in ancillary.c */\n\n          if (status != 0) {\n            fprintf (stderr,\n                     \"Error %d returned by optical_properties_raman (line %d, function %s in %s)\\n\",\n                     status,\n                     __LINE__,\n                     __func__,\n                     __FILE__);\n            return status;\n          }\n\n          /* We also need utau at the \"new\" interpolated optical depth. */\n          /* \"very old\" version, recycled */\n          /* zd is altitude which defines  dtauc */\n          /* zout is the altitudes at which tau is wanted */\n          F77_FUNC (setout, SETOUT)\n          (output->dtauc, &(output->atm.nlyr), &(output->atm.nzout), rte_in->utau, output->atm.zd, output->atm.zout_sur);\n        }\n\n        else if (ir == 1) {\n\n          rte_in->fbeam             = 0.0;\n          rte_in->gsrc              = 1;\n          ds_in.flag.general_source = TRUE; /* Include extra source term for first order Raman scattering. */\n\n          if ((status = ASCII_calloc_double_3D (&(rte_in->qsrc), input.rte.nstr, output->atm.nzout, input.rte.nstr)) != 0)\n            return status;\n\n          if (rte_in->usrang) {\n            if ((status = ASCII_calloc_double_3D (&(rte_in->qsrcu), input.rte.nstr, output->atm.nzout, input.rte.numu)) != 0)\n              return status;\n          }\n\n          if (input.raman_fast) {\n\n            /* Calculate Raman crs at wanted wavelength. */\n            if ((status = ASCII_calloc_double_3D (&tmp_crs, output->atm.nlev, output->crs.number_of_ramanwavelengths, 3)) != 0) {\n              fprintf (stderr, \"Error %d allocating memory for tmp_crs\\n\", status);\n              fprintf (stderr, \"       (line %d, function '%s' in '%s')\\n\", __LINE__, __func__, __FILE__);\n              return status;\n            }\n\n            /* For each user wavelength calculate Raman shifted wavelengths and Raman cross section */\n            for (lu = 0; lu < output->atm.nlev; lu++) {\n              ivi    = 0;\n              status = crs_raman_N2 (output->wl.lambda_r[iv + output->wl.nlambda_rte_lower],\n                                     input.n_raman_transitions_N2,\n                                     output->atm.microphys.temper[0][0][lu],\n                                     &tmp_crs[lu],\n                                     &ivi,\n                                     verbose);\n              status = crs_raman_O2 (output->wl.lambda_r[iv + output->wl.nlambda_rte_lower],\n                                     input.n_raman_transitions_O2,\n                                     output->atm.microphys.temper[0][0][lu],\n                                     &tmp_crs[lu],\n                                     &ivi,\n                                     verbose);\n\n              /* Put the wanted wavelength last in the tmp_crs by doing the following */\n              /* and set correctly after sort                                         */\n              tmp_crs[lu][output->crs.number_of_ramanwavelengths - 1][0] = 999e+9;\n\n              /* sort cross section data in ascending order */\n              status = ASCII_sortarray (tmp_crs[lu], output->crs.number_of_ramanwavelengths, 3, 0, 0);\n\n              for (ivi = 0; ivi < output->crs.number_of_ramanshifts; ivi++) {\n                output->crs.wvl_of_ramanshifts[ivi] = tmp_crs[0][ivi][0];\n                output->crs.crs_raman_RL[lu][ivi]   = tmp_crs[lu][ivi][1];\n                // Cross sections are reversed in wavelength. This because photons are scattered into the\n                // wavelength of interest, lambda_1, from these wavelengths (lambda_j). If lambda_j >\n                // lambda_1, then the photon gains energy. Thus, the original cross section indices\n                // must be reversed to account for this, and vice versa. AK, 20130513.\n                output->crs.crs_raman_RG[lu][output->crs.number_of_ramanshifts - ivi] = tmp_crs[lu][ivi][2];\n              }\n              ivi                                 = output->crs.number_of_ramanwavelengths - 1;\n              output->crs.wvl_of_ramanshifts[ivi] = output->wl.lambda_r[iv];\n              output->crs.crs_raman_RL[lu][ivi]   = 0.0;\n              output->crs.crs_raman_RG[lu][ivi]   = 0.0;\n            }\n            if (tmp_crs != NULL)\n              ASCII_free_double_3D (tmp_crs, output->atm.nlev, output->crs.number_of_ramanwavelengths);\n\n            /* Interpolate raman_qsrc_comp at wl.lambda_r resolution to raman_wavelength grid */\n\n            tmp_raman_qsrc_comp = calloc_raman_qsrc_components (input.raman_fast,\n                                                                output->atm.nzout,\n                                                                input.rte.maxumu,\n                                                                input.rte.nphi,\n                                                                input.rte.nstr,\n                                                                output->crs.number_of_ramanwavelengths);\n\n            /* Interpolate dtauc */\n            if ((tmp_in_int = (double*)calloc (output->wl.nlambda_r, sizeof (double))) == NULL)\n              return ASCII_NO_MEMORY;\n            if ((tmp_wl = (double*)calloc (output->wl.nlambda_r, sizeof (double))) == NULL)\n              return ASCII_NO_MEMORY;\n            if ((tmp_out_int = (double*)calloc (output->crs.number_of_ramanshifts + 1, sizeof (double))) == NULL)\n              return ASCII_NO_MEMORY;\n            for (ivi = 0; ivi < output->wl.nlambda_r; ivi++)\n              tmp_wl[ivi] = output->wl.lambda_r[ivi];\n            for (lu = 0; lu < output->atm.nzout - 1; lu++) {\n              for (ivi = 0; ivi < output->wl.nlambda_r; ivi++)\n                tmp_in_int[ivi] = raman_qsrc_comp->dtauc[lu][ivi];\n              status = arb_wvn_double (output->wl.nlambda_r,\n                                       tmp_wl,\n                                       tmp_in_int,\n                                       output->crs.number_of_ramanshifts,\n                                       output->crs.wvl_of_ramanshifts,\n                                       tmp_out_int,\n                                       INTERP_METHOD_LINEAR,\n                                       0);\n              for (ivi = 0; ivi < output->crs.number_of_ramanshifts; ivi++)\n                tmp_raman_qsrc_comp->dtauc[lu][ivi] = tmp_out_int[ivi];\n              /* The wavelength we are calculating is stored last in the ary */\n              tmp_raman_qsrc_comp->dtauc[lu][output->crs.number_of_ramanshifts] = raman_qsrc_comp->dtauc[lu][iv];\n            }\n            /* Interpolate fbeam */\n            for (ivi = 0; ivi < output->wl.nlambda_r; ivi++)\n              tmp_in_int[ivi] = raman_qsrc_comp->fbeam[ivi];\n            status = arb_wvn_double (output->wl.nlambda_r,\n                                     tmp_wl,\n                                     tmp_in_int,\n                                     output->crs.number_of_ramanshifts,\n                                     output->crs.wvl_of_ramanshifts,\n                                     tmp_out_int,\n                                     INTERP_METHOD_LINEAR,\n                                     0);\n            for (ivi = 0; ivi < output->crs.number_of_ramanshifts; ivi++)\n              tmp_raman_qsrc_comp->fbeam[ivi] = tmp_out_int[ivi];\n            /* The wavelength we are calculating is stored last in the ary */\n            tmp_raman_qsrc_comp->fbeam[output->crs.number_of_ramanshifts] = raman_qsrc_comp->fbeam[iv];\n            /* Interpolate uum */\n            for (lu = 0; lu < output->atm.nzout; lu++) {\n              for (maz = 0; maz < input.rte.nstr; maz++) {\n                for (iq = 0; iq < input.rte.numu; iq++) {\n                  for (ivi = 0; ivi < output->wl.nlambda_r; ivi++)\n                    tmp_in_int[ivi] = raman_qsrc_comp->uum[lu][maz][iq][ivi];\n                  status = arb_wvn_double (output->wl.nlambda_r,\n                                           tmp_wl,\n                                           tmp_in_int,\n                                           output->crs.number_of_ramanshifts,\n                                           output->crs.wvl_of_ramanshifts,\n                                           tmp_out_int,\n                                           INTERP_METHOD_LINEAR,\n                                           0);\n                  for (ivi = 0; ivi < output->crs.number_of_ramanshifts; ivi++)\n                    tmp_raman_qsrc_comp->uum[lu][maz][iq][ivi] = tmp_out_int[ivi];\n                  /* The wavelength we are calculating is stored last in the ary */\n                  tmp_raman_qsrc_comp->uum[lu][maz][iq][output->crs.number_of_ramanshifts] = raman_qsrc_comp->uum[lu][maz][iq][iv];\n                }\n              }\n            }\n            qwanted_wvl[0] = tmp_wl[iv]; /* Needed later in set_raman_source */\n            free (tmp_in_int);\n            free (tmp_out_int);\n            free (tmp_wl);\n\n            status = optical_properties (input,\n                                         output,\n                                         output->wl.lambda_r[iv],\n                                         ir,\n                                         iv,\n                                         iv,\n                                         0,\n                                         verbose,\n                                         skip_optical_properties); /* in ancillary.c */\n            if (status != 0) {\n              fprintf (stderr,\n                       \"Error %d returned by optical_properties (line %d, function %s in %s)\\n\",\n                       status,\n                       __LINE__,\n                       __func__,\n                       __FILE__);\n              return status;\n            }\n            /* We also need utau. */\n            /* \"very old\" version, recycled */\n            F77_FUNC (setout, SETOUT)\n            (output->dtauc, &(output->atm.nlyr), &(output->atm.nzout), rte_in->utau, output->atm.zd, output->atm.zout_sur);\n\n            /* Set the general inhomogeneous source applicable for Raman scattering   */\n            if (iv == output->wl.raman_end_id)\n              last = 1;\n            status = set_raman_source (rte_in->qsrc,\n                                       rte_in->qsrcu,\n                                       input.rte.maxphi,\n                                       output->atm.nlyr + 1,\n                                       output->atm.nzout,\n                                       input.rte.nstr,\n                                       output->crs.number_of_ramanshifts,\n                                       qwanted_wvl[0],\n                                       output->crs.wvl_of_ramanshifts,\n                                       rte_in->umu0,\n                                       output->atm.zd,\n                                       output->atm.zout_sur,\n                                       output->atm.sza_r[iv],\n                                       output->wl.fbeam[iv],\n                                       input.r_earth,\n                                       output->atm.microphys.dens[MOL_AIR][0][0],\n                                       output->crs.crs_raman_RL,\n                                       output->crs.crs_raman_RG,\n                                       output->ssalb,\n                                       input.rte.numu,\n                                       input.rte.umu,\n                                       rte_in->usrang,\n                                       input.rte.cmuind,\n                                       output->pmom,\n                                       tmp_raman_qsrc_comp,\n                                       output->atm.zout_comp_index,\n                                       output->alt.altitude,\n                                       last,\n                                       verbose);\n\n            free_raman_qsrc_components (tmp_raman_qsrc_comp,\n                                        input.raman_fast,\n                                        output->atm.nzout,\n                                        input.rte.maxumu,\n                                        input.rte.nphi,\n                                        input.rte.nstr);\n\n          } /* END if ( input.raman_fast )  */\n          else {\n\n            /* Find iv indices closest to ib wavelength above and below */\n            qwanted_wvl[0] = (float)output->crs.wvl_of_ramanshifts[output->crs.number_of_ramanwavelengths - 1];\n            iv1            = closest_above (qwanted_wvl[0], output->wl.lambda_r, output->wl.nlambda_r);\n            iv2            = closest_below (qwanted_wvl[0], output->wl.lambda_r, output->wl.nlambda_r);\n            /* Calculate optical properties for closest wavelength above and below wanted wavelength,*/\n            /* and interpolate optical properties to wanted wavelength.       */\n            status = optical_properties (input,\n                                         output,\n                                         qwanted_wvl[0],\n                                         ir,\n                                         iv1,\n                                         iv2,\n                                         0,\n                                         verbose,\n                                         skip_optical_properties); /* in ancillary.c */\n            if (status != 0) {\n              fprintf (stderr,\n                       \"Error %d returned by optical_properties (line %d, function %s in %s)\\n\",\n                       status,\n                       __LINE__,\n                       __func__,\n                       __FILE__);\n              return status;\n            }\n\n            /* We also need utau at the \"new\" interpolated optical depth. */\n            /* \"very old\" version, recycled */\n\n            F77_FUNC (setout, SETOUT)\n            (output->dtauc, &(output->atm.nlyr), &(output->atm.nzout), rte_in->utau, output->atm.zd, output->atm.zout_sur);\n\n            /* Set the general inhomogeneous source applicable for Raman scattering   */\n\n            status = set_raman_source (rte_in->qsrc,\n                                       rte_in->qsrcu,\n                                       input.rte.maxphi,\n                                       output->atm.nlyr + 1,\n                                       output->atm.nzout,\n                                       input.rte.nstr,\n                                       output->crs.number_of_ramanshifts,\n                                       qwanted_wvl[0],\n                                       output->crs.wvl_of_ramanshifts,\n                                       rte_in->umu0,\n                                       output->atm.zd,\n                                       output->atm.zout_sur,\n                                       output->atm.sza_r[iv],\n                                       output->wl.fbeam[iv],\n                                       input.r_earth,\n                                       output->atm.microphys.dens[MOL_AIR][0][0],\n                                       output->crs.crs_raman_RL,\n                                       output->crs.crs_raman_RG,\n                                       output->ssalb,\n                                       input.rte.numu,\n                                       input.rte.umu,\n                                       rte_in->usrang,\n                                       input.rte.cmuind,\n                                       output->pmom,\n                                       raman_qsrc_comp,\n                                       output->atm.zout_comp_index,\n                                       output->alt.altitude,\n                                       last,\n                                       verbose);\n          }\n        } /*  END    if ( input.raman_fast ) {} else    */\n      }   /*  END    if ( input.raman )    */\n\n      /* BRDF or Lambertian albedo */\n      if (input.disort2_brdf != BRDF_NONE)\n        rte_in->lamber = 0;\n      else\n        rte_in->lamber = 1;\n\n      ds_in.nlyr  = output->atm.nlyr;\n      ds_in.ntau  = output->atm.nzout;\n      ds_in.nstr  = input.rte.nstr;\n      ds_in.numu  = input.rte.numu;\n      ds_in.nmom  = output->atm.nmom;\n      ds_in.nphi  = input.rte.nphi;\n      ds_in.accur = rte_in->accur;\n      if (input.rte.disort_icm == DISORT_ICM_PHASE)\n        ds_in.nphase = output->ntheta[0][0];\n\n      /* choose how to do intensity correction */\n      switch (input.rte.disort_icm) {\n      case DISORT_ICM_OFF:\n        ds_in.flag.intensity_correction = FALSE;\n        break;\n      case DISORT_ICM_MOMENTS:\n        ds_in.flag.intensity_correction     = TRUE;\n        ds_in.flag.old_intensity_correction = TRUE;\n        break;\n      case DISORT_ICM_PHASE:\n        ds_in.flag.intensity_correction     = TRUE;\n        ds_in.flag.old_intensity_correction = FALSE;\n        break;\n      default:\n        fprintf (stderr, \"Error: unknown disort_icm %d\\n\", input.rte.disort_icm);\n        fprintf (stderr, \"       (line %d, function '%s' in '%s')\\n\", __LINE__, __func__, __FILE__);\n        return -1;\n      }\n\n      ds_in.flag.quiet  = input.quiet;\n      ds_in.flag.ibcnd  = rte_in->ibcnd;\n      ds_in.flag.planck = rte_in->planck;\n      ds_in.flag.lamber = rte_in->lamber;\n      ds_in.flag.usrtau = rte_in->usrtau;\n      ds_in.flag.usrang = rte_in->usrang;\n      ds_in.flag.onlyfl = rte_in->onlyfl;\n      if (input.raman) {\n        ds_in.flag.output_uum = TRUE;\n        if (ir == 1) {\n          ds_in.flag.general_source = TRUE;\n          ds_in.bc.fluor            = 0.0;  // Only fluorescence source for the zeroth iteration\n                                            // Otherwise source is included twice.\n        } else {\n          ds_in.flag.general_source = FALSE;\n          ds_in.bc.fluor            = (double)output->flu.fluorescence_r[ib];\n        }\n        ds_in.bc.albedo = (double)output->alb.albedo_r[ib];\n      } else {\n        ds_in.flag.output_uum     = FALSE;\n        ds_in.flag.general_source = FALSE;\n        ds_in.bc.albedo           = (double)output->alb.albedo_r[iv];\n        ds_in.bc.fluor            = (double)output->flu.fluorescence_r[iv];\n      }\n      ds_in.flag.spher = rte_in->spher;\n      ds_in.radius     = c_r_earth;\n\n      /* ds_in.flag.spher   = input.rte.pseudospherical; */\n\n      ds_in.bc.btemp       = (double)rte_in->btemp;\n      ds_in.bc.fbeam       = (double)rte_in->fbeam;\n      ds_in.bc.fisot       = (double)rte_in->fisot;\n      ds_in.bc.temis       = (double)rte_in->temis;\n      ds_in.bc.ttemp       = (double)rte_in->ttemp;\n      ds_in.bc.umu0        = (double)rte_in->umu0;\n      ds_in.bc.phi0        = (double)output->atm.phi0_r[iv];\n      ds_in.wvnmlo         = output->wl.wvnmlo_r[iv];\n      ds_in.wvnmhi         = output->wl.wvnmhi_r[iv];\n      ds_in.flag.prnt[0]   = rte_in->prndis2[0];\n      ds_in.flag.prnt[1]   = rte_in->prndis2[1];\n      ds_in.flag.prnt[2]   = rte_in->prndis2[2];\n      ds_in.flag.prnt[3]   = rte_in->prndis2[3];\n      ds_in.flag.prnt[4]   = rte_in->prndis2[4];\n      ds_in.flag.brdf_type = input.disort2_brdf;\n\n      c_disort_state_alloc (&ds_in);\n      c_disort_out_alloc (&ds_in, &ds_out);\n\n      for (lc = 0; lc < output->atm.nlyr; lc++) {\n        ds_in.dtauc[lc] = (double)output->dtauc[lc];\n        ds_in.ssalb[lc] = (double)output->ssalb[lc];\n\n        for (k = 0; k <= output->atm.nmom; k++) {\n          ds_in.pmom[k + lc * (ds_in.nmom_nstr + 1)] = (double)output->pmom[lc][0][k];\n        }\n      }\n      for (lc = 0; lc < output->atm.nzout; lc++) {\n        ds_in.utau[lc] = (double)rte_in->utau[lc];\n      }\n      for (iu = 0; iu < input.rte.numu; iu++) {\n        ds_in.umu[iu] = (double)input.rte.umu[iu];\n      }\n      for (iu = 0; iu < input.rte.nphi; iu++) {\n        ds_in.phi[iu] = (double)input.rte.phi[iu];\n      }\n      for (lu = 0; lu <= output->atm.nlyr; lu++) {\n        if (rte_in->planck)\n          ds_in.temper[lu] = (double)output->atm.microphys.temper[0][0][lu];\n      }\n      if (ds_in.flag.spher) {\n        for (lu = 0; lu <= output->atm.nlyr; lu++) {\n          ds_in.zd[lu] = (double)output->atm.zd[lu];\n        }\n      }\n      if (input.rte.disort_icm == DISORT_ICM_PHASE) {\n        for (imu = 0; imu < ds_in.nphase; imu++)\n          ds_in.mu_phase[imu] = output->mu[0][0][imu];\n        for (imu = 0; imu < ds_in.nphase; imu++)\n          for (lc = 0; lc < ds_in.nlyr; lc++) {\n            ds_in.phase[imu + lc * (ds_in.nphase)] = (double)output->phase[lc][0][imu];\n          }\n      }\n\n      /* albedo stuff */\n      switch (ds_in.flag.brdf_type) {\n      case BRDF_RPV:\n        ds_in.brdf.rpv->rho0  = output->rpv.rho0_r[iv];\n        ds_in.brdf.rpv->k     = output->rpv.k_r[iv];\n        ds_in.brdf.rpv->theta = output->rpv.theta_r[iv];\n        ds_in.brdf.rpv->sigma = output->rpv.sigma_r[iv];\n        ds_in.brdf.rpv->t1    = output->rpv.t1_r[iv];\n        ds_in.brdf.rpv->t2    = output->rpv.t2_r[iv];\n        ds_in.brdf.rpv->scale = output->rpv.scale_r[iv];\n        break;\n      case BRDF_CAM:\n        ds_in.brdf.cam->u10  = input.cm.param[BRDF_CAM_U10];\n        ds_in.brdf.cam->pcl  = input.cm.param[BRDF_CAM_PCL];\n        ds_in.brdf.cam->xsal = input.cm.param[BRDF_CAM_SAL];\n        break;\n      case BRDF_HAPKE:\n        ds_in.brdf.hapke->b0 = output->hapke.b0_r[iv];\n        ds_in.brdf.hapke->h  = output->hapke.h_r[iv];\n        ds_in.brdf.hapke->w  = output->hapke.w_r[iv];\n        break;\n      case BRDF_ROSSLI:\n        ds_in.brdf.rossli->iso     = output->rossli.iso_r[iv];\n        ds_in.brdf.rossli->vol     = output->rossli.vol_r[iv];\n        ds_in.brdf.rossli->geo     = output->rossli.geo_r[iv];\n        ds_in.brdf.rossli->hotspot = input.rossli.hotspot;\n        break;\n      default:\n        break;\n      }\n\n      if (input.raman && ir == 1) {\n        for (maz = 0; maz < ds_in.nstr; maz++) {\n          for (lc = 0; lc < ds_in.nlyr; lc++) {\n            for (iq = 0; iq < ds_in.nstr; iq++) {\n              ds_in.gensrc[iq + (lc + maz * ds_in.nlyr) * ds_in.nstr] = (double)rte_in->qsrc[maz][lc][iq];\n            }\n          }\n        }\n        for (maz = 0; maz < ds_in.nstr; maz++) {\n          for (lc = 0; lc < ds_in.nlyr; lc++) {\n            for (iu = 0; iu < ds_in.numu; iu++) {\n              ds_in.gensrcu[iu + (lc + maz * ds_in.nlyr) * ds_in.numu] = (double)rte_in->qsrcu[maz][lc][iu];\n            }\n          }\n        }\n      }\n\n      if (ir == 1) {\n        if (rte_in->qsrc != NULL)\n          ASCII_free_double_3D (rte_in->qsrc, input.rte.nstr, output->atm.nzout);\n        if (rte_in->qsrcu != NULL)\n          ASCII_free_double_3D (rte_in->qsrcu, input.rte.nstr, output->atm.nzout);\n      }\n\n      if (((input.source == SRC_SOLAR) && (rte_in->umu0 > 0)) /* no need to call plane-parralel cdisort, as sun below horizon */\n          || ((input.source == SRC_SOLAR) && (input.rte.pseudospherical)) /* pseudo-spherical cdisort  */\n          || (input.source == SRC_THERMAL)) {\n        c_disort (&ds_in, &ds_out);\n      }\n\n      if (rte_in->ibcnd) {\n        for (iu = 0; iu < input.rte.numu; iu++) {\n          rte_out->albmed[iu] = (float)ds_out.albmed[iu];\n          rte_out->trnmed[iu] = (float)ds_out.trnmed[iu];\n        }\n      }\n      for (lu = 0; lu < output->atm.nzout; lu++) {\n        rte_out->dfdt[lu]   = (float)ds_out.rad[lu].dfdt;\n        rte_out->rfldir[lu] = (float)ds_out.rad[lu].rfldir;\n        rte_out->rfldn[lu]  = (float)ds_out.rad[lu].rfldn;\n        rte_out->flup[lu]   = (float)ds_out.rad[lu].flup;\n        rte_out->uavg[lu]   = (float)ds_out.rad[lu].uavg;\n        rte_out->uavgdn[lu] = (float)ds_out.rad[lu].uavgdn;\n        rte_out->uavgup[lu] = (float)ds_out.rad[lu].uavgup;\n        rte_out->uavgso[lu] = (float)ds_out.rad[lu].uavgso;\n\n        for (j = 0; j < input.rte.nphi; j++)\n          for (iu = 0; iu < input.rte.numu; iu++)\n            rte_out->uu[j][lu][iu] = ds_out.uu[iu + (lu + j * ds_in.ntau) * ds_in.numu];\n\n        if (input.raman)\n          for (j = 0; j < input.rte.nstr; j++)  // j is the same as mazim in c_disort\n            for (iu = 0; iu < input.rte.numu; iu++)\n              rte_out->uum[j][lu][iu] = ds_out.uum[iu + (lu + j * ds_in.ntau) * ds_in.numu];\n\n        for (iu = 0; iu < input.rte.numu; iu++)\n          rte_out->u0u[lu][iu] = ds_out.u0u[iu + lu * ds_in.numu];\n      }\n      c_disort_out_free (&ds_in, &ds_out);\n      c_disort_state_free (&ds_in);\n    }\n\n    if (planck_tempoff) {\n      rte_in->planck = 1;\n      planck_tempoff = 0;\n    }\n\n    if (rte_solver != SOLVER_DISORT) {\n      /* convert temporary Fortran arrays to permanent result for the fortran solver, not cdisort*/\n      fortran2c_2D_float_ary_noalloc (output->atm.nzout, input.rte.maxumu, disort_u0u, rte_out->u0u);\n\n      fortran2c_3D_float_ary_noalloc (input.rte.maxphi, output->atm.nzout, input.rte.maxumu, disort_uu, rte_out->uu);\n\n      free (disort_pmom);\n      free (disort2_pmom);\n      free (disort2_phaso);\n      free (disort2_mup);\n      free (disort_u0u);\n      free (disort_uu);\n    }\n\n    break;\n\n  case SOLVER_TZS:\n\n    /* tzs_u0u  = (float *) calloc (output->atm.nzout*input.rte.maxumu, sizeof(float)); */\n    /* tzs_uu   = (float *) calloc (output->atm.nzout*input.rte.maxumu*input.rte.maxphi, sizeof(float)); */\n\n    /* ??? no need for thermal below 2um;                 ??? */\n    /* ??? need to do that to avoid numerical underflow;  ??? */\n    /* ??? however, this could be done without actually   ??? */\n    /* ??? calling the solver                             ??? */\n    if (rte_in->planck && output->wl.lambda_r[iv] < 2000.0) {\n      rte_in->planck = 0;\n      planck_tempoff = 1;\n    }\n\n    if (iv == output->wl.nlambda_rte_lower && ib == 0) {\n      status = F77_FUNC (dcheck, DCHECK) (&output->atm.nlyr,\n                                          &output->atm.nzout,\n                                          &input.rte.nstr,\n                                          &input.rte.numu,\n                                          &input.rte.nphi,\n                                          &input.optimize_fortran,\n                                          &input.optimize_delta);\n      if (status != 0) {\n        fprintf (stderr, \"Error %d returned by dcheck in %s (%s)\\n\", status, function_name, file_name);\n        return status;\n      }\n    }\n\n    /* call RTE solver */\n    /* old call to fortran tzs, now replaced by c_tzs which includes also blackbody clouds */\n    /* F77_FUNC  (tzs, TZS) (&output->atm.nlyr, output->dtauc, output->ssalb,  */\n    /* \t\t    output->atm.microphys.temper, &output->wl.wvnmlo_r[iv], */\n    /* \t\t    &output->wl.wvnmhi_r[iv], &rte_in->usrtau, &output->atm.nzout, rte_in->utau, */\n    /* \t\t    &rte_in->usrang, &input.rte.numu, input.rte.umu,  */\n    /* \t\t    &input.rte.nphi, input.rte.phi,  */\n    /* \t\t    &output->alb.albedo_r[iv], &rte_in->btemp, &rte_in->ttemp,  */\n    /* \t\t    &rte_in->temis, &rte_in->planck, */\n    /* \t\t    rte_in->prndis, rte_in->header, &output->atm.nlyr,  */\n    /* \t\t    &output->atm.nzout, &input.rte.maxumu, &input.rte.maxphi,  */\n    /* \t\t    rte_out->rfldir, rte_out->rfldn, rte_out->flup,  */\n    /* \t\t    rte_out->dfdt, rte_out->uavg,  */\n    /* \t\t    tzs_uu, rte_out->albmed, rte_out->trnmed,  */\n    /* \t\t    rte_out->uavgdn, rte_out->uavgso, rte_out->uavgup); */\n    /* call RTE solver */\n    status = c_tzs (output->atm.nlyr,\n                    output->dtauc,\n                    output->atm.nlev_common,\n                    output->atm.zd_common,\n                    output->atm.nzout,\n                    output->atm.zout_sur,\n                    output->ssalb,\n                    output->atm.microphys.temper[0][0],\n                    output->wl.wvnmlo_r[iv],\n                    output->wl.wvnmhi_r[iv],\n                    rte_in->usrtau,\n                    output->atm.nzout,\n                    rte_in->utau,\n                    rte_in->usrang,\n                    input.rte.numu,\n                    input.rte.umu,\n                    input.rte.nphi,\n                    input.rte.phi,\n                    output->alb.albedo_r[iv],\n                    rte_in->btemp,\n                    rte_in->ttemp,\n                    rte_in->temis,\n                    rte_in->planck,\n                    rte_in->prndis,\n                    rte_in->header,\n                    rte_out->rfldir,\n                    rte_out->rfldn,\n                    rte_out->flup,\n                    rte_out->dfdt,\n                    rte_out->uavg,\n                    rte_out->uu,\n                    input.quiet);\n\n    if (planck_tempoff) {\n      rte_in->planck = 1;\n      planck_tempoff = 0;\n    }\n\n    /* convert temporary Fortran arrays to permanent result */\n    /* fortran2c_2D_float_ary_noalloc (output->atm.nzout,  */\n    /* \t\t\t\t    input.rte.maxumu, tzs_u0u, rte_out->u0u); */\n\n    /* fortran2c_3D_float_ary_noalloc (input.rte.maxphi, output->atm.nzout,  */\n    /* \t\t\t\t    input.rte.maxumu, tzs_uu, rte_out->uu); */\n\n    /* free(tzs_u0u); */\n    /* free(tzs_uu); */\n\n    break;\n\n  case SOLVER_SSS:\n\n    sss_u0u = (float*)calloc (output->atm.nzout * input.rte.maxumu, sizeof (float));\n    sss_uu  = (float*)calloc (output->atm.nzout * input.rte.maxumu * input.rte.maxphi, sizeof (float));\n\n    /* ??? no need for thermal below 2um;                 ??? */\n    /* ??? need to do that to avoid numerical underflow;  ??? */\n    /* ??? however, this could be done without actually   ??? */\n    /* ??? calling the solver                             ??? */\n    if (rte_in->planck && output->wl.lambda_r[iv] < 2000.0) {\n      rte_in->planck = 0;\n      planck_tempoff = 1;\n    }\n\n    if (iv == output->wl.nlambda_rte_lower && ib == 0) {\n      status = F77_FUNC (dcheck, DCHECK) (&output->atm.nlyr,\n                                          &output->atm.nzout,\n                                          &input.rte.nstr,\n                                          &input.rte.numu,\n                                          &input.rte.nphi,\n                                          &input.optimize_fortran,\n                                          &input.optimize_delta);\n      if (status != 0) {\n        fprintf (stderr, \"Error %d returned by dcheck in %s (%s)\\n\", status, function_name, file_name);\n        return status;\n      }\n    }\n\n    /* call RTE solver */\n    sss_pmom = c2fortran_3D_float_ary (output->atm.nlyr, 1, output->atm.nmom + 1, output->pmom);\n    F77_FUNC (sss, SSS)\n    (&output->atm.nlyr,\n     output->dtauc,\n     output->ssalb,\n     &output->atm.nmom,\n     sss_pmom,\n     output->atm.microphys.temper[0][0],\n     &output->wl.wvnmlo_r[iv],\n     &output->wl.wvnmhi_r[iv],\n     &rte_in->usrtau,\n     &output->atm.nzout,\n     rte_in->utau,\n     &input.rte.nstr,\n     &rte_in->usrang,\n     &input.rte.numu,\n     input.rte.umu,\n     &input.rte.nphi,\n     input.rte.phi,\n     &rte_in->ibcnd,\n     &rte_in->fbeam,\n     &rte_in->umu0,\n     &output->atm.phi0_r[iv],\n     &rte_in->fisot,\n     &rte_in->lamber,\n     &output->alb.albedo_r[iv],\n     &rte_in->btemp,\n     &rte_in->ttemp,\n     &rte_in->temis,\n     &rte_in->planck,\n     &rte_in->onlyfl,\n     &rte_in->accur,\n     rte_in->prndis2,\n     rte_in->header,\n     &output->atm.nlyr,\n     &output->atm.nzout,\n     &input.rte.maxumu,\n     &input.rte.maxphi,\n     &output->atm.nmom,\n     rte_out->rfldir,\n     rte_out->rfldn,\n     rte_out->flup,\n     rte_out->dfdt,\n     rte_out->uavg,\n     sss_uu,\n     rte_out->albmed,\n     rte_out->trnmed,\n     rte_out->uavgdn,\n     rte_out->uavgso,\n     rte_out->uavgup,\n     &(input.disort2_brdf),\n     &(output->rpv.rho0_r[iv]),\n     &(output->rpv.k_r[iv]),\n     &(output->rpv.theta_r[iv]),\n     &(input.cm.param[BRDF_CAM_U10]),\n     &(input.cm.param[BRDF_CAM_PCL]),\n     &(input.cm.param[BRDF_CAM_SAL]));\n\n    if (planck_tempoff) {\n      rte_in->planck = 1;\n      planck_tempoff = 0;\n    }\n\n    /* convert temporary Fortran arrays to permanent result */\n    fortran2c_2D_float_ary_noalloc (output->atm.nzout, input.rte.maxumu, sss_u0u, rte_out->u0u);\n\n    fortran2c_3D_float_ary_noalloc (input.rte.maxphi, output->atm.nzout, input.rte.maxumu, sss_uu, rte_out->uu);\n\n    free (sss_pmom);\n    free (sss_u0u);\n    free (sss_uu);\n\n    break;\n\n  case SOLVER_SSSI:\n\n#if HAVE_SSSI\n\n    /* get cloud reflectivity from lookup table */\n    status = read_isccp_reflectivity (output->sssi.type,\n                                      output->atm.sza_r[iv],\n                                      output->sssi.tautot,\n                                      input.filename[FN_PATH],\n                                      input.quiet,\n                                      &(output->sssi.ref));\n    if (status != 0) {\n      fprintf (stderr, \"Error %d returned by read_isccp_reflectivity()\\n\", status);\n      return status;\n    }\n\n    if (input.verbose) {\n      fprintf (stderr, \"*** SSSI cloud properties:\\n\");\n      fprintf (stderr, \"    top level:          zd[%d] = %f\\n\", output->sssi.lctop, output->atm.zd[output->sssi.lctop]);\n      switch (output->sssi.type) {\n      case ISCCP_WATER:\n        fprintf (stderr, \"    type:               water\\n\");\n        break;\n      case ISCCP_ICE:\n        fprintf (stderr, \"    type:               ice\\n\");\n        break;\n      default:\n        fprintf (stderr, \"Error, unknown ISCCP cloud type %d\\n\", output->sssi.type);\n        return -1;\n      }\n      fprintf (stderr, \"    optical thickness:  %f\\n\", output->sssi.tautot);\n      fprintf (stderr, \"    reflectivity:       %f\\n\", output->sssi.ref);\n    }\n    fflush (stderr);\n\n    sss_u0u = (float*)calloc (output->atm.nzout * input.rte.maxumu, sizeof (float));\n    sss_uu  = (float*)calloc (output->atm.nzout * input.rte.maxumu * input.rte.maxphi, sizeof (float));\n\n    /* ??? no need for thermal below 2um;                 ??? */\n    /* ??? need to do that to avoid numerical underflow;  ??? */\n    /* ??? however, this could be done without actually   ??? */\n    /* ??? calling the solver                             ??? */\n    if (rte_in->planck && output->wl.lambda_r[iv] < 2000.0) {\n      rte_in->planck = 0;\n      planck_tempoff = 1;\n    }\n\n    if (iv == output->wl.nlambda_rte_lower && ib == 0) {\n      status = F77_FUNC (dcheck, DCHECK) (&output->atm.nlyr,\n                                          &output->atm.nzout,\n                                          &input.rte.nstr,\n                                          &input.rte.numu,\n                                          &input.rte.nphi,\n                                          &input.optimize_fortran,\n                                          &input.optimize_delta);\n      if (status != 0) {\n        fprintf (stderr, \"Error %d returned by dcheck in %s (%s)\\n\", status, function_name, file_name);\n        return status;\n      }\n    }\n\n    /* call RTE solver */\n    sss_pmom = c2fortran_3D_float_ary (output->atm.nlyr, 1, output->atm.nmom + 1, output->pmom);\n    F77_FUNC (sssi, SSSI)\n    (&output->atm.nlyr,\n     output->dtauc,\n     output->ssalb,\n     &output->atm.nmom,\n     sss_pmom,\n     output->atm.microphys.temper[0][0],\n     &output->wl.wvnmlo_r[iv],\n     &output->wl.wvnmhi_r[iv],\n     &rte_in->usrtau,\n     &output->atm.nzout,\n     rte_in->utau,\n     &input.rte.nstr,\n     &rte_in->usrang,\n     &input.rte.numu,\n     input.rte.umu,\n     &input.rte.nphi,\n     input.rte.phi,\n     &rte_in->ibcnd,\n     &rte_in->fbeam,\n     &rte_in->umu0,\n     &output->atm.phi0_r[iv],\n     &rte_in->fisot,\n     &rte_in->lamber,\n     &output->alb.albedo_r[iv],\n     &rte_in->btemp,\n     &rte_in->ttemp,\n     &rte_in->temis,\n     &rte_in->planck,\n     &rte_in->onlyfl,\n     &rte_in->accur,\n     rte_in->prndis2,\n     rte_in->header,\n     &output->atm.nlyr,\n     &output->atm.nzout,\n     &input.rte.maxumu,\n     &input.rte.maxphi,\n     &output->atm.nmom,\n     rte_out->rfldir,\n     rte_out->rfldn,\n     rte_out->flup,\n     rte_out->dfdt,\n     rte_out->uavg,\n     sss_uu,\n     rte_out->albmed,\n     rte_out->trnmed,\n     rte_out->uavgdn,\n     rte_out->uavgso,\n     rte_out->uavgup,\n     &(input.disort2_brdf),\n     &(output->rpv.rho0_r[iv]),\n     &(output->rpv.k_r[iv]),\n     &(output->rpv.theta_r[iv]),\n     &(input.cm.param[BRDF_CAM_U10]),\n     &(input.cm.param[BRDF_CAM_PCL]),\n     &(input.cm.param[BRDF_CAM_SAL]),\n     &(output->sssi.ref),\n     &(output->sssi.lctop));\n\n    if (planck_tempoff) {\n      rte_in->planck = 1;\n      planck_tempoff = 0;\n    }\n\n    /* convert temporary Fortran arrays to permanent result */\n    fortran2c_2D_float_ary_noalloc (output->atm.nzout, input.rte.maxumu, sss_u0u, rte_out->u0u);\n\n    fortran2c_3D_float_ary_noalloc (input.rte.maxphi, output->atm.nzout, input.rte.maxumu, sss_uu, rte_out->uu);\n\n    free (sss_pmom);\n    free (sss_u0u);\n    free (sss_uu);\n#else\n    fprintf (stderr, \"Error, SSSI solver not available!\\n\");\n    return -1;\n#endif\n\n    break;\n\n  case SOLVER_POLRADTRAN:\n#if HAVE_POLRADTRAN\n    rte_in->pol.nummu      = input.rte.nstr / 2 + input.rte.numu;\n    rte_in->pol.albedo     = (double)output->alb.albedo_r[iv];\n    rte_in->pol.btemp      = (double)(rte_in->btemp);\n    rte_in->pol.flux       = (double)(rte_in->fbeam * rte_in->umu0); /* Polradtran wants flux \n                                                                     on horizontal surface */\n    rte_in->pol.mu         = (double)(rte_in->umu0);\n    rte_in->pol.sky_temp   = (double)(rte_in->ttemp);\n    rte_in->pol.wavelength = 0.0; /* Not used for solar source */\n    for (lu = 0; lu < output->atm.nlyr; lu++) {\n      /*\n      rte_in->pol.gas_extinct[lu] = (double)  output->atm.optprop.tau_molabs_r[lu][iv][0]; \n      fprintf(stderr, \"test 1-ssa %g tauc %g molabs %g \\n \", 1.0-output->ssalb[lu],output->atm.optprop.tau_rayleigh_r[lu][iv][0], output->atm.optprop.tau_molabs_r[lu][iv][0] );\n      */\n      /* ????? CE: Something wrong here?? If not set to zero, results for radiances are totally wrong */\n      rte_in->pol.gas_extinct[lu] = 0.0;\n    }\n\n    polradtran_down_flux = (double*)calloc (output->atm.nzout * input.rte.polradtran[POLRADTRAN_NSTOKES], sizeof (double));\n    polradtran_up_flux   = (double*)calloc (output->atm.nzout * input.rte.polradtran[POLRADTRAN_NSTOKES], sizeof (double));\n    polradtran_down_rad  = (double*)calloc (output->atm.nzout * (input.rte.polradtran[POLRADTRAN_AZIORDER] + 1) *\n                                             (input.rte.nstr / 2 + input.rte.numu) * input.rte.polradtran[POLRADTRAN_NSTOKES],\n                                           sizeof (double));\n    polradtran_up_rad    = (double*)calloc (output->atm.nzout * (input.rte.polradtran[POLRADTRAN_AZIORDER] + 1) *\n                                           (input.rte.nstr / 2 + input.rte.numu) * input.rte.polradtran[POLRADTRAN_NSTOKES],\n                                         sizeof (double));\n    for (iu = 0; iu < rte_in->pol.nummu; iu++)\n      rte_out->polradtran_mu_values[iu] = (double)fabs (output->mu_values[iu]);\n    /* Take fabs since radtran will calculate both up_rad and down_rad for the value of mu.  */\n    /* The user wants one of these. That is sorted out in the output section of uvspec_lex.l */\n\n    F77_FUNC (radtran, RADTRAN)\n    (&input.rte.polradtran[POLRADTRAN_NSTOKES],\n     &(rte_in->pol.nummu),\n     &input.rte.polradtran[POLRADTRAN_AZIORDER],\n     &input.rte.pol_max_delta_tau,\n     &input.rte.polradtran[POLRADTRAN_SRC_CODE],\n     input.rte.pol_quad_type,\n     rte_in->pol.deltam,\n     &(rte_in->pol.flux),\n     &(rte_in->pol.mu),\n     &(rte_in->pol.btemp),\n     (rte_in->pol.ground_type),\n     &(rte_in->pol.albedo),\n     &(rte_in->pol.ground_index),\n     &(rte_in->pol.sky_temp),\n     &(rte_in->pol.wavelength),\n     &output->atm.nlyr,\n     (rte_in->pol.height),\n     (rte_in->pol.temperatures),\n     (rte_in->pol.gas_extinct),\n     output->atm.pol_scat_files,\n     &output->atm.nzout,\n     (rte_in->pol.outlevels),\n     rte_out->polradtran_mu_values,\n     polradtran_up_flux,\n     polradtran_down_flux,\n     polradtran_up_rad,\n     polradtran_down_rad);\n\n    fortran2c_2D_double_ary_noalloc (output->atm.nzout,\n                                     input.rte.polradtran[POLRADTRAN_NSTOKES],\n                                     polradtran_up_flux,\n                                     rte_out->polradtran_up_flux);\n\n    fortran2c_2D_double_ary_noalloc (output->atm.nzout,\n                                     input.rte.polradtran[POLRADTRAN_NSTOKES],\n                                     polradtran_down_flux,\n                                     rte_out->polradtran_down_flux);\n\n    if (input.rte.polradtran[POLRADTRAN_AZIORDER] > 0) {\n      fortran2c_4D_double_ary_noalloc (output->atm.nzout,\n                                       input.rte.polradtran[POLRADTRAN_AZIORDER] + 1,\n                                       input.rte.nstr / 2 + input.rte.numu,\n                                       input.rte.polradtran[POLRADTRAN_NSTOKES],\n                                       polradtran_down_rad,\n                                       rte_out->polradtran_down_rad_q);\n\n      fortran2c_4D_double_ary_noalloc (output->atm.nzout,\n                                       input.rte.polradtran[POLRADTRAN_AZIORDER] + 1,\n                                       input.rte.nstr / 2 + input.rte.numu,\n                                       input.rte.polradtran[POLRADTRAN_NSTOKES],\n                                       polradtran_up_rad,\n                                       rte_out->polradtran_up_rad_q);\n\n      fourier2azimuth (rte_out->polradtran_down_rad_q,\n                       rte_out->polradtran_up_rad_q,\n                       rte_out->polradtran_down_rad,\n                       rte_out->polradtran_up_rad,\n                       output->atm.nzout,\n                       input.rte.polradtran[POLRADTRAN_AZIORDER],\n                       input.rte.nstr,\n                       input.rte.numu,\n                       input.rte.polradtran[POLRADTRAN_NSTOKES],\n                       input.rte.nphi,\n                       input.rte.phi);\n    }\n\n    free (polradtran_down_flux);\n    free (polradtran_up_flux);\n\n    free (polradtran_down_rad);\n    free (polradtran_up_rad);\n\n#else\n    fprintf (stderr, \"Error: RTE polradtran solver not included in uvspec build.\\n\");\n    fprintf (stderr, \"Error: Get solver and rebuild uvspec.\\n\");\n    return -1;\n#endif\n    break;\n\n  case SOLVER_SDISORT:\n\n    if (iv == output->wl.nlambda_rte_lower && ib == 0) {\n      status = F77_FUNC (dcheck, DCHECK) (&output->atm.nlyr,\n                                          &output->atm.nzout,\n                                          &input.rte.nstr,\n                                          &input.rte.numu,\n                                          &input.rte.nphi,\n                                          &input.optimize_fortran,\n                                          &input.optimize_delta);\n      if (status != 0) {\n        fprintf (stderr, \"Error %d returned by dcheck in %s (%s)\\n\", status, function_name, file_name);\n        return status;\n      }\n    }\n\n    sdisort_beta = (float*)calloc (output->atm.nlyr + 1, sizeof (float));\n    disort_pmom  = c2fortran_3D_float_ary (output->atm.nlyr, 1, input.rte.nstr + 1, output->pmom);\n    disort_u0u   = (float*)calloc (output->atm.nzout * input.rte.maxumu, sizeof (float));\n    disort_uu    = (float*)calloc (output->atm.nzout * input.rte.maxumu * input.rte.maxphi, sizeof (float));\n    sdisort_sig  = (float*)calloc (output->atm.nlyr + 1, sizeof (float));\n    if ((status = ASCII_calloc_float (&sdisort_denstab, output->atm.microphys.nsza_denstab, output->atm.nlyr + 1)) != 0)\n      return status;\n    if (output->atm.microphys.denstab_id > 0) {\n      for (lu = 0; lu <= output->atm.nlyr; lu++) {\n        sdisort_sig[lu] = output->crs.crs_amf[iv][lu];\n        for (is = 0; is < output->atm.microphys.nsza_denstab; is++)\n          sdisort_denstab[is][lu] = output->atm.microphys.denstab_amf[is][lu];\n      }\n\n      tosdisort_denstab = c2fortran_2D_float_ary (output->atm.microphys.nsza_denstab, output->atm.nlyr + 1, sdisort_denstab);\n      if (sdisort_denstab != NULL)\n        ASCII_free_float (sdisort_denstab, output->atm.microphys.nsza_denstab);\n    }\n\n    /* Definition of refind in (refractive index - 1), function SOLVER_SDISORT takes refractive index */\n    for (lu = 0; lu <= output->atm.nlyr; lu++)\n      output->atm.microphys.refind[iv][lu] += 1.;\n\n    F77_FUNC (sdisort, SDISORT)\n    (&output->atm.nlyr,\n     output->dtauc,\n     output->ssalb,\n     disort_pmom,\n     output->atm.microphys.temper[0][0],\n     &(output->wl.wvnmlo_r[iv]),\n     &(output->wl.wvnmhi_r[iv]),\n     &(rte_in->usrtau),\n     &output->atm.nzout,\n     rte_in->utau,\n     &input.rte.nstr,\n     &(rte_in->usrang),\n     &input.rte.numu,\n     input.rte.umu,\n     &input.rte.nphi,\n     input.rte.phi,\n     &(rte_in->fbeam),\n     sdisort_beta,\n     &(rte_in->nil),\n     &(rte_in->umu0),\n     &output->atm.phi0_r[iv],\n     &(rte_in->newgeo),\n     output->atm.zd,\n     &(rte_in->spher),\n     &input.r_earth,\n     &(rte_in->fisot),\n     &output->alb.albedo_r[iv],\n     &(rte_in->btemp),\n     &(rte_in->ttemp),\n     &(rte_in->temis),\n     &input.rte.deltam,\n     &(rte_in->planck),\n     &(rte_in->onlyfl),\n     &(rte_in->accur),\n     &(rte_in->quiet),\n     rte_in->ierror_s,\n     rte_in->prndis,\n     rte_in->header,\n     &output->atm.nlyr,\n     &output->atm.nzout,\n     &input.rte.maxumu,\n     &input.rte.nstr,\n     &input.rte.maxphi,\n     rte_out->rfldir,\n     rte_out->rfldn,\n     rte_out->flup,\n     rte_out->dfdt,\n     rte_out->uavg,\n     disort_uu,\n     disort_u0u,\n     &input.rte.sdisort[SDISORT_NSCAT],\n     rte_out->uavgdn,\n     rte_out->uavgso,\n     rte_out->uavgup,\n     &input.rte.sdisort[SDISORT_NREFRAC],\n     &input.rte.sdisort[SDISORT_ICHAPMAN],\n     output->atm.microphys.refind[iv],\n     &output->atm.microphys.nsza_denstab,\n     output->atm.microphys.sza_denstab,\n     sdisort_sig,\n     tosdisort_denstab,\n     output->dtauc_md);\n\n    /* convert temporary Fortran arrays to permanent result */\n\n    fortran2c_2D_float_ary_noalloc (output->atm.nzout, input.rte.maxumu, disort_u0u, rte_out->u0u);\n\n    fortran2c_3D_float_ary_noalloc (input.rte.maxphi, output->atm.nzout, input.rte.maxumu, disort_uu, rte_out->uu);\n\n    free (sdisort_beta);\n    free (disort_pmom);\n    free (disort_u0u);\n    free (disort_uu);\n\n    break;\n  case SOLVER_SPSDISORT:\n\n    if (iv == output->wl.nlambda_rte_lower && ib == 0) {\n      status = F77_FUNC (dcheck, DCHECK) (&output->atm.nlyr,\n                                          &output->atm.nzout,\n                                          &input.rte.nstr,\n                                          &input.rte.numu,\n                                          &input.rte.nphi,\n                                          &input.optimize_fortran,\n                                          &input.optimize_delta);\n      if (status != 0) {\n        fprintf (stderr, \"Error %d returned by dcheck in %s (%s)\\n\", status, function_name, file_name);\n        return status;\n      }\n    }\n\n    sdisort_beta = (float*)calloc (output->atm.nlyr + 1, sizeof (float));\n    disort_pmom  = c2fortran_3D_float_ary (output->atm.nlyr, 1, input.rte.nstr + 1, output->pmom);\n    disort_u0u   = (float*)calloc (output->atm.nzout * input.rte.maxumu, sizeof (float));\n    disort_uu    = (float*)calloc (output->atm.nzout * input.rte.maxumu * input.rte.maxphi, sizeof (float));\n\n    F77_FUNC (spsdisort, SPSDISORT)\n    (&output->atm.nlyr,\n     output->dtauc,\n     output->ssalb,\n     disort_pmom,\n     output->atm.microphys.temper[0][0],\n     &(output->wl.wvnmlo_r[iv]),\n     &(output->wl.wvnmhi_r[iv]),\n     &(rte_in->usrtau),\n     &output->atm.nzout,\n     rte_in->utau,\n     &input.rte.nstr,\n     &(rte_in->usrang),\n     &input.rte.numu,\n     input.rte.umu,\n     &input.rte.nphi,\n     input.rte.phi,\n     &(rte_in->fbeam),\n     sdisort_beta,\n     &(rte_in->nil),\n     &(rte_in->umu0),\n     &output->atm.phi0_r[iv],\n     &(rte_in->newgeo),\n     output->atm.zd,\n     &(rte_in->spher),\n     &input.r_earth,\n     &(rte_in->fisot),\n     &output->alb.albedo_r[iv],\n     &(rte_in->btemp),\n     &(rte_in->ttemp),\n     &(rte_in->temis),\n     &input.rte.deltam,\n     &(rte_in->planck),\n     &(rte_in->onlyfl),\n     &(rte_in->accur),\n     &(rte_in->quiet),\n     rte_in->ierror_s,\n     rte_in->prndis,\n     rte_in->header,\n     &output->atm.nlyr,\n     &output->atm.nzout,\n     &input.rte.maxumu,\n     &input.rte.nstr,\n     &input.rte.maxphi,\n     rte_out->rfldir,\n     rte_out->rfldn,\n     rte_out->flup,\n     rte_out->dfdt,\n     rte_out->uavg,\n     disort_uu,\n     disort_u0u,\n     rte_out->uavgdn,\n     rte_out->uavgso,\n     rte_out->uavgup);\n\n    /* convert temporary Fortran arrays to permanent result */\n\n    fortran2c_2D_float_ary_noalloc (output->atm.nzout, input.rte.maxumu, disort_u0u, rte_out->u0u);\n\n    fortran2c_3D_float_ary_noalloc (input.rte.maxphi, output->atm.nzout, input.rte.maxumu, disort_uu, rte_out->uu);\n\n    free (sdisort_beta);\n    free (disort_pmom);\n    free (disort_u0u);\n    free (disort_uu);\n\n    break;\n  case SOLVER_FTWOSTR:\n\n    if (iv == output->wl.nlambda_rte_lower && ib == 0) {\n      status = F77_FUNC (tcheck, TCHECK) (&output->atm.nlyr,\n                                          &output->atm.nzout,\n                                          &input.rte.nstr,\n                                          &input.rte.numu,\n                                          &input.rte.nphi,\n                                          &input.optimize_fortran,\n                                          &input.optimize_delta);\n      if (status != 0)\n        return status;\n    }\n\n    twostr_gg = (float*)calloc (output->atm.nlyr, sizeof (float));\n    for (lu = 0; lu < output->atm.nlyr; lu++)\n      twostr_gg[lu] = output->pmom[lu][0][1];\n\n    /* ??? no need for thermal below 2um;                 ??? */\n    /* ??? need to do that to avoid numerical underflow;  ??? */\n    /* ??? however, this could be done without actually   ??? */\n    /* ??? calling the solver                             ??? */\n    if (rte_in->planck && output->wl.lambda_r[iv] < 2000.0) {\n      rte_in->planck = 0;\n      planck_tempoff = 1;\n    }\n\n    F77_FUNC (twostr, TWOSTR)\n    (&output->alb.albedo_r[iv],\n     &(rte_in->btemp),\n     &input.rte.deltam,\n     output->dtauc,\n     &(rte_in->fbeam),\n     &(rte_in->fisot),\n     twostr_gg,\n     rte_in->header,\n     rte_in->ierror_t,\n     &output->atm.nlyr,\n     &output->atm.nzout,\n     &(rte_in->newgeo),\n     &output->atm.nlyr,\n     &(rte_in->planck),\n     &output->atm.nzout,\n     rte_in->prntwo,\n     &(rte_in->quiet),\n     &input.r_earth,\n     &(rte_in->spher),\n     output->ssalb,\n     &(rte_in->temis),\n     output->atm.microphys.temper[0][0],\n     &(rte_in->ttemp),\n     &(rte_in->umu0),\n     &(rte_in->usrtau),\n     rte_in->utau,\n     &(output->wl.wvnmlo_r[iv]),\n     &(output->wl.wvnmhi_r[iv]),\n     output->atm.zd,\n     rte_out->dfdt,\n     rte_out->flup,\n     rte_out->rfldir,\n     rte_out->rfldn,\n     rte_out->uavg);\n    free (twostr_gg);\n\n    for (lev = 0; lev < output->atm.nzout; lev++) {\n      rte_out->uavgso[lev] = NAN;\n      rte_out->uavgdn[lev] = NAN;\n      rte_out->uavgup[lev] = NAN;\n    }\n\n    if (planck_tempoff) {\n      rte_in->planck = 1;\n      planck_tempoff = 0;\n    }\n\n    break;\n\n  case SOLVER_TWOSTR:\n\n    twostr_ds.nlyr        = output->atm.nlyr;\n    twostr_ds.ntau        = output->atm.nzout;\n    twostr_ds.flag.planck = rte_in->planck;\n    twostr_ds.flag.quiet  = rte_in->quiet;\n    twostr_ds.flag.spher  = rte_in->spher;\n    /* twostr_ds.flag.spher = input.rte.pseudospherical; */\n    twostr_ds.flag.usrtau = rte_in->usrtau;\n    c_twostr_state_alloc (&twostr_ds);\n    c_twostr_out_alloc (&twostr_ds, &twostr_out);\n\n    c_twostr_gg = (double*)calloc (output->atm.nlyr, sizeof (double));\n    for (lu = 0; lu < output->atm.nlyr; lu++) {\n      c_twostr_gg[lu]     = (double)output->pmom[lu][0][1];\n      twostr_ds.dtauc[lu] = (double)output->dtauc[lu];\n      twostr_ds.ssalb[lu] = (double)output->ssalb[lu];\n    }\n    for (lu = 0; lu < output->atm.nzout; lu++) {\n      twostr_ds.utau[lu] = (double)rte_in->utau[lu];\n    }\n    for (lu = 0; lu <= output->atm.nlyr; lu++) {\n      twostr_ds.zd[lu] = (double)output->atm.zd[lu];\n      if (rte_in->planck)\n        twostr_ds.temper[lu] = (double)output->atm.microphys.temper[0][0][lu];\n    }\n    twostr_ds.bc.albedo    = (double)output->alb.albedo_r[iv];\n    twostr_ds.bc.btemp     = (double)rte_in->btemp;\n    twostr_ds.bc.fbeam     = (double)rte_in->fbeam;\n    twostr_ds.bc.fisot     = (double)rte_in->fisot;\n    twostr_ds.bc.temis     = (double)rte_in->temis;\n    twostr_ds.bc.ttemp     = (double)rte_in->ttemp;\n    twostr_ds.bc.umu0      = (double)rte_in->umu0;\n    twostr_ds.flag.prnt[0] = rte_in->prntwo[0];\n    twostr_ds.flag.prnt[1] = rte_in->prntwo[1];\n    twostr_ds.wvnmlo       = output->wl.wvnmlo_r[iv];\n    twostr_ds.wvnmhi       = output->wl.wvnmhi_r[iv];\n\n    /* ??? no need for thermal below 2um;                 ??? */\n    /* ??? need to do that to avoid numerical underflow;  ??? */\n    /* ??? however, this could be done without actually   ??? */\n    /* ??? calling the solver                             ??? */\n    if (rte_in->planck && output->wl.lambda_r[iv] < 2000.0) {\n      rte_in->planck = 0;\n      planck_tempoff = 1;\n    }\n\n    c_twostr (&twostr_ds, &twostr_out, input.rte.deltam, c_twostr_gg, rte_in->ierror_t, c_r_earth);\n\n    for (lu = 0; lu < output->atm.nzout; lu++) {\n      rte_out->dfdt[lu]   = (float)twostr_out.rad[lu].dfdt;\n      rte_out->rfldir[lu] = (float)twostr_out.rad[lu].rfldir;\n      rte_out->rfldn[lu]  = (float)twostr_out.rad[lu].rfldn;\n      rte_out->flup[lu]   = (float)twostr_out.rad[lu].flup;\n      rte_out->uavg[lu]   = (float)twostr_out.rad[lu].uavg;\n    }\n\n    free (c_twostr_gg);\n    free (c_zd);\n    c_twostr_state_free (&twostr_ds);\n    c_twostr_out_free (&twostr_ds, &twostr_out);\n\n    for (lev = 0; lev < output->atm.nzout; lev++) {\n      rte_out->uavgso[lev] = NAN;\n      rte_out->uavgdn[lev] = NAN;\n      rte_out->uavgup[lev] = NAN;\n    }\n\n    if (planck_tempoff) {\n      rte_in->planck = 1;\n      planck_tempoff = 0;\n    }\n\n    break;\n\n  case SOLVER_RODENTS: /* ulrike, Robert Buras' two-stream model */\n\n    if (input.tipa == TIPA_DIR) /* BCA this should be somewhere else */\n      /* for tipa_dir, delta-scaling is not yet implemented!!! */\n      rodents_delta_method = RODENTS_DELTA_METHOD_OFF;\n    else\n      /* test showed that f=g*g is better than f=p2; master thesis to improve this! */\n      rodents_delta_method = RODENTS_DELTA_METHOD_HG;\n\n    twostr_gg = (float*)calloc (output->atm.nlyr, sizeof (float));\n    for (lu = 0; lu < output->atm.nlyr; lu++)\n      twostr_gg[lu] = output->pmom[lu][0][1];\n    twostr_ff = (float*)calloc (output->atm.nlyr, sizeof (float));\n    if (rodents_delta_method ==\n        RODENTS_DELTA_METHOD_ON) /* use second moment for delta-scaling */ /* BCA this should be somewhere else */\n      for (lu = 0; lu < output->atm.nlyr; lu++)\n        twostr_ff[lu] = output->pmom[lu][0][2];\n    else /* f is set to zero, and evtl set to g*g internally */\n      for (lu = 0; lu < output->atm.nlyr; lu++)\n        twostr_ff[lu] = 0.0;\n\n    /* ??? no need for thermal below 2um;                 ??? */\n    /* ??? need to do that to avoid numerical underflow;  ??? */\n    /* ??? however, this could be done without actually   ??? */\n    /* ??? calling the solver                             ??? */\n\n    if (rte_in->planck && output->wl.lambda_r[iv] < 2000.0) {\n      rte_in->planck = 0;\n      planck_tempoff = 1;\n    }\n\n    status = rodents (/* INPUT */\n                      output->atm.nlyr,\n                      output->dtauc,\n                      output->ssalb,\n                      twostr_gg,\n                      twostr_ff,\n                      rodents_delta_method,\n                      output->atm.microphys.temper[0][0],\n                      output->wl.wvnmlo_r[iv],\n                      output->wl.wvnmhi_r[iv],\n                      rte_in->usrtau,\n                      output->atm.nzout,\n                      rte_in->utau,\n                      rte_in->fbeam,\n                      rte_in->umu0,\n                      output->alb.albedo_r[iv],\n                      rte_in->btemp,\n                      rte_in->planck,\n                      /* NECESSARY FOR TIPA DIR */\n                      input.tipa, /* if ==2, then tipa dir */\n                      output->tausol,\n                      /* OUTPUT */\n                      rte_out->rfldn,  /* e_minus */\n                      rte_out->flup,   /* e_plus */\n                      rte_out->rfldir, /* s_direct */\n                      rte_out->uavg);  /* KST ???? */\n\n    if (status != 0) {\n      fprintf (stderr, \"Error %d returned by rodents()\\n\", status);\n      return status;\n    }\n\n    free (twostr_gg);\n    free (twostr_ff);\n\n    for (lev = 0; lev < output->atm.nzout; lev++) {\n      rte_out->uavgso[lev] = NAN;\n      rte_out->uavgdn[lev] = NAN;\n      rte_out->uavgup[lev] = NAN;\n    }\n\n    if (planck_tempoff) {\n      rte_in->planck = 1;\n      planck_tempoff = 0;\n    }\n    break; /* END of rodents */\n\n  case SOLVER_TWOSTREBE: /* ulrike 22.06.2010, Bernhard Mayers twostream*/\n\n    twostr_gg = (float*)calloc (output->atm.nlyr, sizeof (float));\n    for (lu = 0; lu < output->atm.nlyr; lu++)\n      twostr_gg[lu] = output->pmom[lu][0][1];\n\n    /* ??? no need for thermal below 2um;                 ??? */\n    /* ??? need to do that to avoid numerical underflow;  ??? */\n    /* ??? however, this could be done without actually   ??? */\n    /* ??? calling the solver                             ??? */\n    if (rte_in->planck && output->wl.lambda_r[iv] < 2000.0) {\n      rte_in->planck = 0;\n      planck_tempoff = 1;\n    }\n\n    status = twostrebe (output->dtauc,            /* dtau (rodents) = dtau_org (twostrebe) */\n                        output->ssalb,            /* omega_0 */\n                        twostr_gg,                /* g (rodents) = g_org (twostrebe) */\n                        output->atm.nlyr + 1,     /* nlev */\n                        rte_in->fbeam,            /* S_0 */\n                        rte_in->umu0,             /* mu_0 */\n                        output->alb.albedo_r[iv], /* surface albedo */\n                        rte_in->planck,           /* whether to use planck */\n                        input.rte.deltam,         /* delta scaling */\n                        output->atm.nzout,        /* nzout */\n                        output->atm.zd,           /* z-levels */\n                        output->atm.microphys.temper[0][0],\n                        rte_in->btemp, /* surface temperature */\n                        output->wl.wvnmlo_r[iv],\n                        output->wl.wvnmhi_r[iv],\n                        input.atm.zout_sur, /* zout's (in km) */\n                        /* output */\n                        rte_out->rfldn,  /* e_minus */\n                        rte_out->flup,   /* e_plus */\n                        rte_out->rfldir, /* s_direct */\n                        rte_out->uavg);  /* KST ???? */\n\n    if (status != 0) {\n      fprintf (stderr, \"Error %d returned by twostrebe()\\n\", status);\n      return status;\n    }\n\n    free (twostr_gg);\n\n    for (lev = 0; lev < output->atm.nzout; lev++) {\n      rte_out->uavgso[lev] = NAN;\n      rte_out->uavgdn[lev] = NAN;\n      rte_out->uavgup[lev] = NAN;\n    }\n\n    if (planck_tempoff) {\n      rte_in->planck = 1;\n      planck_tempoff = 0;\n    }\n\n    break; /* END twostrebe */\n\n  case SOLVER_TWOMAXRND: /* Bernhard Mayer, 7.7.2016, Nina Crnivec twostream with Maximum Random Overlap */\n\n    twostr_gg     = (float*)calloc (output->atm.nlyr, sizeof (float));\n    twostr_gg_clr = (float*)calloc (output->atm.nlyr, sizeof (float));\n    for (lu = 0; lu < output->atm.nlyr; lu++) {\n      twostr_gg[lu]     = output->pmom[lu][0][1];\n      twostr_gg_clr[lu] = output->pmom01_clr[lu];\n    }\n\n    /* ??? no need for thermal below 2um;                 ??? */\n    /* ??? need to do that to avoid numerical underflow;  ??? */\n    /* ??? however, this could be done without actually   ??? */\n    /* ??? calling the solver                             ??? */\n    if (rte_in->planck && output->wl.lambda_r[iv] < 2000.0) {\n      rte_in->planck = 0;\n      planck_tempoff = 1;\n    }\n\n    twostr_cf = calloc (output->atm.nlyr, sizeof (float));\n\n    if (output->cf.nlev != 0) {\n\n      if (output->atm.nlyr != output->cf.nlev) {\n        fprintf (stderr,\n                 \"Fatal error! Cloud fraction grid different from atmospheric grid. %d levels vs. %d levels\\n\",\n                 output->cf.nlev + 1,\n                 output->atm.nlyr + 1);\n        return -1;\n      } else {\n        for (lu = 0; lu < output->atm.nlyr; lu++)\n          twostr_cf[lu] = output->cf.cf[lu];\n      }\n    }\n\n    status = twomaxrnd (output->dtauc,            /* dtau (rodents) = dtau_org (twostrebe) */\n                        output->ssalb,            /* omega_0 */\n                        twostr_gg,                /* g (rodents) = g_org (twostrebe) */\n                        output->dtauc_clr,        /* dtau (rodents) = dtau_org (twostrebe) */\n                        output->ssalb_clr,        /* omega_0 */\n                        twostr_gg_clr,            /* g (rodents) = g_org (twostrebe) */\n                        twostr_cf,                /* cloud fraction */\n                        output->atm.nlyr + 1,     /* nlev */\n                        rte_in->fbeam,            /* S_0 */\n                        rte_in->umu0,             /* mu_0 */\n                        output->alb.albedo_r[iv], /* surface albedo */\n                        rte_in->planck,           /* whether to use planck */\n                        input.rte.deltam,         /* delta scaling */\n                        output->atm.nzout,        /* nzout */\n                        output->atm.zd,           /* z-levels */\n                        output->atm.microphys.temper[0][0],\n                        rte_in->btemp, /* surface temperature */\n                        output->wl.wvnmlo_r[iv],\n                        output->wl.wvnmhi_r[iv],\n                        input.atm.zout_sur, /* zout's (in km) */\n                        /* output */\n                        rte_out->rfldn,  /* e_minus */\n                        rte_out->flup,   /* e_plus */\n                        rte_out->rfldir, /* s_direct */\n                        rte_out->uavg);  /* KST ???? */\n\n    if (status != 0) {\n      fprintf (stderr, \"Error %d returned by twomaxrnd()\\n\", status);\n      return status;\n    }\n\n    free (twostr_gg);\n    free (twostr_gg_clr);\n    free (twostr_cf);\n\n    for (lev = 0; lev < output->atm.nzout; lev++) {\n      rte_out->uavgso[lev] = NAN;\n      rte_out->uavgdn[lev] = NAN;\n      rte_out->uavgup[lev] = NAN;\n    }\n\n    if (planck_tempoff) {\n      rte_in->planck = 1;\n      planck_tempoff = 0;\n    }\n\n    break; /* END twomaxrnd */\n\n  case SOLVER_DYNAMIC_TWOSTREAM: /* Bernhard Mayer, 23.7.2020, Richard Maier, dynamic twostream */\n\n    twostr_gg     = (float*)calloc (output->atm.nlyr, sizeof (float));\n    twostr_gg_clr = (float*)calloc (output->atm.nlyr, sizeof (float));\n    for (lu = 0; lu < output->atm.nlyr; lu++) {\n      twostr_gg[lu]     = output->pmom[lu][0][1];\n      twostr_gg_clr[lu] = output->pmom01_clr[lu];\n    }\n\n    /* ??? no need for thermal below 2um;                 ??? */\n    /* ??? need to do that to avoid numerical underflow;  ??? */\n    /* ??? however, this could be done without actually   ??? */\n    /* ??? calling the solver                             ??? */\n    if (rte_in->planck && output->wl.lambda_r[iv] < 2000.0) {\n      rte_in->planck = 0;\n      planck_tempoff = 1;\n    }\n\n    twostr_cf = calloc (output->atm.nlyr, sizeof (float));\n\n    if (output->cf.nlev != 0) {\n\n      if (output->atm.nlyr != output->cf.nlev) {\n        fprintf (stderr,\n                 \"Fatal error! Cloud fraction grid different from atmospheric grid. %d levels vs. %d levels\\n\",\n                 output->cf.nlev,\n                 output->atm.nlyr + 1);\n        return -1;\n      } else {\n        for (lu = 0; lu < output->atm.nlyr; lu++)\n          twostr_cf[lu] = output->cf.cf[lu];\n      }\n    }\n\n    status = dynamic_twostream (input.rte.dynamic_iterations, /* number of iterations */\n                                output->dtauc,                /* dtau (rodents) = dtau_org (twostrebe) */\n                                output->ssalb,                /* omega_0 */\n                                twostr_gg,                    /* g (rodents) = g_org (twostrebe) */\n                                output->dtauc_clr,            /* dtau (rodents) = dtau_org (twostrebe) */\n                                output->ssalb_clr,            /* omega_0 */\n                                twostr_gg_clr,                /* g (rodents) = g_org (twostrebe) */\n                                twostr_cf,                    /* cloud fraction */\n                                output->atm.nlyr + 1,         /* nlev */\n                                rte_in->fbeam,                /* S_0 */\n                                rte_in->umu0,                 /* mu_0 */\n                                output->alb.albedo_r[iv],     /* surface albedo */\n                                rte_in->planck,               /* whether to use planck */\n                                input.rte.deltam,             /* delta scaling */\n                                output->atm.nzout,            /* nzout */\n                                output->atm.zd,               /* z-levels */\n                                output->atm.microphys.temper[0][0],\n                                rte_in->btemp, /* surface temperature */\n                                output->wl.wvnmlo_r[iv],\n                                output->wl.wvnmhi_r[iv],\n                                input.atm.zout_sur, /* zout's (in km) */\n                                /* output */\n                                rte_out->rfldn,  /* e_minus */\n                                rte_out->flup,   /* e_plus */\n                                rte_out->rfldir, /* s_direct */\n                                rte_out->uavg);  /* KST ???? */\n\n    if (status != 0) {\n      fprintf (stderr, \"Error %d returned by dynamic_twostream()\\n\", status);\n      return status;\n    }\n\n    free (twostr_gg);\n    free (twostr_gg_clr);\n    free (twostr_cf);\n\n    for (lev = 0; lev < output->atm.nzout; lev++) {\n      rte_out->uavgso[lev] = NAN;\n      rte_out->uavgdn[lev] = NAN;\n      rte_out->uavgup[lev] = NAN;\n    }\n\n    if (planck_tempoff) {\n      rte_in->planck = 1;\n      planck_tempoff = 0;\n    }\n\n    break; /* END dynamic_twostream */\n\n  case SOLVER_DYNAMIC_TENSTREAM: /* Bernhard Mayer, 6.12.2020, Richard Maier, dynamic tenstream */\n\n    twostr_gg_clr = (float*)calloc (output->atm.nlyr, sizeof (float));\n    for (lu = 0; lu < output->atm.nlyr; lu++)\n      twostr_gg_clr[lu] = output->pmom01_clr[lu];\n\n    /* ??? no need for thermal below 2um;                 ??? */\n    /* ??? need to do that to avoid numerical underflow;  ??? */\n    /* ??? however, this could be done without actually   ??? */\n    /* ??? calling the solver                             ??? */\n    if (rte_in->planck && output->wl.lambda_r[iv] < 2000.0) {\n      rte_in->planck = 0;\n      planck_tempoff = 1;\n    }\n\n    status = dynamic_tenstream (input.rte.dynamic_iterations, /* number of iterations */\n                                output->caoth3d,\n                                input.n_caoth + 2,\n                                output->dtauc_clr,        /* dtau (rodents) = dtau_org (twostrebe) */\n                                output->ssalb_clr,        /* omega_0 */\n                                twostr_gg_clr,            /* g (rodents) = g_org (twostrebe) */\n                                output->atm.nlyr + 1,     /* nlev */\n                                rte_in->fbeam,            /* S_0 */\n                                rte_in->umu0,             /* mu_0 */\n                                output->alb.albedo_r[iv], /* surface albedo */\n                                rte_in->planck,           /* whether to use planck */\n                                input.rte.deltam,         /* delta scaling */\n                                output->atm.nzout,        /* nzout */\n                                output->atm.zd,           /* z-levels */\n                                output->atm.microphys.temper[0][0],\n                                rte_in->btemp, /* surface temperature */\n                                output->wl.wvnmlo_r[iv],\n                                output->wl.wvnmhi_r[iv],\n                                input.atm.zout_sur, /* zout's (in km) */\n                                /* output */\n                                rte_out->rfldn,  /* e_minus */\n                                rte_out->flup,   /* e_plus */\n                                rte_out->rfldir, /* s_direct */\n                                rte_out->uavg);  /* KST ???? */\n\n    if (status != 0) {\n      fprintf (stderr, \"Error %d returned by dynamic_tenstream()\\n\", status);\n      return status;\n    }\n\n    free (twostr_gg);\n\n    for (lev = 0; lev < output->atm.nzout; lev++) {\n      rte_out->uavgso[lev] = NAN;\n      rte_out->uavgdn[lev] = NAN;\n      rte_out->uavgup[lev] = NAN;\n    }\n\n    if (planck_tempoff) {\n      rte_in->planck = 1;\n      planck_tempoff = 0;\n    }\n\n    break; /* END dynamic_tenstream */\n\n  case SOLVER_TWOMAXRND3C: /* Bernhard Mayer, 11.4.2018, Nina Crnivec twostream with Maximum Random Overlap and tripleclouds */\n    twostr_gg_cldk = (float*)calloc (output->atm.nlyr, sizeof (float));\n    twostr_gg_cldn = (float*)calloc (output->atm.nlyr, sizeof (float));\n    twostr_gg_clr  = (float*)calloc (output->atm.nlyr, sizeof (float));\n    for (lu = 0; lu < output->atm.nlyr; lu++) {\n      twostr_gg_cldk[lu] = output->pmom01_cldk[lu];\n      twostr_gg_cldn[lu] = output->pmom01_cldn[lu];\n      twostr_gg_clr[lu]  = output->pmom01_clr[lu];\n    }\n\n    /* ??? no need for thermal below 2um;                 ??? */\n    /* ??? need to do that to avoid numerical underflow;  ??? */\n    /* ??? however, this could be done without actually   ??? */\n    /* ??? calling the solver                             ??? */\n    if (rte_in->planck && output->wl.lambda_r[iv] < 2000.0) {\n      rte_in->planck = 0;\n      planck_tempoff = 1;\n    }\n\n    twostr_cf = calloc (output->atm.nlyr, sizeof (float));\n\n    if (output->cf.nlev != 0) {\n\n      if (output->atm.nlyr != output->cf.nlev) {\n        fprintf (stderr,\n                 \"Fatal error! Cloud fraction grid different from atmospheric grid. %d levels vs. %d levels\\n\",\n                 output->cf.nlev,\n                 output->atm.nlyr + 1);\n        return -1;\n      } else {\n        for (lu = 0; lu < output->atm.nlyr; lu++)\n          twostr_cf[lu] = output->cf.cf[lu];\n      }\n    }\n\n#if HAVE_TWOMAXRND3C\n    status = twomaxrnd3C (output->dtauc_cldk, /* dtau (rodents) = dtau_org (twostrebe) */\n                          output->ssalb_cldk, /* omega_0 */\n                          twostr_gg_cldk,     /* g (rodents) = g_org (twostrebe) */\n                          output->dtauc_cldn, /* dtau (rodents) = dtau_org (twostrebe) */\n                          output->ssalb_cldn, /* omega_0 */\n                          twostr_gg_cldn,     /* g (rodents) = g_org (twostrebe) */\n                          output->dtauc_clr,  /* dtau (rodents) = dtau_org (twostrebe) */\n                          output->ssalb_clr,  /* omega_0 */\n                          twostr_gg_clr,      /* g (rodents) = g_org (twostrebe) */\n                          twostr_cf,          /* cloud fraction */\n                          input.rte.twomaxrnd3C_scale_cf,\n                          output->atm.nlyr + 1,     /* nlev */\n                          rte_in->fbeam,            /* S_0 */\n                          rte_in->umu0,             /* mu_0 */\n                          output->alb.albedo_r[iv], /* surface albedo */\n                          rte_in->planck,           /* whether to use planck */\n                          input.rte.deltam,         /* delta scaling */\n                          output->atm.nzout,        /* nzout */\n                          output->atm.zd,           /* z-levels */\n                          output->atm.microphys.temper[0][0],\n                          rte_in->btemp, /* surface temperature */\n                          output->wl.wvnmlo_r[iv],\n                          output->wl.wvnmhi_r[iv],\n                          input.atm.zout_sur, /* zout's (in km) */\n                          /* output */\n                          rte_out->rfldn,  /* e_minus */\n                          rte_out->flup,   /* e_plus */\n                          rte_out->rfldir, /* s_direct */\n                          rte_out->uavg);  /* KST ???? */\n\n    if (status != 0) {\n      fprintf (stderr, \"Error %d returned by twomaxrnd3C()\\n\", status);\n      return status;\n    }\n#else\n    fprintf (stderr, \"Error: twomaxrnd3C solver not included in uvspec build.\\n\");\n    return -1;\n#endif\n\n    free (twostr_gg_cldk);\n    free (twostr_gg_cldn);\n    free (twostr_gg_clr);\n    free (twostr_cf);\n\n    for (lev = 0; lev < output->atm.nzout; lev++) {\n      rte_out->uavgso[lev] = NAN;\n      rte_out->uavgdn[lev] = NAN;\n      rte_out->uavgup[lev] = NAN;\n    }\n\n    if (planck_tempoff) {\n      rte_in->planck = 1;\n      planck_tempoff = 0;\n    }\n\n    break; /* END twomaxrnd3C */\n\n  case SOLVER_SOS:\n#if HAVE_SOS\n    ASCII_calloc_float (&pmom_sos, output->atm.nlyr, output->atm.nmom + 1);\n\n    for (lu = 0; lu < output->atm.nlyr; lu++)\n      for (k = 0; k < output->atm.nmom + 1; k++)\n        pmom_sos[lu][k] = output->pmom[lu][0][k];\n\n    status = sos (output->atm.nlyr,\n                  rte_in->newgeo,\n                  input.rte.nstr,\n                  input.rte.sos_nscat,\n                  output->alb.albedo_r[iv],\n                  input.r_earth,\n                  output->atm.zd,\n                  output->ssalb,\n                  pmom_sos,\n                  output->dtauc,\n                  output->atm.sza_r[iv],\n                  output->atm.nzout,\n                  input.rte.numu,\n                  input.rte.umu,\n                  rte_in->utau,\n                  rte_out->rfldir,\n                  rte_out->rfldn,\n                  rte_out->flup,\n                  rte_out->uavgso,\n                  rte_out->uavgdn,\n                  rte_out->uavgup,\n                  rte_out->u0u);\n\n    if (status != 0) {\n      fprintf (stderr, \"Error %d returned by sos()\\n\", status);\n      return status;\n    }\n    break;\n#else\n    fprintf (stderr, \"Error: sos solver not included in uvspec build.\\n\");\n    fprintf (stderr, \"Error: Please contact arve.kylling@gmail.com\\n\");\n    return -1;\n#endif\n\n  case SOLVER_SSLIDAR:\n\n    /* NOTE! Lidar only uses one umu!!! */\n\n    phase_back = calloc ((size_t)output->atm.nlyr, sizeof (double*));\n\n    for (lu = 0; lu < output->atm.nlyr; lu++)\n      phase_back[lu] = calloc ((size_t)output->nphamat, sizeof (double));\n\n    /* this only works because mu[0] = -1.0 */\n    for (lu = 0; lu < output->atm.nlyr; lu++)\n      for (is = 0; is < output->nphamat; is++)\n        phase_back[lu][is] = output->phase[lu][is][0];\n\n    status = ss_lidar (/* input: atmosphere */\n                       output->atm.nlyr,\n                       output->atm.zd, /* z-levels */\n                       output->alt.altitude,\n                       output->dtauc,            /* optical depth */\n                       output->ssalb,            /* omega_0 */\n                       phase_back,               /* phase function in backward direction */\n                       output->alb.albedo_r[iv], /* albedo (rodents) = Ag (twostrebe) */\n                       /* input: lidar */\n                       output->wl.lambda_r[iv], /* lidar wavelength */\n                       input.sslidar[SSLIDAR_E0],\n                       input.sslidar[SSLIDAR_POSITION],\n                       input.rte.umu[0], /* only first umu is lidar direction */\n                       input.sslidar_nranges,\n                       input.sslidar[SSLIDAR_RANGE],\n                       output->atm.zout_sur, /* ranges (in km) */\n                       input.sslidar[SSLIDAR_EFF],\n                       input.sslidar[SSLIDAR_AREA],\n                       input.sslidar_polarisation,\n                       /* OUTPUT / RESULT */\n                       rte_out->sslidar_nphot,\n                       rte_out->sslidar_nphot_q,\n                       rte_out->sslidar_ratio);\n    if (status != 0) {\n      fprintf (stderr, \"Error %d returned by ss_lidar()\\n\", status);\n      return status;\n    }\n\n    for (lu = 0; lu < output->atm.nlyr; lu++)\n      free (phase_back[lu]);\n    free (phase_back);\n    break;\n  case SOLVER_NULL:\n    /* do nothing */\n    break;\n\n  default:\n    fprintf (stderr, \"Error: RTE solver %d not yet implemented, call_solver (solve_rte.c)\\n\", input.rte.solver);\n    return -1;\n  }\n\n  if (verbose) {\n    end = clock();\n    fprintf (stderr, \"*** last solver call: %f seconds\\n\", ((double)(end - start)) / CLOCKS_PER_SEC);\n  }\n\n  return 0; /* if o.k. */\n}\n\nstatic int init_rte_input (rte_input* rte, input_struct input, output_struct* output) {\n  int i = 0, found = 0;\n  int ip = 0, is = 0, lu = 0;\n  int status = 0;\n\n  strcpy (rte->header, \"\");\n  rte->accur = 1.0e-5;\n\n  switch (input.source) {\n  case SRC_NONE:\n  case SRC_BLITZ:\n  case SRC_LIDAR:\n    rte->planck = 0;\n    rte->fbeam  = 0.0;\n    rte->fisot  = 0.0;\n    break;\n\n  case SRC_SOLAR:\n    rte->planck = 0;\n\n    if (input.rte.fisot > 0) {\n      rte->fbeam = 0.0;\n      rte->fisot = 1.0;\n    } else {\n      rte->fbeam = 1.0;\n      rte->fisot = 0.0;\n    }\n\n    break;\n\n  case SRC_THERMAL:\n    rte->planck = 1;\n    rte->fbeam  = 0.0;\n    rte->fisot  = 0.0;\n\n    rte->btemp = output->surface_temperature;\n    rte->ttemp = output->atm.microphys.temper[0][0][0];\n\n    rte->temis = 0.0;\n\n    break;\n  default:\n    fprintf (stderr, \"Error, unknown source\\n\");\n    return -1;\n  }\n\n  rte->umu0 = 0.0;\n\n  rte->ierror_d[0] = 0;\n  rte->ierror_s[0] = 0;\n  rte->ierror_t[0] = 0;\n\n  for (i = 0; i < 7; i++)\n    rte->prndis[i] = 0;\n\n  for (i = 0; i < 5; i++)\n    rte->prndis2[i] = 0;\n\n  for (i = 0; i < 2; i++)\n    rte->prntwo[i] = 0;\n\n  rte->ibcnd  = input.rte.ibcnd;\n  rte->lamber = 1;\n  rte->newgeo = 1;\n  rte->nil    = 0;\n  rte->onlyfl = 1;\n  rte->quiet  = input.quiet;\n  rte->usrang = 0;\n  rte->usrtau = 1;\n\n  if (input.rte.pseudospherical || input.rte.solver == SOLVER_SDISORT ||\n      input.rte.solver == SOLVER_SPSDISORT) /* these solvers are spherical by default */\n    rte->spher = 1;\n  else\n    rte->spher = 0;\n\n  rte->hl   = (float*)calloc (input.rte.maxumu + 1, sizeof (float));\n  rte->utau = (float*)calloc (output->atm.nzout, sizeof (float));\n\n  if (input.rte.numu > 0) {\n    rte->onlyfl = 0;\n    rte->usrang = 1;\n  }\n\n  /* PolRadtran */\n  rte->pol.deltam      = \"Y\";\n  rte->pol.ground_type = \"L\";\n  strcpy (rte->pol.polscat, \"\");\n  rte->pol.albedo       = 0.0;\n  rte->pol.btemp        = 0.0;\n  rte->pol.flux         = 1.0;\n  rte->pol.gas_extinct  = NULL;\n  rte->pol.height       = NULL;\n  rte->pol.mu           = 1.0;\n  rte->pol.sky_temp     = 0.0;\n  rte->pol.temperatures = NULL;\n  rte->pol.wavelength   = 0.0;\n  rte->pol.outlevels    = NULL;\n  rte->pol.nummu        = 0;\n\n  rte->pol.ground_index.re = 0.0;\n  rte->pol.ground_index.im = 0.0;\n\n  /* get the indices of the zout levels in the z-scale */\n  rte->pol.outlevels = (int*)calloc (output->atm.nzout, sizeof (int));\n  found              = 0;\n  for (i = 0; i < output->atm.nzout; i++)\n    for (lu = 0; lu < output->atm.nlev; lu++) {\n      if (fabs (output->atm.zout_sur[i] - output->atm.zd[lu]) <= 0) {\n        rte->pol.outlevels[found++] = lu + 1;\n        break;\n      }\n    }\n\n  switch (input.rte.solver) {\n  case SOLVER_MONTECARLO:\n    /* set number of photons */\n    output->mc_photons = input.rte.mc.photons;\n    break;\n  case SOLVER_SDISORT:\n  case SOLVER_SPSDISORT:\n  case SOLVER_FDISORT1:\n  case SOLVER_SSS:\n  case SOLVER_SSSI:\n  case SOLVER_TZS:\n    for (ip = 0; ip < input.rte.nprndis; ip++)\n      (rte->prndis)[input.rte.prndis[ip] - 1] = 1;\n    break;\n  case SOLVER_DISORT:\n  case SOLVER_FDISORT2:\n    for (ip = 0; ip < input.rte.nprndis; ip++)\n      (rte->prndis2)[input.rte.prndis[ip] - 1] = 1;\n    break;\n  case SOLVER_POLRADTRAN:\n    /* Need to do a little checking of polradtran specific input stuff here...*/\n    if (found != output->atm.nzout) {\n      fprintf (stderr, \"*** zout does not correspond to atmosphere file levels.\\n\");\n      fprintf (stderr, \"*** zout must do so for the polradtran solver.\\n\");\n      status--;\n    }\n\n    if (input.rte.deltam == 0)\n      rte->pol.deltam = \"N\";\n    else if (input.rte.deltam == 1)\n      rte->pol.deltam = \"Y\";\n\n    if ((output->mu_values = (float*)calloc (input.rte.nstr / 2 + input.rte.numu, sizeof (float))) == NULL)\n      return -1;\n\n    if (strncmp (input.rte.pol_quad_type, \"E\", 1) == 0)\n      for (i = 0; i < input.rte.numu; i++)\n        output->mu_values[input.rte.nstr / 2 + i] = input.rte.umu[i];\n\n    rte->pol.gas_extinct  = (double*)calloc (output->atm.nlyr + 1, sizeof (double));\n    rte->pol.height       = (double*)calloc (output->atm.nlyr + 1, sizeof (double));\n    rte->pol.temperatures = (double*)calloc (output->atm.nlyr + 1, sizeof (double));\n\n    output->atm.pol_scat_files = (char*)calloc (64 * output->atm.nlyr, sizeof (char));\n\n    for (is = 0; is < 64 * output->atm.nlyr; is++)\n      output->atm.pol_scat_files[is] = ' ';\n\n    for (lu = 0; lu < output->atm.nlyr; lu++) {\n      is = lu * 64;\n      if (lu > 998)\n        return err_out (\"nlyr must be < 999, or a sprintf buffer overflow would occur,fix this\", output->atm.nlyr);\n      sprintf (rte->pol.polscat, \".scat_file_%03d\", lu);\n      strcpy (&output->atm.pol_scat_files[is], rte->pol.polscat);\n    }\n\n    for (lu = 0; lu <= output->atm.nlyr; lu++) {\n      rte->pol.height[lu]       = (double)lu; /*  Weird hey???? Well, the story goes as \n\t\t\t\t\t      follows: polradtran wants extinction and\n\t\t\t\t\t      scattering in terms of 1/(layerthickness).\n\t\t\t\t\t      However, we feed it optical depth. Hence,\n\t\t\t\t\t      we need to make delta_height of each layer\n\t\t\t\t\t      equal one. One simple remedy is the one\n\t\t\t\t\t      used. Arve 15.03.2000 */\n      rte->pol.temperatures[lu] = (double)output->atm.microphys.temper[0][0][lu];\n    }\n    break;\n  case SOLVER_TWOSTR:\n  case SOLVER_FTWOSTR:\n    for (ip = 0; ip < input.rte.nprndis; ip++)\n      if (input.rte.prndis[ip] == 1 || input.rte.prndis[ip] == 2)\n        (rte->prntwo)[input.rte.prndis[ip] - 1] = 1;\n    break;\n  case SOLVER_SOS:\n  case SOLVER_NULL:\n  case SOLVER_RODENTS:\n  case SOLVER_TWOSTREBE:\n  case SOLVER_TWOMAXRND:\n  case SOLVER_TWOMAXRND3C:\n  case SOLVER_DYNAMIC_TWOSTREAM:\n  case SOLVER_DYNAMIC_TENSTREAM:\n  case SOLVER_SSLIDAR:\n    break;\n  default:\n    fprintf (stderr, \"Error: RTE solver %d not yet implemented, init_rte_input (solve_rte.c)\\n\", input.rte.solver);\n    return -1;\n    break;\n  }\n\n  return status;\n}\n\nstatic void fourier2azimuth (double**** down_rad_rt3,\n                             double**** up_rad_rt3,\n                             double**** down_rad,\n                             double**** up_rad,\n                             int        nzout,\n                             int        aziorder,\n                             int        nstr,\n                             int        numu,\n                             int        nstokes,\n                             int        nphi,\n                             float*     phi) {\n  /* For each azimuth and polar angle sum the Fourier azimuth series appropriate\n     for the particular Stokes parameter to produce the radiance.\n     Only used for the polradtran solver \n  */\n  int    i = 0, j = 0, je = 0, k = 0, lu = 0, m = 0;\n  double sumd = 0, sumu = 0;\n  float  phir;\n  for (lu = 0; lu < nzout; lu++) {\n    for (k = 0; k < nphi; k++) {\n      phir = PI * phi[k] / 180.0;\n\n      /* Up- and downwelling irradiances at user angles only*/\n      /*      for (j=0;j<nstr/2+numu;j++) {  */\n      for (j = 0; j < numu; j++) {\n        je = j + nstr / 2;\n        for (i = 0; i < nstokes; i++) {\n          sumd = 0.0;\n          sumu = 0.0;\n          for (m = 0; m <= aziorder; m++) {\n            if (i < 2) {\n              sumd += cos (m * phir) * down_rad_rt3[lu][m][je][i];\n              sumu += cos (m * phir) * up_rad_rt3[lu][m][je][i];\n            } else {\n              sumd += sin (m * phir) * down_rad_rt3[lu][m][je][i];\n              sumu += sin (m * phir) * up_rad_rt3[lu][m][je][i];\n            }\n          }\n          down_rad[lu][k][j][i] = sumd;\n          up_rad[lu][k][j][i]   = sumu;\n        }\n      }\n    }\n  }\n}\n\n/***************************************************************/\n/* calc_spectral_heating calculates the divergence of the flux */\n/* either by differences of the flux or                        */\n/* with the help of the actinic flux                           */\n/***************************************************************/\n\nstatic int calc_spectral_heating (input_struct   input,\n                                  output_struct* output,\n                                  float*         dz,\n                                  double*        rho_mass_zout,\n                                  float*         k_abs,\n                                  float*         k_abs_layer,\n                                  int*           zout_index,\n                                  rte_output*    rte_out,\n                                  float*         heat,\n                                  float*         emis,\n                                  float*         w_zout,\n                                  int            iv) {\n\n  int status = 0;\n\n  int lz    = NOT_DEFINED_INTEGER;\n  int lc    = NOT_DEFINED_INTEGER;\n  int nzout = NOT_DEFINED_INTEGER;\n  int nlev  = NOT_DEFINED_INTEGER;\n  int nlyr  = NOT_DEFINED_INTEGER;\n\n  /* float *Fup = NULL; */\n  /* float *Fdn = NULL; */\n  float* F_net = NULL;\n  float  dFdz  = 0;\n  float* c_p   = 0;\n\n  float* dtheta_dz_layer = NULL;\n  float* dtheta_dz       = NULL;\n\n  float* dFdz_array = NULL;\n  int    lz1 = NOT_DEFINED_INTEGER, lz2 = NOT_DEFINED_INTEGER, n_lz = NOT_DEFINED_INTEGER;\n  float  M_AIR           = MOL_MASS_AIR / 1000.0; /* molecular weight of air (kg mol-1) */\n  float  planck_radiance = 0.0;\n\n  float* z_center  = NULL;\n  float* zout_in_m = NULL;\n  int    outside   = 0;\n  int    start     = 0;\n\n  /*   int additional_verbose_output=FALSE; */\n\n  nlev  = output->atm.nlev;\n  nlyr  = nlev - 1;\n  nzout = output->atm.nzout;\n\n  /* center heights of the atmosphere layers in m */\n  if (((z_center) = (float*)calloc (nlyr, sizeof (float))) == NULL) {\n    fprintf (stderr, \"Error allocating memory for 'z_center'\\n\");\n    fprintf (stderr, \"       (line %d, function '%s' in '%s')\\n\", __LINE__, __func__, __FILE__);\n    return -1;\n  }\n  for (lc = 0; lc < nlyr; lc++)\n    z_center[lc] = output->atm.zd[lc] * 1000.0 - dz[lc] / 2; /* 1000 == km -> m */\n\n  /* zout_in_m == levels (layer boundaries) of zout levels in m above surface */\n  if (((zout_in_m) = (float*)calloc (nzout, sizeof (float))) == NULL) {\n    fprintf (stderr, \"Error allocating memory for 'zout_in_m'\\n\");\n    fprintf (stderr, \"       (line %d, function '%s' in '%s')\\n\", __LINE__, __func__, __FILE__);\n    return -1;\n  }\n  for (lz = 0; lz < nzout; lz++) {\n    zout_in_m[lz] = output->atm.zout_sur[lz] * 1000.0; /* 1000 == km -> m */\n    /* if (iv == 0) fprintf(stderr,\"zout in metern %3d = %10.3f\\n\", lz, zout_in_m[lz] ); */\n  }\n\n  if (((dtheta_dz) = (float*)calloc (nzout, sizeof (float))) == NULL) {\n    fprintf (stderr, \"Error allocating memory for 'dtheta_dz'\\n\");\n    fprintf (stderr, \"       (line %d, function '%s' in '%s')\\n\", __LINE__, __func__, __FILE__);\n    return -1;\n  }\n\n  /* calculate normalized (1/incident_flux) spectral heating rate */\n  switch (input.heating) {\n  case HEAT_LAYER_CD:\n  case HEAT_LAYER_FD:\n\n    /*   /\\* additional verbose output *\\/ */\n    /*   if (additional_verbose_output) { */\n    /*     if (((Fup) = (float *) calloc (nzout, sizeof(float))) == NULL) { */\n    /*       fprintf (stderr, \"Error allocating memory for (Fup) in %s (%s)\\n\", function_name, file_name); */\n    /*       return -1; */\n    /*     } */\n\n    /*     if (((Fdn) = (float  *) calloc (nzout, sizeof(float))) == NULL) { */\n    /*       fprintf (stderr, \"Error allocating memory for (Fdn) in %s (%s)\\n\", function_name, file_name); */\n    /*       return -1; */\n    /*     } */\n    /*   } */\n\n    if (((F_net) = (float*)calloc (nzout, sizeof (float))) == NULL) {\n      fprintf (stderr, \"Error allocating memory for 'dF'\\n\");\n      fprintf (stderr, \"       (line %d, function '%s' in '%s')\\n\", __LINE__, __func__, __FILE__);\n      return -1;\n    }\n\n    if (((dFdz_array) = (float*)calloc (nzout, sizeof (float))) == NULL) {\n      fprintf (stderr, \"Error allocating memory for 'dFdz_array'\\n\");\n      fprintf (stderr, \"       (line %d, function '%s' in '%s')\\n\", __LINE__, __func__, __FILE__);\n      return -1;\n    }\n\n    if (((c_p) = (float*)calloc (nzout, sizeof (float))) == NULL) {\n      fprintf (stderr, \"Error allocating memory for 'c_p'\\n\");\n      fprintf (stderr, \"       (line %d, function '%s' in '%s')\\n\", __LINE__, __func__, __FILE__);\n      return -1;\n    }\n\n    switch (input.rte.solver) {\n    case SOLVER_FDISORT1:\n    case SOLVER_SDISORT:\n    case SOLVER_FTWOSTR:\n    case SOLVER_TWOSTR:\n    case SOLVER_RODENTS:\n    case SOLVER_TWOSTREBE:\n    case SOLVER_TWOMAXRND:\n    case SOLVER_TWOMAXRND3C:\n    case SOLVER_DYNAMIC_TWOSTREAM:\n    case SOLVER_DYNAMIC_TENSTREAM:\n    case SOLVER_SOS:\n    case SOLVER_MONTECARLO:\n    case SOLVER_FDISORT2:\n    case SOLVER_DISORT:\n    case SOLVER_SPSDISORT:\n    case SOLVER_TZS:\n    case SOLVER_SSS:\n    case SOLVER_SSSI:\n    case SOLVER_NULL:\n      for (lz = 0; lz < nzout; lz++) {\n        /*       if (additional_verbose_output) { */\n        /*         Fdn[lz] = rte_out->rfldir[lz] + rte_out->rfldn[lz]; */\n        /*         Fup[lz] = rte_out->flup[lz]; */\n        /*       } */\n        F_net[lz] = (rte_out->rfldir[lz] + rte_out->rfldn[lz]) - rte_out->flup[lz];\n      }\n      break;\n    case SOLVER_POLRADTRAN:\n      for (lz = 0; lz < nzout; lz++) {\n        /*       if (additional_verbose_output) { */\n        /*         Fdn[lz] = rte_out->polradtran_down_flux[lz][0]; */\n        /*         Fup[lz] = rte_out->polradtran_up_flux[lz][0]; */\n        /*       } */\n        F_net[lz] = rte_out->polradtran_down_flux[lz][0] - rte_out->polradtran_up_flux[lz][0];\n      }\n      break;\n    default:\n      fprintf (stderr, \"Error: unknown solver id number %d\\n\", input.rte.solver);\n      fprintf (stderr, \"       (line %d, function '%s' in '%s')\\n\", __LINE__, __func__, __FILE__);\n      return -1;\n      break;\n    }\n\n    if (input.heating == HEAT_LAYER_CD)\n      n_lz = nzout;\n    if (input.heating == HEAT_LAYER_FD)\n      n_lz = nzout - 1;\n\n    for (lz = 0; lz < n_lz; lz++) {\n\n      if (input.heating == HEAT_LAYER_CD) {\n        if (lz == 0) {\n          lz1 = lz;\n          lz2 = lz + 1;\n        } else if (lz == output->atm.nzout - 1) {\n          lz1 = lz - 1;\n          lz2 = lz;\n        } else {\n          lz1 = lz - 1;\n          lz2 = lz + 1;\n        }\n\n        if (lz != 0 && lz != output->atm.nzout - 1) {\n          /* centered difference */ /* 1.0e+6: convert from cm-3 to m-3 */\n          rho_mass_zout[lz] = output->atm.microphys.dens_zout[MOL_AIR][lz] * 1.0e+6 * M_AIR / AVOGADRO;\n\n          /* mass weighted mean of specific heating rates */\n          c_p[lz] = output->atm.microphys.c_p[lz];\n        } else {\n          /* boundary, no centered difference possible, (log) average density for forward difference */\n          rho_mass_zout[lz] =\n            log_average (output->atm.microphys.dens_zout[MOL_AIR][lz1], output->atm.microphys.dens_zout[MOL_AIR][lz2]) * 1.0e+6 *\n            M_AIR / AVOGADRO;\n\n          /* mass weighted mean of specific heating rates, assuming exponential change of density and linear change of c_p */\n          c_p[lz] = mass_weighted_average (output->atm.microphys.c_p[lz1],\n                                           output->atm.microphys.c_p[lz2],\n                                           output->atm.microphys.dens_zout[MOL_AIR][lz1],\n                                           output->atm.microphys.dens_zout[MOL_AIR][lz2]);\n        }\n      } else if (input.heating == HEAT_LAYER_FD) {\n        /* forward difference */\n        lz1 = lz;\n        lz2 = lz + 1;\n\n        /* effective density for one layer (logarithmic) */ /* 1.0e+6: convert from cm-3 to m-3 */\n        rho_mass_zout[lz] =\n          log_average (output->atm.microphys.dens_zout[MOL_AIR][lz1], output->atm.microphys.dens_zout[MOL_AIR][lz2]) * 1.0e+6 *\n          M_AIR / AVOGADRO;\n\n        /* mass weighted mean of specific heating rates, assuming exponential change of density and linear change of c_p */\n        c_p[lz] = mass_weighted_average (output->atm.microphys.c_p[lz1],\n                                         output->atm.microphys.c_p[lz2],\n                                         output->atm.microphys.dens_zout[MOL_AIR][lz1],\n                                         output->atm.microphys.dens_zout[MOL_AIR][lz2]);\n      } else {\n        fprintf (stderr, \"Error, unknown processing scheme %d\\n\", input.processing);\n        fprintf (stderr, \"        (line %d, function '%s' in '%s')\\n\", __LINE__, __func__, __FILE__);\n      }\n\n      /* Compute the derivative dF/dz using a two-point formula */\n\n      if (fabs ((F_net[lz1] - F_net[lz2]) / F_net[lz1]) > 1.0E-6 ||\n          fabs ((output->atm.zout_sur[lz1] - output->atm.zout_sur[lz2]) * rho_mass_zout[lz]) > 1.0E-6) {\n        dFdz = (F_net[lz1] - F_net[lz2]) / (output->atm.zout_sur[lz1] - output->atm.zout_sur[lz2]);\n      } else\n        dFdz = NAN;\n\n      dFdz_array[lz] = 0.001 * dFdz; /* 1/1000 = km -> m, for dz */\n\n      /*       if (additional_verbose_output) { */\n      /*        if (lz==0) { */\n      /*          fprintf (stderr, \" ... calling calc_spectral_heating()\\n\"); */\n      /*          if (input.heating == HEAT_LAYER_CD)  fprintf (stderr, \" ... calculate heating_rate with centered differences \\n\"); */\n      /*          if (input.heating == HEAT_LAYER_FD)  fprintf (stderr, \" ... calculate heating_rate with forward differences \\n\"); */\n      /*          fprintf (stderr, \"\\n#--------------------------------------------------------------------------------------------------------------------------------\\n\"); */\n      /*          fprintf (stderr, \"#lvl      z    l1  l2    z(l1)    z(l2)    E(l1)     E(l2)      dE/dz      |dE/E|        Edn       Eup      Edn/dz        Eup/dz   \\n\"); */\n      /*          fprintf (stderr, \"#         km              km       km      W/m2      W/m2      W/(m2 m)                  W/m2      W/m2    W/(m2 km)     W/(m2 km) \\n\"); */\n      /*          fprintf (stderr, \"#----------------------------------------------------------------------------------------------------------------------------------\\n\"); */\n      /*        } */\n\n      /*        fprintf (stderr, \"%3d %9.3f %3d %3d %8.3f %8.3f %9.4f %9.4f %12.5e %10.5e %9.4f %9.4f %12.5e %12.5e\\n\", */\n      /*           lz, output->atm.zout_sur[lz], lz1, lz2, output->atm.zout_sur[lz1],output->atm.zout_sur[lz2], */\n      /*           F_net[lz1],F_net[lz2],dFdz_array[lz],fabs((F_net[lz1]-F_net[lz2])/F_net[lz1]),Fdn[lz],Fup[lz], */\n      /*           (Fdn[lz1]-Fdn[lz2])/(output->atm.zout_sur[lz1]-output->atm.zout_sur[lz2]),(Fup[lz1]-Fup[lz2])/(output->atm.zout_sur[lz1]-output->atm.zout_sur[lz2])); */\n      /*       } */\n\n      heat[lz] = dFdz_array[lz] / (rho_mass_zout[lz] * c_p[lz]);\n\n      /* calculate dtheta_dz from zout-levels */\n      dtheta_dz[lz] = (output->atm.microphys.theta_zout[lz1] - output->atm.microphys.theta_zout[lz2]) /\n                      (1000.0 * (output->atm.zout_sur[lz1] - output->atm.zout_sur[lz2]));\n\n      w_zout[lz] = (output->atm.microphys.theta_zout[lz] / output->atm.microphys.temper_zout[lz]) * 1.0 / dtheta_dz[lz] * heat[lz];\n    }\n\n    /*   if (additional_verbose_output) { */\n    /*     free(Fup); */\n    /*     free(Fdn); */\n    /*   } */\n\n    free (F_net);\n    free (dFdz_array);\n    free (c_p);\n\n    break;\n  case HEAT_LOCAL:\n\n    /* spline interpolation of all level EXEPT LOWEST AND HIGHEST LEVEL */\n    /* they are outside of the range of layer midpoints and must therefor be extrapolated !!!! */\n\n    if (((dtheta_dz_layer) = (float*)calloc (nlyr, sizeof (float))) == NULL) {\n      fprintf (stderr, \"Error allocating memory for 'dtheta_dz_layer'\\n\");\n      fprintf (stderr, \"       (line %d, function '%s' in '%s')\\n\", __LINE__, __func__, __FILE__);\n      return -1;\n    }\n\n    outside = 0;\n    /* k_abs_layer == absorption coefficient representative for one layer (layer midpoint is z_center) */\n    for (lc = 0; lc < nlyr; lc++) {\n      k_abs_layer[lc]     = (1.0 - output->ssalb[lc]) * output->dtauc[lc] / dz[lc];\n      dtheta_dz_layer[lc] = (output->atm.microphys.theta[lc + 1] - output->atm.microphys.theta[lc]) /\n                            ((output->atm.zd[lc + 1] - output->atm.zd[lc]) * 1000.0);\n    }\n\n    /* if uppermost zout level is above the uppermost layer midpoint (e.g. zout TOA),  */\n    /* than extrapolate k_abs from the uppermost 2 layers                              */\n    if (zout_in_m[nzout - 1] > z_center[0]) {\n      outside = 1;\n      /* exponentiell extrapolation, as linear might cause negative values */\n      if (k_abs_layer[1] != 0.0)\n        k_abs[nzout - 1] =\n          k_abs_layer[0] * pow (k_abs_layer[0] / k_abs_layer[1], dz[0] / ((output->atm.zd[0] - output->atm.zd[2]) * 1000.0));\n      else\n        /* if not possible, take value from the last layer, in most cases also 0.0  */\n        k_abs[nzout - 1] = k_abs_layer[0];\n      /* first difference */\n      dtheta_dz[nzout - 1] = dtheta_dz_layer[0]; /* zout is sorted ascending, z_atm descending */\n    }\n\n    /* if lowermost zout level is below the lowest layer midpoint (e.g. zout surface),  */\n    /* than extrapolate k_abs from the lowermost 2 layers                              */\n    if (zout_in_m[0] < z_center[nlyr - 1]) {\n      outside = outside + 1;\n      start   = 1;\n      /* linear extrapolation */\n      k_abs[0] = k_abs_layer[nlyr - 1] - dz[nlyr - 1] * (k_abs_layer[nlyr - 1] - k_abs_layer[nlyr - 2]) /\n                                           ((output->atm.zd[nlyr] - output->atm.zd[nlyr - 2]) * 1000.0); /* 1000 = km -> m */\n      /* canceled 2/2 in (dz/2)/((z[2]-z[0])/2) */\n      /* last difference */\n      dtheta_dz[0] = dtheta_dz_layer[nlyr - 1]; /* zout is sorted ascending, z_atm descending */\n    }\n\n    /* interpolate the rest, attention pointer arithmetic, last argument 1 means descending order of z_center */\n    /* in versions before Jan 2008 also INTERP_METHOD_SPLINE was tested                 */\n    /* but this caused overshootings, if clouds are present.                            */\n    /* thereforwe use linear PLUS additional levels around the zout level, UH Feb 2008 */\n    status = arb_wvn (nlyr, z_center, k_abs_layer, nzout - outside, zout_in_m + start, k_abs + start, INTERP_METHOD_LINEAR, 1);\n    if (status != 0) {\n      fprintf (stderr, \" Error, interpolation of 'k_abs'\\n\");\n      fprintf (stderr, \"       (line %d, function '%s' in '%s')\\n\", __LINE__, __func__, __FILE__);\n      return -1;\n    }\n\n    /* interpolate the rest, attention pointer arithmetic, last argument 1 means descending order of z_center */\n    status =\n      arb_wvn (nlyr, z_center, dtheta_dz_layer, nzout - outside, zout_in_m + start, dtheta_dz + start, INTERP_METHOD_LINEAR, 1);\n    if (status != 0) {\n      fprintf (stderr, \" Error, interpolation of 'dtheta_dz'\\n\");\n      fprintf (stderr, \"       (line %d, function '%s' in '%s')\\n\", __LINE__, __func__, __FILE__);\n      return -1;\n    }\n\n    for (lz = 0; lz < nzout; lz++) {\n\n      /* level (local) property */ /* 1.0e+6: convert from cm-3 to m-3 */\n      rho_mass_zout[lz] = output->atm.microphys.dens_zout[MOL_AIR][lz] * 1.0e+6 * M_AIR / AVOGADRO;\n\n      /* correction of the emission term of the heating rate, when calculated with actinic flux */\n      if (input.source == SRC_THERMAL) {\n        F77_FUNC (cplkavg, CPLKAVG)\n        (&(output->wl.wvnmlo_r[iv]), &(output->wl.wvnmhi_r[iv]), &(output->atm.microphys.temper_zout[lz]), &(planck_radiance));\n      }\n      /* (else (in the solar case) planck_radiance == 0) */\n\n      heat[lz] = k_abs[lz] * 4.0 * PI * (rte_out->uavg[lz] - planck_radiance) / (rho_mass_zout[lz] * output->atm.microphys.c_p[lz]);\n      emis[lz] = k_abs[lz] * 4.0 * PI * (-planck_radiance) / (rho_mass_zout[lz] * output->atm.microphys.c_p[lz]);\n\n      w_zout[lz] = (output->atm.microphys.theta_zout[lz] / output->atm.microphys.temper_zout[lz]) * 1.0 / dtheta_dz[lz] * heat[lz];\n    }\n\n    /* overwrite heating rate in case of dynamic twostream; in that case uavg contains dEnet */\n    if (input.rte.solver == SOLVER_DYNAMIC_TWOSTREAM || input.rte.solver == SOLVER_DYNAMIC_TENSTREAM) {\n\n      if (!input.quiet)\n        fprintf (stderr, \" ... overwriting heating rate by uavg (dynamic_twostream special)\\n\");\n\n      for (lz = 0; lz < nzout - 1; lz++) {\n        /* BM, 18.9.2020: copied from layer_fd above */\n        double rho_mass_tmp =\n          log_average (output->atm.microphys.dens_zout[MOL_AIR][lz], output->atm.microphys.dens_zout[MOL_AIR][lz + 1]) * 1.0e+6 *\n          M_AIR / AVOGADRO;\n\n        /* mass weighted mean of specific heating rates, assuming exponential change of density and linear change of c_p */\n        double c_p_tmp = mass_weighted_average (output->atm.microphys.c_p[lz],\n                                                output->atm.microphys.c_p[lz + 1],\n                                                output->atm.microphys.dens_zout[MOL_AIR][lz],\n                                                output->atm.microphys.dens_zout[MOL_AIR][lz + 1]);\n\n        // factor 1000.0 converts z from km to m\n        heat[lz] =\n          rte_out->uavg[lz] / (rho_mass_tmp * c_p_tmp) / (output->atm.zout_sur[lz + 1] - output->atm.zout_sur[lz]) / 1000.0;\n        emis[lz] = NAN;\n      }\n    }\n\n    break;\n  default:\n    fprintf (stderr, \"Error, unknown processing scheme %d\\n\", input.processing);\n    fprintf (stderr, \"       (line %d, function '%s' in '%s')\\n\", __LINE__, __func__, __FILE__);\n    return -1;\n  }\n\n  free (z_center);\n  free (zout_in_m);\n  free (dtheta_dz);\n\n  return status;\n}\n\nstatic float*** calloc_abs3d (int Nx, int Ny, int Nz, int* threed) {\n  int      lc = 0, lx = 0;\n  float*** tmp;\n\n  tmp = calloc (Nz, sizeof (float**));\n  if (tmp == NULL)\n    return NULL;\n\n  for (lc = 0; lc < Nz; lc++)\n    if (threed[lc]) {\n      tmp[lc] = calloc (Nx, sizeof (float*));\n      if (tmp[lc] == NULL)\n        return NULL;\n\n      for (lx = 0; lx < Nx; lx++) {\n        tmp[lc][lx] = calloc (Ny, sizeof (float));\n        if (tmp[lc][lx] == NULL)\n          return NULL;\n      }\n    }\n\n  return tmp;\n}\n\nstatic void free_abs3d (float*** abs3d, int Nx, int Ny, int Nz, int* threed) {\n  int lc = 0, lx = 0;\n\n  for (lc = 0; lc < Nz; lc++)\n    if (threed[lc]) {\n      for (lx = 0; lx < Nx; lx++)\n        free (abs3d[lc][lx]);\n      free (abs3d[lc]);\n    }\n\n  free (abs3d);\n}\n\nstatic float**** calloc_spectral_abs3d (int Nx, int Ny, int Nz, int nlambda, int* threed) {\n  int       lx = 0, ly = 0, lc = 0;\n  float**** tmp = NULL;\n\n  if ((tmp = (float****)calloc (Nz, sizeof (float***))) == NULL)\n    return NULL;\n\n  for (lc = 0; lc < Nz; lc++) {\n    if (threed[lc]) {\n      if ((tmp[lc] = (float***)calloc (Nx, sizeof (float**))) == NULL)\n        return NULL;\n\n      for (lx = 0; lx < Nx; lx++) {\n        if ((tmp[lc][lx] = (float**)calloc (Ny, sizeof (float*))) == NULL)\n          return NULL;\n\n        for (ly = 0; ly < Ny; ly++)\n          if ((tmp[lc][lx][ly] = (float*)calloc (nlambda, sizeof (float))) == NULL)\n            return NULL;\n      }\n    }\n  }\n\n  return tmp;\n}\n\n/***********************************************************************************/\n/* Function: generate_effective_cloud                                              */\n/*                                                                                 */\n/* Description:                                                                    */\n/*  * Generates an effective cloud assuming random overlap (as in ECHAM)           */\n/*    given cloud profiles and cloud fraction.                                     */\n/*  * save the effective cloud optical property on the wc-structure                */\n/*  * ic-structure is set to 0.0, as wc-structure contrains both now               */\n/*                                                                                 */\n/* Parameters (input/output):                                                      */\n/*   input          uvspec input structure                                         */\n/*   output         uvspec output structure                                        */\n/*   save_cloud     unmodified cloud properties for given wavelength               */\n/*   iv             wavelength index                                               */\n/*   iq             subband index                                                  */\n/*   verbose        flag for verbose output                                        */\n/*                                                                                 */\n/*                                                                                 */\n/* Return value:                                                                   */\n/*     int status         == 0, if everthing is OK                                 */\n/*                        < 0, if there was an error                               */\n/*                                                                                 */\n/* Example:                                                                        */\n/* Files:    solver_rte.c                                                          */\n/* Known bugs: -                                                                   */\n/* Author:                                                                         */\n/*    xxx 200x   C. Emde       Created                                             */\n/*                                                                                 */\n/***********************************************************************************/\n\nstatic int\ngenerate_effective_cloud (input_struct input, output_struct* output, save_optprop* save_cloud, int iv, int iq, int verbose) {\n\n  int    lc = 0, i = 0, isp = 0;\n  float  tauw = 0.0, taui = 0.0, taua = 0.0, taum = 0.0, taur = 0.0, tau_clear = 0.0, tau_cloud = 0.0;\n  float  g1d = 0.0, g2d = 0.0, fd = 0.0, g1i = 0.0, g2i = 0.0, fi = 0.0, gi = 0.0, gw = 0.0;\n  float  ssai = 0.0, ssaw = 0.0;\n  float *ssa = NULL, *tau = NULL, *g = NULL;\n\n  /* Reflectivity of underlying layer, should be zero, because here\n     we calculate just the effective optical thickness of one\n     layer. This optical thickness is used in the RTE solver, where\n     then of course the reflectivity of the neighbour layers is\n     considered. */\n  float pref = 0.0;\n  /* Solar zenith angle */\n  float mu = 0.0;\n  /* Effective solar zenith angle, accounts for the decrease of the\n     direct solar beam and the corresponding increase of the diffuse\n     part of the radiation (in ECHAM). Here always the solar zenith\n     angle is used (see below). */\n  float mu_eff = 0.0;\n  /* Diffusivity factor, 1.66 in ECHAM */\n  float r = 1.66;\n  /* Effective cloudyness */\n  float C_eff = 0.0, product = 1.0;\n  /* Output variables of swde */\n  float pre1 = 0.0, pre2 = 0.0, ptr2 = 0.0;\n  /* Transmission of clear and cloudy parts and of the layer */\n  float transmission_clear = 0.0, transmission_cloud = 0.0, transmission_layer = 0.0;\n  /* Variables for iteratiom */\n  float taueff = 0.0;\n  /* cloud fraction to scale the optical thickness */\n  /* Attention: ECHAM input is already scaled to cloudy part */\n  float cf            = 1.0;\n  int   first_verbose = TRUE;\n\n  /*   if ( input.cloud_overlap == CLOUD_OVERLAP_OFF ) { */\n  /*     fprintf (stderr, \"Error: call of %s, but cloud overlap schema is switched off\\n\", __func__ ); */\n  /*     return -1; */\n  /*   } */\n\n  if (verbose && output->cf.nlev > 0) {\n    fprintf (stderr, \" ... generate effective cloud\\n\");\n  }\n\n  ssa = (float*)calloc (output->atm.nlev - 1, sizeof (float));\n  tau = (float*)calloc (output->atm.nlev - 1, sizeof (float));\n  g   = (float*)calloc (output->atm.nlev - 1, sizeof (float));\n\n  mu = cos (output->atm.sza_r[iv] * PI / 180);\n\n  /* scattering properties */\n  for (lc = 0; lc < output->atm.nlev - 1; lc++) {\n\n    /* Ice and water clouds */\n    tauw = save_cloud->tauw[lc];\n    taui = save_cloud->taui[lc];\n\n    g1d = save_cloud->g1d[lc];\n    g2d = save_cloud->g2d[lc];\n    fd  = save_cloud->fd[lc];\n    gw  = g1d * fd + (1.0 - fd) * g2d;\n\n    g1i = save_cloud->g1i[lc];\n    g2i = save_cloud->g2i[lc];\n    fi  = save_cloud->fi[lc];\n    gi  = g1i * fi + (1.0 - fi) * g2i;\n\n    ssaw = save_cloud->ssaw[lc];\n    ssai = save_cloud->ssai[lc];\n\n    /* molecular absorption */\n    taum = output->atm.optprop.tau_molabs_r[0][0][lc][iv][iq];\n\n    /* aerosol */\n    taua = output->aer.optprop.dtau[iv][lc];\n    //20120816ak stuff below is not in use, commented\n    //    ssaa  = output->aer.optprop.ssa[iv][lc];\n    //    g1a   = output->aer.optprop.g1[iv][lc];\n    //    g2a   = output->aer.optprop.g2[iv][lc];\n    //    fa    = output->aer.optprop.ff[iv][lc];\n    //    ga    = g1a*fa+(1.0-fa)*g2a;\n\n    /*Rayleigh*/\n    switch (input.ck_scheme) {\n    case CK_FU:\n      taur = output->atm.optprop.tau_rayleigh_r[0][0][lc][iv][iq];\n      break;\n\n    case CK_KATO:\n    case CK_KATO2:\n    case CK_KATO2_96:\n    case CK_KATO2ANDWANDJI:\n    case CK_AVHRR_KRATZ:\n    case CK_FILE:\n    case CK_LOWTRAN:\n    case CK_CRS:\n    case CK_REPTRAN:\n    case CK_REPTRAN_CHANNEL:\n    case CK_RAMAN:\n      taur = output->atm.optprop.tau_rayleigh_r[0][0][lc][iv][0];\n      break;\n\n    default:\n      fprintf (stderr, \"Error: unsupported correlated-k scheme %d\\n\", input.ck_scheme);\n      return -1;\n\n      break;\n    }\n\n    /* Calculate mean optical properties of the layer */\n\n    cf = 0.0;\n    for (isp = 0; isp < input.n_caoth; isp++)\n      if (input.caoth[isp].source == CAOTH_FROM_ECHAM || input.caoth[isp].source == CAOTH_FROM_1D)\n        cf = 1.0;\n\n    if (cf == 0.0) { /* else */\n      if (output->cf.cf[lc] != 0.0)\n        cf = output->cf.cf[lc];\n      else\n        cf = 1.0;\n    }\n\n    /* total optical thickness */\n    /* fprintf(stderr, \" scaling tau: tauw = %f, taui = %f, cf = %f\\n\", tauw, taui, cf); */\n    tau_cloud = (tauw + taui) / cf; /* Water and Ice cloud */\n    tau_clear = taum + taua + taur; /* Molecular, Aerosol, and Rayleigh */\n\n    /* Calculate effective Cloudiness */\n\n    /* Total optical thickness */\n    tau[lc] = tau_cloud + tau_clear;\n\n    if ((tauw || taui) != 0.0) {\n      g[lc] = (tauw * ssaw * gw + taui * ssai * gi) / (tauw * ssaw + taui * ssai);\n      /* effective single scattering albedo */\n      ssa[lc] = (tauw * ssaw + taui * ssai) / (tauw + taui);\n    } else {\n      g[lc]   = 1.;\n      ssa[lc] = 1.;\n    }\n\n    if (input.source == SRC_THERMAL)\n      mu_eff = 1. / r;\n    else {\n      /*Calculate effective zenith angle */\n      for (i = lc; i >= 0; i--) {\n        if (mu != 0.0)\n          product *= 1.0 - output->cf.cf[i] * (1.0 - exp (-((1.0 - ssa[i] * g[i] * g[i]) * (tau[lc])) / mu));\n        else\n          product *= 1.0 - output->cf.cf[i];\n      }\n\n      C_eff  = 1.0 - product;\n      mu_eff = mu / (1.0 - C_eff + mu * r * C_eff);\n    }\n\n    /* Call ECHAM radiation routine SWDE. */\n    if ((tauw || taui) != 0.0) {\n\n      /*Initialize inputs for swde.*/\n      pre1               = 0.0;\n      pre2               = 0.0;\n      transmission_cloud = 0.0;\n      transmission_clear = 0.0;\n      ptr2               = 0.0;\n\n      if (verbose) {\n        if (first_verbose) {\n          fprintf (\n            stderr,\n            \"   lc      g        pref    theta_eff   tau        tau_clear      ptr1      ptr2     ssa       cf     taueff\\n\");\n          first_verbose = FALSE;\n        }\n        fprintf (stderr,\n                 \" %4d %9.6f %9.6f %9.3f %12.6e %12.6e %9.6f %9.6f %9.6f %8.5f\",\n                 lc,\n                 g[lc],\n                 pref,\n                 acos (mu_eff) * 180 / PI,\n                 tau[lc],\n                 tau_clear,\n                 transmission_cloud,\n                 ptr2,\n                 ssa[lc],\n                 output->cf.cf[lc]);\n      }\n\n      if (ssa[lc] == 1.0)\n        ssa[lc] = 0.99999;\n\n      /* Perform radiative transfer (twostream) with scaled optical properties\n         to calculate effective optical thickness. */\n      /* Scattering + sbsorption + rayleigh + aerosol*/\n      F77_FUNC (swde, SWDE) (&g[lc], &pref, &mu_eff, &tau[lc], &ssa[lc], &pre1, &pre2, &transmission_cloud, &ptr2);\n\n      ptr2 = 0.0;\n      /* Only absorption, rayleigh, aerosol */\n      F77_FUNC (swde, SWDE) (&g[lc], &pref, &mu_eff, &tau_clear, &ssa[lc], &pre1, &pre2, &transmission_clear, &ptr2);\n\n      /* Transmission of the layer*/\n      transmission_layer = output->cf.cf[lc] * transmission_cloud + (1.0 - output->cf.cf[lc]) * transmission_clear;\n\n      /*    fprintf (stderr,  */\n      /*    \"transmission_cloud %g, transmission_clear %g, transmission_layer %g cloud cover %g \\n\",   */\n      /*         transmission_cloud, transmission_clear, transmission_layer, output->cf.cf[lc+1]);  */\n\n      /* Calculate effective optical thickness */\n      taueff = zbrent_taueff (mu_eff,\n                              g[lc],\n                              ssa[lc],\n                              transmission_cloud,\n                              transmission_layer,\n                              tau_clear,\n                              tau[lc],\n                              0.00001); /* in solve_rte.c, next function */\n\n      /*         fprintf (stderr, \"test %d %g  %g %g %g %g %g %g %g \\n\", lc, */\n      /*                  output->atm.zd[lc]+output->alt.altitude, tau[lc], mu_eff,   */\n      /*                  output->cf.cf[lc], transmission_cloud, transmission_clear,\n                          transmission_layer, taueff); */\n      /*         if (taueff > 0 && taueff < 1e-7) */\n\n      if (verbose)\n        fprintf (stderr, \"  %g\\n\", taueff);\n\n      /* Set the optical properties to be used in rte calculation.*/\n\n      /* wc is now representing both, water and ice clouds */\n      output->caoth[input.i_wc].optprop.dtau[iv][lc] = taueff;\n      output->caoth[input.i_wc].optprop.g1[iv][lc]   = g[lc];\n      output->caoth[input.i_wc].optprop.g2[iv][lc]   = 0.0;\n      output->caoth[input.i_wc].optprop.ff[iv][lc]   = 1.0;\n      output->caoth[input.i_wc].optprop.ssa[iv][lc]  = ssa[lc];\n\n      /* ic is now not needed any more */\n      output->caoth[input.i_ic].optprop.dtau[iv][lc] = 0.0;\n      output->caoth[input.i_ic].optprop.g1[iv][lc]   = 0.0;\n      output->caoth[input.i_ic].optprop.g2[iv][lc]   = 0.0;\n      output->caoth[input.i_ic].optprop.ff[iv][lc]   = 0.0;\n      output->caoth[input.i_ic].optprop.ssa[iv][lc]  = 0.0;\n\n    } else {\n      /* wc is now representing both, water and ice clouds */\n      output->caoth[input.i_wc].optprop.dtau[iv][lc] = 0.0;\n      output->caoth[input.i_wc].optprop.g1[iv][lc]   = 0.0;\n      output->caoth[input.i_wc].optprop.g2[iv][lc]   = 0.0;\n      output->caoth[input.i_wc].optprop.ff[iv][lc]   = 0.0;\n      output->caoth[input.i_wc].optprop.ssa[iv][lc]  = 0.0;\n\n      /* ic is now not needed any more */\n      output->caoth[input.i_ic].optprop.dtau[iv][lc] = 0.0;\n      output->caoth[input.i_ic].optprop.g1[iv][lc]   = 0.0;\n      output->caoth[input.i_ic].optprop.g2[iv][lc]   = 0.0;\n      output->caoth[input.i_ic].optprop.ff[iv][lc]   = 0.0;\n      output->caoth[input.i_ic].optprop.ssa[iv][lc]  = 0.0;\n    }\n  }\n\n  free (ssa);\n  free (tau);\n  free (g);\n  return 0;\n}\n\n/** \n * *zbrent_taueff* returns the effective optical depth of a layer.\n *\n * The function is a slightly modified version of the \"zbrent\" function in the \n * \"Numerical Recipes in C\" (p. 352 ff.) for finding roots of an arbitrary function. \n * The function is here the ECHAM radiative tarnsfer routine swde.f and the root of it \n * is the effective optical thickness.\n * \n * @param mu_eff effective zenith angle\n * @param g asymmetry parameter\n * @param ssa single scattering albedo\n * @param transmission_cloud transmission cloudy part\n * @param transmission_layer total transmission\n * @param x1 clear optical depth\n * @param x2 cloudy optical depth\n * @param tol accuracy\n * \n * @return effective tau\n */\nfloat zbrent_taueff (float mu_eff,\n                     float g,\n                     float ssa,\n                     float transmission_cloud,\n                     float transmission_layer,\n                     float x1,\n                     float x2,\n                     float tol) {\n  int   iter = 0;\n  float a = x1, b = x2, c = x2, d = 0, e = 0, min1 = 0, min2 = 0;\n  float fa = 0, fb = 0;\n  float fc = 0, p = 0, q = 0, r = 0, s = 0, tol1 = 0, xm = 0;\n  int   itmax = 100;\n  float eps   = 3.0e-8;\n  float dummy = 0.0;\n  float pref  = 0.0;\n\n  F77_FUNC (swde, SWDE) (&g, &pref, &mu_eff, &x1, &ssa, &dummy, &dummy, &transmission_cloud, &dummy);\n  fa = transmission_cloud - transmission_layer;\n\n  dummy = 0.0;\n  pref  = 0.0;\n  F77_FUNC (swde, SWDE) (&g, &pref, &mu_eff, &x2, &ssa, &dummy, &dummy, &transmission_cloud, &dummy);\n  fb = transmission_cloud - transmission_layer;\n\n  if ((fa > 0.0 && fb > 0.0) || (fa < 0.0 && fb < 0.0)) {\n    fprintf (stderr, \"Root must be bracketed in zbrent \\n\");\n    fprintf (stderr, \"Please check whether the cloud effective optical thickness has been \\n\");\n    fprintf (stderr, \"calculated correctly. \\n\");\n  }\n  fc = fb;\n  for (iter = 1; iter <= itmax; iter++) {\n    if ((fb > 0.0 && fc > 0.0) || (fb < 0.0 && fc < 0.0)) {\n      c  = a;\n      fc = fa;\n      e = d = b - a;\n    }\n    if (fabs (fc) < fabs (fb)) {\n      a  = b;\n      b  = c;\n      c  = a;\n      fa = fb;\n      fb = fc;\n      fc = fa;\n    }\n    tol1 = 2.0 * eps * fabs (b) + 0.5 * tol;\n    xm   = 0.5 * (c - b);\n    if (fabs (xm) <= tol1 || fb == 0.0)\n      return b;\n    if (fabs (e) >= tol1 && fabs (fa) > fabs (fb)) {\n      s = fb / fa;\n      if (a == c) {\n        p = 2.0 * xm * s;\n        q = 1.0 - s;\n      } else {\n        q = fa / fc;\n        r = fb / fc;\n        p = s * (2.0 * xm * q * (q - r) - (b - a) * (r - 1.0));\n        q = (q - 1.0) * (r - 1.0) * (s - 1.0);\n      }\n      if (p > 0.0)\n        q = -q;\n      p    = fabs (p);\n      min1 = 3.0 * xm * q - fabs (tol1 * q);\n      min2 = fabs (e * q);\n      if (2.0 * p < (min1 < min2 ? min1 : min2)) {\n        e = d;\n        d = p / q;\n      } else {\n        d = xm;\n        e = d;\n      }\n    } else {\n      d = xm;\n      e = d;\n    }\n    a  = b;\n    fa = fb;\n    if (fabs (d) > tol1)\n      b += d;\n    else\n      b += SIGN (tol1, xm);\n\n    dummy = 0.0;\n    pref  = 0.0;\n    F77_FUNC (swde, SWDE) (&g, &dummy, &mu_eff, &b, &ssa, &dummy, &dummy, &transmission_cloud, &dummy);\n    fb = transmission_cloud - transmission_layer;\n  }\n  fprintf (stderr, \"Maximum number of iterations exceeded in zbrent \\n\");\n  return 0.0;\n}\n\nstatic int set_raman_source (double***              qsrc,\n                             double***              qsrcu,\n                             int                    maxphi,\n                             int                    nlev,\n                             int                    nzout,\n                             int                    nstr,\n                             int                    n_shifts,\n                             float                  wanted_wl,\n                             double*                wl_shifts,\n                             float                  umu0,\n                             float*                 zd,\n                             float*                 zout,\n                             float                  zenang,\n                             float                  fbeam,\n                             float                  radius,\n                             float*                 dens,\n                             double**               crs_RL,\n                             double**               crs_RG,\n                             float*                 ssalb,\n                             int                    numu,\n                             float*                 umu,\n                             int                    usrang,\n                             int*                   cmuind,\n                             float***               pmom,\n                             raman_qsrc_components* raman_qsrc_comp,\n                             int*                   zout_comp_index,\n                             float                  altitude,\n                             int                    last,\n                             int                    verbose) {\n\n  /* Equation numbers in this function refer to equations in ESAS-LIGHT */\n  /* report for WP2200.                                                 */\n\n  int status = 0, twonm1, test = 0;\n#if HAVE_SOS\n  int* nfac = NULL;\n#endif\n\n  int static first = 1, nlyr = 0;\n  int            lu = 0, lua = 0, lub = 0, lv = 0, iq = 0, iu = 0, jq = 0, k = 0, l = 0, nn = 0, lc = 0, maz = 0, is = 0;\n  double         sum = 0, sum1 = 0, sum2 = 0, sum3 = 0, sum4 = 0;\n  double static *cmu = NULL, *cwt = NULL, ***ylmc = NULL, ***ylmu = NULL, ***ylm0 = NULL, sgn = 0, *tmpumu = NULL;\n  double *       tmp = NULL, *tmpylmc = NULL, *tmpylmu = NULL, *tmpylm0 = NULL;\n  double static *trs = NULL, **trs_shifted = NULL, *tmp_shifted = NULL, *tmp_dtauc = NULL, *chtau = NULL;\n  double static* tmp_dtauc_shifted = NULL;\n  double static *tmp_dens = NULL, *tmp_dens_org = NULL, **tmp_crs_RG = NULL, **tmp_crs_RL = NULL;\n  double static *tmp_in = NULL, *tmp_out = NULL;\n\n  double static *tmp_cumtau = NULL, *tmp_cumtauint = NULL, **tmp_user_dtauc = NULL, *tmp_zd = NULL, *tmp_zd_org = NULL;\n  int static ntmp_zd = 0;\n\n#if HAVE_SOS\n  double static** fac = NULL;\n#endif\n\n  double g2_R   = 1 / 100.;      /* Legendre expansion coefficients for Raman scattering */\n  double PI_R_b = 0, PI_R_d = 0; /* PIs in Eq. (28)-(29) */\n  double ssalbRL = 0;            /* ssalb for Raman loss, Eq. (40) in Spurr et al 2008 */\n  double ssalbRG = 0;            /* ssalb for Raman gain, Eq. (39) in Spurr et al 2008 */\n  double deltaz = 0, km2cm = 1E+5;\n  ;\n  double delm0       = 1;\n  double crs_RL_tot  = 0;\n  double crs_RG_tot  = 0;\n  double lambda_fact = 0; /* Conversion factor lambdap**2/lambda**2, Eq. A3 Edgington et al. 1999 */\n\n  if (first) {\n\n    nlyr    = nlev - 1;\n    ntmp_zd = nlev;\n\n    /* Need quadrature angles and weights and Legendre polynomials */\n\n    cmu = (double*)calloc (nstr, sizeof (double));\n    cwt = (double*)calloc (nstr, sizeof (double));\n    nn  = nstr / 2;\n\n    c_gaussian_quadrature (nn, cmu, cwt);\n\n    /* Rearrange cmu and cwt such that they are ascending order. qsrc  should */\n    /* have cmu in ascending order, however, internally qdisort does not treat*/\n    /* cmu in ascending order. This feature is inherited from disort.         */\n    for (iq = 0; iq < nn; iq++) {\n      cmu[nn + iq] = cmu[iq];\n      cwt[nn + iq] = cwt[iq];\n    }\n    for (iq = 0; iq < nn; iq++) {\n      cmu[iq] = -cmu[nstr - 1 - iq];\n      cwt[iq] = cwt[nstr - 1 - iq];\n    }\n\n    /* Calculate Legendre polynomials for each m */\n    if ((tmpylmc = (double*)calloc ((size_t) ((nstr + 1) * nstr), sizeof (double))) == NULL)\n      return ASCII_NO_MEMORY;\n    if ((tmpylm0 = (double*)calloc ((size_t) ((nstr + 1) * nstr), sizeof (double))) == NULL)\n      return ASCII_NO_MEMORY;\n    if ((status = ASCII_calloc_double_3D (&ylmc, nstr, nstr, nstr + 1)) != 0)\n      return ASCII_NO_MEMORY;\n    if ((status = ASCII_calloc_double_3D (&ylm0, nstr, nstr, nstr + 1)) != 0)\n      return ASCII_NO_MEMORY;\n    if (usrang) {\n      if ((tmpylmu = (double*)calloc ((size_t) ((nstr + 1) * numu), sizeof (double))) == NULL)\n        return ASCII_NO_MEMORY;\n      if ((status = ASCII_calloc_double_3D (&ylmu, nstr, numu, nstr + 1)) != 0)\n        return ASCII_NO_MEMORY;\n    }\n    for (maz = 0; maz < nstr; maz++) {\n      twonm1 = nstr - 1;\n      nn     = 1;\n      if ((tmp = (double*)calloc ((size_t) (1), sizeof (double))) == NULL)\n        return ASCII_NO_MEMORY;\n      tmp[0] = -umu0;\n      c_legendre_poly (nn, maz, nstr, twonm1, tmp, tmpylm0);\n      free (tmp);\n      fortran2c_2D_double_ary_noalloc (nstr, nstr + 1, tmpylm0, ylm0[maz]);\n\n      nn = nstr / 2;\n      c_legendre_poly (nn, maz, nstr, twonm1, cmu, tmpylmc);\n      fortran2c_2D_double_ary_noalloc (nstr, nstr + 1, tmpylmc, ylmc[maz]);\n\n      /* Evaluate Legendre polynomials with negative -cmu- from those with*/\n      /* positive -cmu-;  Dave Armstrong Eq. (15) */\n      sgn = -1.0;\n      for (l = 0; l < nstr; l++) {\n        sgn = -sgn;\n        for (iq = nn; iq < nstr; iq++) {\n          ylmc[maz][iq][l] = sgn * ylmc[maz][nstr - 1 - iq][l];\n        }\n      }\n\n      if (usrang) {\n        if ((tmpumu = (double*)calloc ((size_t) (numu), sizeof (double))) == NULL) {\n          status = ASCII_NO_MEMORY;\n          fprintf (stderr,\n                   \"Unable to allocate memory for tmpumu, status: %d returned at (line %d, function %s in %s)\\n\",\n                   status,\n                   __LINE__,\n                   __func__,\n                   __FILE__);\n          return status;\n        }\n        for (iu = 0; iu < numu; iu++)\n          tmpumu[iu] = umu[iu];\n        c_legendre_poly (numu, maz, nstr, twonm1, tmpumu, tmpylmu);\n        fortran2c_2D_double_ary_noalloc (numu, nstr + 1, tmpylmu, ylmu[maz]);\n        free (tmpumu);\n      }\n    }\n    free (tmpylmc);\n    free (tmpylm0);\n    if (usrang) {\n      free (tmpylmu);\n    }\n\n    if ((trs = (double*)calloc ((size_t) (ntmp_zd), sizeof (double))) == NULL) {\n      status = ASCII_NO_MEMORY;\n      fprintf (stderr,\n               \"Unable to allocate memory for trs, status: %d returned at (line %d, function %s in %s)\\n\",\n               status,\n               __LINE__,\n               __func__,\n               __FILE__);\n      return status;\n    }\n\n    if ((status = ASCII_calloc_double (&trs_shifted, ntmp_zd, n_shifts)) != 0) {\n      fprintf (stderr,\n               \"Unable to allocate memory for trs_shifted, status: %d returned at (line %d, function %s in %s)\\n\",\n               status,\n               __LINE__,\n               __func__,\n               __FILE__);\n      return status;\n    }\n\n    if ((chtau = (double*)calloc ((size_t) (ntmp_zd), sizeof (double))) == NULL) {\n      status = ASCII_NO_MEMORY;\n      fprintf (stderr,\n               \"Unable to allocate memory for chtau, status: %d returned at (line %d, function %s in %s)\\n\",\n               status,\n               __LINE__,\n               __func__,\n               __FILE__);\n      return status;\n    }\n\n    if ((tmp_dtauc = (double*)calloc ((size_t) (ntmp_zd), sizeof (double))) == NULL) {\n      status = ASCII_NO_MEMORY;\n      fprintf (stderr,\n               \"Unable to allocate memory for tmp_dtauc, status: %d returned at (line %d, function %s in %s)\\n\",\n               status,\n               __LINE__,\n               __func__,\n               __FILE__);\n      return status;\n    }\n\n    if ((tmp_dens = (double*)calloc ((size_t) (ntmp_zd), sizeof (double))) == NULL) {\n      status = ASCII_NO_MEMORY;\n      fprintf (stderr,\n               \"Unable to allocate memory for tmp_dens, status: %d returned at (line %d, function %s in %s)\\n\",\n               status,\n               __LINE__,\n               __func__,\n               __FILE__);\n      return status;\n    }\n\n    if ((tmp_dens_org = (double*)calloc ((size_t) (nlev), sizeof (double))) == NULL) {\n      status = ASCII_NO_MEMORY;\n      fprintf (stderr,\n               \"Unable to allocate memory for tmp_dens_org, status: %d returned at (line %d, function %s in %s)\\n\",\n               status,\n               __LINE__,\n               __func__,\n               __FILE__);\n      return status;\n    }\n\n    if ((tmp_dtauc_shifted = (double*)calloc ((size_t) (ntmp_zd), sizeof (double))) == NULL) {\n      status = ASCII_NO_MEMORY;\n      fprintf (stderr,\n               \"Unable to allocate memory for tmp_dtauc_shifted, status: %d returned at (line %d, function %s in %s)\\n\",\n               status,\n               __LINE__,\n               __func__,\n               __FILE__);\n      return status;\n    }\n\n    if ((tmp_in = (double*)calloc ((size_t) (nzout), sizeof (double))) == NULL) {\n      status = ASCII_NO_MEMORY;\n      fprintf (stderr,\n               \"Unable to allocate memory for tmp_in, status: %d returned at (line %d, function %s in %s)\\n\",\n               status,\n               __LINE__,\n               __func__,\n               __FILE__);\n      return status;\n    }\n\n    if ((tmp_out = (double*)calloc ((size_t) (ntmp_zd), sizeof (double))) == NULL) {\n      status = ASCII_NO_MEMORY;\n      fprintf (stderr,\n               \"Unable to allocate memory for tmp_out, status: %d returned at (line %d, function %s in %s)\\n\",\n               status,\n               __LINE__,\n               __func__,\n               __FILE__);\n      return status;\n    }\n\n    if ((tmp_shifted = (double*)calloc ((size_t) (ntmp_zd), sizeof (double))) == NULL) {\n      status = ASCII_NO_MEMORY;\n      fprintf (stderr,\n               \"Unable to allocate memory for tmp_shifted, status: %d returned at (line %d, function %s in %s)\\n\",\n               status,\n               __LINE__,\n               __func__,\n               __FILE__);\n      return status;\n    }\n\n    if ((status = ASCII_calloc_double (&tmp_crs_RG, ntmp_zd, n_shifts)) != 0) {\n      fprintf (stderr, \"Error %d allocating memory for crs_RG \\n\", status);\n      fprintf (stderr, \"       (line %d, function '%s' in '%s')\\n\", __LINE__, __func__, __FILE__);\n      return status;\n    }\n\n    if ((status = ASCII_calloc_double (&tmp_crs_RL, ntmp_zd, n_shifts)) != 0) {\n      fprintf (stderr, \"Error %d allocating memory for crs_RG \\n\", status);\n      fprintf (stderr, \"       (line %d, function '%s' in '%s')\\n\", __LINE__, __func__, __FILE__);\n      return status;\n    }\n\n    if ((status = ASCII_calloc_double (&tmp_user_dtauc, ntmp_zd, n_shifts + 1)) != 0) {\n      fprintf (stderr,\n               \"Unable to allocate memory for user_dtauc, status: %d returned at (line %d, function %s in %s)\\n\",\n               status,\n               __LINE__,\n               __func__,\n               __FILE__);\n      return status;\n    }\n\n    first = 0;\n\n  } /* if ( first ) */\n\n  /* Find all unique altitudes */\n  ntmp_zd = nlev;\n  if ((tmp_zd = calloc (ntmp_zd, sizeof (double))) == NULL) {\n    fprintf (stderr, \"Error, allocating memory for tmp_zd\\n\");\n    fprintf (stderr, \"      (line %d, function %s in %s)  \\n\", __LINE__, __func__, __FILE__);\n    return -1;\n  }\n  if ((tmp_zd_org = calloc (nlyr + 1, sizeof (double))) == NULL) {\n    fprintf (stderr, \"Error, allocating memory for tmp_zd_org\\n\");\n    fprintf (stderr, \"      (line %d, function %s in %s)  \\n\", __LINE__, __func__, __FILE__);\n    return -1;\n  }\n  for (lc = 0; lc <= nlyr; lc++) {\n    tmp_zd_org[lc]   = (double)zd[lc];\n    tmp_dens_org[lc] = (double)dens[lc];\n  }\n\n  lv = 0;\n  for (lu = 0; lu < nlev - 1; lu++) {\n    if (zd[lu] >= 0.0)\n      tmp_zd[lv++] = (double)zd[lu];\n  }\n\n  if (zd[nlev] < 0.0)\n    tmp_zd[lv] = 0.0;\n  else\n    tmp_zd[lv] = (double)zd[nlev];\n\n    // aky20042012 removed this, made source zero at bottom level if altitude was set different from level.\n    // Probably a leftover from when source varied within layers and forgotten to clean up.....\n    //  if ( altitude != 0) {\n    //aky    ntmp_zd = lv;  /* Number of output levels may be reduced due to altitude option */\n    // }\n\n#if HAVE_SOS\n  /* Calculate geometric correction factor needed for chapman function */\n  if ((nfac = (int*)calloc ((size_t) (ntmp_zd - 1), sizeof (int))) == NULL)\n    return ASCII_NO_MEMORY;\n  if ((status = ASCII_calloc_double (&fac, ntmp_zd - 1, 2 * (ntmp_zd - 1))) != 0)\n    return status;\n\n  /* Share dtauc from zd layering to zout */\n  for (lu = 0; lu < ntmp_zd - 1; lu++)\n    tmp_dtauc[lu] = raman_qsrc_comp->dtauc[lu][n_shifts];\n\n  chtau[0] = 0;\n  for (lc = 1; lc <= ntmp_zd - 1; lc++)\n    chtau[lc] = c_chapman_simpler (lc, 0.5, ntmp_zd, tmp_zd, tmp_dtauc, zenang, radius);\n\n  /* Transmittance of the atmosphere at wanted wavelength */\n  trans_double (ntmp_zd - 1, chtau, trs);\n\n  for (is = 0; is < n_shifts; is++) {\n\n    for (lu = 0; lu < ntmp_zd - 1; lu++) {\n      tmp_dtauc_shifted[lu] = raman_qsrc_comp->dtauc[lu][is];\n    }\n\n    chtau[0] = 0;\n    for (lc = 1; lc <= ntmp_zd - 1; lc++)\n      chtau[lc] = c_chapman_simpler (lc, 0.5, ntmp_zd, tmp_zd, tmp_dtauc_shifted, zenang, radius);\n    trans_double (ntmp_zd - 1, chtau, tmp_shifted);\n    for (lu = 0; lu < ntmp_zd; lu++)\n      trs_shifted[lu][is] = tmp_shifted[lu];\n  }\n\n#else\n  fprintf (stderr, \"Error, need SOS source code for Raman scattering!\\n\");\n  return -1;\n#endif\n\n  /* Interpolate density and Raman cross sections from zd to zout grid */\n  status = arb_wvn_double (nlev, tmp_zd_org, tmp_dens_org, ntmp_zd, tmp_zd, tmp_dens, INTERP_METHOD_LOG, 1);\n\n  for (is = 0; is < n_shifts; is++) {\n    for (lu = 0; lu < nlev; lu++)\n      tmp_in[lu] = crs_RG[lu][is];\n    status = arb_wvn_double (nlev, tmp_zd_org, tmp_in, ntmp_zd, tmp_zd, tmp_out, INTERP_METHOD_LINEAR, 1);\n    for (lu = 0; lu < ntmp_zd; lu++)\n      tmp_crs_RG[lu][is] = tmp_out[lu];\n  }\n  for (is = 0; is < n_shifts; is++) {\n    for (lu = 0; lu < nlev; lu++)\n      tmp_in[lu] = crs_RL[lu][is];\n    status = arb_wvn_double (nlev, tmp_zd_org, tmp_in, ntmp_zd, tmp_zd, tmp_out, INTERP_METHOD_LINEAR, 1);\n    for (lu = 0; lu < ntmp_zd; lu++)\n      tmp_crs_RL[lu][is] = tmp_out[lu];\n  }\n\n  test = 0;\n  if (test) {\n    /*************************************************************/\n    /* To check that all angles etc. are correctly treated test  */\n    /* with the direct beam source. This should give identical   */\n    /* results for the diffuse radiation as the first raman      */\n    /* wavelength loop                                           */\n    /*************************************************************/\n\n    delm0 = 1;\n    fbeam = 1;\n    for (maz = 0; maz < nstr; maz++) {\n      if (maz > 0)\n        delm0 = 0;\n      for (lu = 0; lu < nzout - 1; lu++) {\n        lc = lu;\n        for (iq = 0; iq < nstr; iq++) {\n          sum = 0;\n          for (k = maz; k < nstr; k++) {\n            sum += (2 * k + 1) * ssalb[lc] * pmom[lc][0][k] * ylmc[maz][iq][k] * ylm0[maz][0][k];\n          }\n          qsrc[maz][lu][iq] = sum * (2 - delm0) * fbeam / (4 * M_PI);\n          if (lu == nzout) { /* Set source at bottom level */\n            qsrc[maz][lu + 1][iq] = qsrc[maz][lu][iq] * trs[lu + 1];\n          }\n          qsrc[maz][lu][iq] = qsrc[maz][lu][iq] * trs[lu];\n        }\n        if (usrang) {\n          for (iu = 0; iu < numu; iu++) {\n            sum = 0;\n            for (k = maz; k < nstr; k++) {\n              sum += (2 * k + 1) * ssalb[lc] * pmom[lc][0][k] * ylmu[maz][iu][k] * ylm0[maz][0][k];\n            }\n            qsrcu[maz][lu][iu] = sum * (2 - delm0) * fbeam / (4 * M_PI);\n            if (lu == nzout - 2) { /* Set source at bottom level */\n              qsrcu[maz][lu + 1][iu] = qsrcu[maz][lu][iu] * trs[lu + 1];\n            }\n            qsrcu[maz][lu][iu] = qsrcu[maz][lu][iu] * trs[lu];\n          }\n        }\n      }\n    }\n  } else { /* Raman scattering source */\n\n    if (verbose)\n      fprintf (stderr,\n               \"Raman_src %1s  %2s %2s    %2s     %3s        %4s          %4s          %4s          %4s          %4s  %9s %9s \"\n               \"%9s %9s )\\n\",\n               \"m\",\n               \"lu\",\n               \"iq\",\n               \"zd\",\n               \"cmu\",\n               \"sum1\",\n               \"sum2\",\n               \"sum3\",\n               \"sum4\",\n               \"qsrc\",\n               \"ssalbRL\",\n               \"ssalbRG\",\n               \"PI_R_b\",\n               \"PI_R_d\");\n\n    delm0 = 1;\n\n    /* dtauc is not necessarily at all user altitudes. So first interpolate to all user altitudes.... */\n    if ((tmp_cumtau = (double*)calloc ((size_t) (ntmp_zd), sizeof (double))) == NULL)\n      return ASCII_NO_MEMORY;\n    if ((tmp_cumtauint = (double*)calloc ((size_t) (ntmp_zd), sizeof (double))) == NULL)\n      return ASCII_NO_MEMORY;\n\n    for (is = 0; is <= n_shifts; is++) {\n\n      /* Start by calculating the cumulative optical depth. */\n      lu             = 0;\n      tmp_cumtau[lu] = 0.0;\n      for (lu = 1; lu < ntmp_zd; lu++)\n        tmp_cumtau[lu] = tmp_cumtau[lu - 1] + raman_qsrc_comp->dtauc[lu - 1][is];\n\n      /* Interpolate the cumulative optical depth to all user altitudes. */\n      status = arb_wvn_double (ntmp_zd, tmp_zd, tmp_cumtau, ntmp_zd, tmp_zd, tmp_cumtauint, INTERP_METHOD_LINEAR, 1);\n      /* Finally calculate the optical depth of each layer. */\n      lu                     = 0;\n      tmp_user_dtauc[lu][is] = 0.0;\n      for (lu = 1; lu < ntmp_zd; lu++)\n        tmp_user_dtauc[lu][is] = tmp_cumtauint[lu] - tmp_cumtauint[lu - 1];\n    }\n\n    free (tmp_cumtau);\n    free (tmp_cumtauint);\n\n    for (maz = 0; maz < nstr; maz++) {\n      if (maz > 0)\n        delm0 = 0;\n\n      for (lu = 1; lu < ntmp_zd; lu++) { /* No need to include first level as source is calculated at middle of layer */\n\n        lua = lu - 1;\n        lub = lu;\n\n        deltaz  = (tmp_zd[lua] - tmp_zd[lub]) * km2cm;\n        ssalbRL = 0;\n        //aky\ttmpsum=0.0;\n        for (is = 0; is < n_shifts; is++) {\n          //aky\t  ssalbRL += 0.5 * deltaz * (tmp_dens[lua]*tmp_crs_RL[lua][is] + tmp_dens[lub]*tmp_crs_RL[lub][is]) /\n          ssalbRL += deltaz * dlog_average (tmp_dens[lua] * tmp_crs_RL[lua][is], tmp_dens[lub] * tmp_crs_RL[lub][is]) /\n                     tmp_user_dtauc[lub][n_shifts];\n          //aky\t  tmpsum += dlog_average(tmp_crs_RL[lua][is], tmp_crs_RL[lub][is]);\n        }\n        verbose = 0;\n        if (verbose && maz == 0) {\n          crs_RL_tot = 0;\n          crs_RG_tot = 0;\n          for (is = 0; is < n_shifts; is++) {\n            crs_RL_tot += tmp_crs_RL[lu][is];\n            crs_RG_tot += tmp_crs_RG[lu][is];\n          }\n          fprintf (stderr, \"%3d, zout: %7.2f, crs_RL_tot: %13.6e, crs_RG_tot: %13.6e\\n\", lu, zout[lu], crs_RL_tot, crs_RG_tot);\n        }\n\n        for (iq = 0; iq < nstr; iq++) {\n          sum1 = 0;\n          sum2 = 0;\n          sum3 = 0;\n          sum4 = 0;\n\n          /* Calculate PI_R_b (Eq. 28) for Raman scattering */\n          if (maz == 0)\n            PI_R_b = ylmc[maz][iq][0] * ylm0[maz][0][0] + 5 * g2_R * ylmc[maz][iq][2] * ylm0[maz][0][2];\n          else if (maz == 1)\n            PI_R_b = -5 * g2_R * ylmc[maz][iq][2] * ylm0[maz][0][2];\n          else if (maz == 2)\n            PI_R_b = +5 * g2_R * ylmc[maz][iq][2] * ylm0[maz][0][2];\n          else\n            PI_R_b = 0;\n\n          /* First part of Raman scattering source term, Eq. (31). */\n\n          ssalbRG = 0;\n          for (is = 0; is < n_shifts; is++) {\n            lambda_fact = (wl_shifts[is] * wl_shifts[is]) / (wanted_wl * wanted_wl);\n            sum         = 0;\n            for (jq = 0; jq < nstr; jq++) {\n              /* Calculate  PI_R_d (Eq. 29) for Raman scattering */\n              if (maz == 0)\n                PI_R_d = ylmc[maz][iq][0] * ylmc[maz][jq][0] + 5 * g2_R * ylmc[maz][iq][2] * ylmc[maz][jq][2];\n              else if (maz == 1)\n                PI_R_d = +5 * g2_R * ylmc[maz][iq][2] * ylmc[maz][jq][2];\n              else if (maz == 2)\n                PI_R_d = +5 * g2_R * ylmc[maz][iq][2] * ylmc[maz][jq][2];\n              else\n                PI_R_d = 0;\n\n              sum += cwt[jq] * PI_R_d * raman_qsrc_comp->uum[zout_comp_index[lub]][maz][cmuind[jq]][is];\n            }\n            //aky\t    ssalbRG = 0.5 * deltaz * lambda_fact * (tmp_dens[lua] * tmp_crs_RG[lua][is] +\n            //aky\t\t\t\t      tmp_dens[lub] * tmp_crs_RG[lub][is]) /\n            ssalbRG = deltaz * lambda_fact *\n                      dlog_average (tmp_dens[lua] * tmp_crs_RG[lua][is], tmp_dens[lub] * tmp_crs_RG[lub][is]) /\n                      tmp_user_dtauc[lub][n_shifts];\n\n            sum1 += ssalbRG * sum;\n          }\n          sum1 *= +1. / 2.;\n\n          /* Second part of Raman scattering source term, Eq. (31). */\n\n          for (is = 0; is < n_shifts; is++) {\n            lambda_fact = (wl_shifts[is] * wl_shifts[is]) / (wanted_wl * wanted_wl);\n            //aky\t    ssalbRG = 0.5 * deltaz * (tmp_dens[lua] * tmp_crs_RG[lua][is] + tmp_dens[lub] *\n            //aky\t\t\t\t      tmp_crs_RG[lub][is]) / tmp_user_dtauc[lub][n_shifts];\n            ssalbRG = deltaz * dlog_average (tmp_dens[lua] * tmp_crs_RG[lua][is], tmp_dens[lub] * tmp_crs_RG[lub][is]) /\n                      tmp_user_dtauc[lub][n_shifts];\n\n            sum2 += raman_qsrc_comp->fbeam[is] * ssalbRG * trs_shifted[lub][is] * lambda_fact;\n          }\n          sum2 *= +((2 - delm0) / (4 * M_PI)) * PI_R_b;\n\n          /* Third part of Raman scattering source term, Eq. (31). */\n\n          sum = 0;\n          for (jq = 0; jq < nstr; jq++) {\n            /* Calculate  PI_R_d (Eq. 29) for Raman scattering */\n            if (maz == 0)\n              PI_R_d = ylmc[maz][iq][0] * ylmc[maz][jq][0] + 5 * g2_R * ylmc[maz][iq][2] * ylmc[maz][jq][2];\n            else if (maz == 1)\n              PI_R_d = +5 * g2_R * ylmc[maz][iq][2] * ylmc[maz][jq][2];\n            else if (maz == 2)\n              PI_R_d = +5 * g2_R * ylmc[maz][iq][2] * ylmc[maz][jq][2];\n            else\n              PI_R_d = 0;\n\n            sum += cwt[jq] * PI_R_d * raman_qsrc_comp->uum[zout_comp_index[lub]][maz][cmuind[jq]][n_shifts];\n          }\n\n          sum3 = -(ssalbRL / 2) * sum;\n\n          /* Fourth part of Raman scattering source term, Eq. (31). */\n\n          sum4 = -((ssalbRL * fbeam) / (4 * M_PI)) * (2 - delm0) * PI_R_b * trs[lub];\n\n          qsrc[maz][lu - 1][iq] = sum1 + sum2 + sum3 + sum4; /* lu starts at 1, source index is one less */\n\n          //aky\t  verbose = 0;\n          if (verbose) {\n            if (maz == 0 && iq == 0)\n              fprintf (stderr,\n                       \"Raman_src %2d %2d %2d %7.3f %7.3f %13.6e %13.6e %13.6e %13.6e %13.6e %13.6e %13.6e  %7.3f %7.3f %13.6e\\n\",\n                       maz,\n                       lu,\n                       iq,\n                       zout[lu],\n                       cmu[iq],\n                       sum1,\n                       sum2,\n                       sum3,\n                       sum4,\n                       qsrc[maz][lu - 1][iq],\n                       ssalbRL,\n                       ssalbRG,\n                       PI_R_b,\n                       PI_R_d,\n                       trs[lu]);\n          }\n\n        } /* for (iq=0;iq<nstr;iq++) */\n\n        if (usrang) {\n          /* Also have to calculate the source for all user angles */\n          for (iu = 0; iu < numu; iu++) {\n            sum1 = 0;\n            sum2 = 0;\n            sum3 = 0;\n            sum4 = 0;\n\n            /* Calculate PI_R_b (Eq. 28) for Raman scattering */\n            if (maz == 0)\n              PI_R_b = ylmu[maz][iu][0] * ylm0[maz][0][0] + 5 * g2_R * ylmu[maz][iu][2] * ylm0[maz][0][2];\n            else if (maz == 1)\n              PI_R_b = -5 * g2_R * ylmu[maz][iu][2] * ylm0[maz][0][2];\n            else if (maz == 2)\n              PI_R_b = +5 * g2_R * ylmu[maz][iu][2] * ylm0[maz][0][2];\n            else\n              PI_R_b = 0;\n\n            /* First part of Raman scattering source term, Eq. (31). */\n\n            ssalbRG = 0;\n            for (is = 0; is < n_shifts; is++) {\n              sum = 0;\n              for (jq = 0; jq < nstr; jq++) {\n                /* Calculate  PI_R_d (Eq. 29) for Raman scattering */\n                if (maz == 0)\n                  PI_R_d = ylmu[maz][iu][0] * ylmc[maz][jq][0] + 5 * g2_R * ylmu[maz][iu][2] * ylmc[maz][jq][2];\n                else if (maz == 1)\n                  PI_R_d = +5 * g2_R * ylmu[maz][iu][2] * ylmc[maz][jq][2];\n                else if (maz == 2)\n                  PI_R_d = +5 * g2_R * ylmu[maz][iu][2] * ylmc[maz][jq][2];\n                else\n                  PI_R_d = 0;\n\n                sum += cwt[jq] * PI_R_d * raman_qsrc_comp->uum[zout_comp_index[lub]][maz][cmuind[jq]][is];\n              }\n              //aky\t      ssalbRG = 0.5 * deltaz * (tmp_dens[lua] * tmp_crs_RG[lua][is] + tmp_dens[lub] *\n              //aky\t\t\t\t\ttmp_crs_RG[lub][is])/\n              ssalbRG = deltaz * dlog_average (tmp_dens[lua] * tmp_crs_RG[lua][is], tmp_dens[lub] * tmp_crs_RG[lub][is]) /\n                        tmp_user_dtauc[lub][n_shifts];\n\n              sum1 += ssalbRG * sum;\n            }\n            sum1 *= +1. / 2.;\n\n            /* Second part of Raman scattering source term, Eq. (31). */\n\n            for (is = 0; is < n_shifts; is++) {\n              //aky\t      ssalbRG = 0.5 * deltaz * (tmp_dens[lua] * tmp_crs_RG[lua][is] + tmp_dens[lub] *\n              //aky\t\t\t\t\ttmp_crs_RG[lub][is])/tmp_user_dtauc[lub][n_shifts];\n              ssalbRG = deltaz * dlog_average (tmp_dens[lua] * tmp_crs_RG[lua][is], tmp_dens[lub] * tmp_crs_RG[lub][is]) /\n                        tmp_user_dtauc[lub][n_shifts];\n\n              sum2 += raman_qsrc_comp->fbeam[is] * ssalbRG * trs_shifted[lub][is];\n            }\n            sum2 *= +((2 - delm0) / (4 * M_PI)) * PI_R_b;\n\n            /* Third part of Raman scattering source term, Eq. (31). */\n\n            sum = 0;\n            for (jq = 0; jq < nstr; jq++) {\n              /* Calculate  PI_R_d (Eq. 29) for Raman scattering */\n              if (maz == 0)\n                PI_R_d = ylmu[maz][iu][0] * ylmc[maz][jq][0] + 5 * g2_R * ylmu[maz][iu][2] * ylmc[maz][jq][2];\n              else if (maz == 1)\n                PI_R_d = +5 * g2_R * ylmu[maz][iu][2] * ylmc[maz][jq][2];\n              else if (maz == 2)\n                PI_R_d = +5 * g2_R * ylmu[maz][iu][2] * ylmc[maz][jq][2];\n              else\n                PI_R_d = 0;\n              sum += cwt[jq] * PI_R_d * raman_qsrc_comp->uum[zout_comp_index[lub]][maz][cmuind[jq]][n_shifts];\n            }\n            sum3 = -(ssalbRL / 2) * sum;\n\n            /* Fourth part of Raman scattering source term, Eq. (31). */\n\n            sum4 = -((ssalbRL * fbeam) / (4 * M_PI)) * (2 - delm0) * PI_R_b * trs[lub];\n\n            qsrcu[maz][lu - 1][iu] = sum1 + sum2 + sum3 + sum4; /* lu starts at 1, source index is one less */\n\n            verbose = 0;\n            if (verbose) {\n              if (maz == 0 && iu == 0)\n                fprintf (stderr,\n                         \"Raman_srcu %2d %2d %2d %7.3f %7.3f %13.6e %13.6e %13.6e %13.6e %13.6e  %13.6e %13.6e  %7.3f %7.3f\\n\",\n                         maz,\n                         lu,\n                         iu,\n                         zout[lu],\n                         umu[iu],\n                         sum1,\n                         sum2,\n                         sum3,\n                         sum4,\n                         qsrcu[maz][lu][iu],\n                         ssalbRL,\n                         ssalbRG,\n                         PI_R_b,\n                         PI_R_d);\n            }\n          } /* for (iq=0;iq<nstr;iq++) */\n        }   /* if ( usrang ) {  */\n      }     /* for (lu=0;lu<nzout;lu++) */\n    }\n  }\n\n  free (tmp_zd);\n  free (tmp_zd_org);\n  free (nfac);\n  if (last) {\n    free (cmu);\n    free (cwt);\n  }\n\n  return status;\n}\n\n#undef NRANSI\n", "meta": {"hexsha": "3ac24798c76aad46fd63ecafc6778e81aa3e6581", "size": 362032, "ext": "c", "lang": "C", "max_stars_repo_path": "ubuntu20/projects/libRadtran-2.0.4/src/solve_rte.c", "max_stars_repo_name": "AmberCrafter/docker-compose_libRadtran", "max_stars_repo_head_hexsha": "0182f991db6a13e0cacb3bf9f43809e6850593e4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "ubuntu20/projects/libRadtran-2.0.4/src/solve_rte.c", "max_issues_repo_name": "AmberCrafter/docker-compose_libRadtran", "max_issues_repo_head_hexsha": "0182f991db6a13e0cacb3bf9f43809e6850593e4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ubuntu20/projects/libRadtran-2.0.4/src/solve_rte.c", "max_forks_repo_name": "AmberCrafter/docker-compose_libRadtran", "max_forks_repo_head_hexsha": "0182f991db6a13e0cacb3bf9f43809e6850593e4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.1506578181, "max_line_length": 176, "alphanum_fraction": 0.4879458169, "num_tokens": 97920, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.41111086923216794, "lm_q2_score": 0.013636834279261852, "lm_q1q2_score": 0.005606250794122364}}
{"text": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <iniparser.h>\n#include \"parmt_utils.h\"\n#include \"tdsearch_greens.h\"\n#include \"tdsearch_commands.h\"\n#ifdef TDSEARCH_USE_INTEL\n#include <mkl_blas.h>\n#else\n#include <cblas.h>\n#endif\n#include \"tdsearch_struct.h\"\n#include \"tdsearch_hudson.h\"\n#include \"ispl/process.h\"\n#include \"iscl/array/array.h\"\n#include \"iscl/fft/fft.h\"\n#include \"iscl/memory/memory.h\"\n#include \"iscl/os/os.h\"\n\nstatic int getPrimaryArrival(const struct sacHeader_struct hdr,\n                             double *time, char phaseName[8]);\n\n/*!\n * @brief Reads the generic Green's functions pre-processing files from\n *        the ini file.\n *\n * @param[in] iniFile    Name of ini file.\n * @param[in] nobs       Number of observations.\n *\n * @param[in,out] grns   On input contains the number of observations.\n *                       On exit contains the generic Green's functions\n *                       processing commands for the observations.\n *\n * @result 0 indicates success.\n *\n * @author Ben Baker, ISTI\n *\n * @ingroup tdsearch_greens \n *\n * @bug Add an option to read a processing list file.\n *\n */\nint tdsearch_greens_setPreprocessingCommandsFromIniFile(\n    const char *iniFile,\n    const int nobs,  \n    struct tdSearchGreens_struct *grns)\n{\n    dictionary *ini;\n    char **cmds;\n    const char *s;\n    char varname[128];\n    size_t lenos;\n    int ierr, k, ncmds, ncmdsWork;\n    ierr = 0;\n    grns->nobs = nobs;\n    if (grns->nobs < 1){return 0;}\n    if (!os_path_isfile(iniFile))\n    {\n        fprintf(stderr, \"%s: Error ini file %s doesn't exist\\n\",\n                __func__, iniFile);\n        return -1;\n    }\n    ini = iniparser_load(iniFile);\n    ncmds = iniparser_getint(ini, \"tdSearch:greens:nCommands\\0\", 0);\n    grns->cmds = (struct tdSearchDataProcessingCommands_struct *)\n                 calloc((size_t) nobs, //ncmds,\n                        sizeof(struct tdSearchDataProcessingCommands_struct));\n    //if (!luseProcessingList)\n    {\n        if (ncmds > 0)\n        {\n            ncmdsWork = ncmds;\n            ncmds = 0;\n            cmds = (char **) calloc((size_t) ncmdsWork, sizeof(char *));\n            for (k=0; k<ncmdsWork; k++)\n            {\n                memset(varname, 0, 128*sizeof(char));\n                sprintf(varname, \"tdSearch:greens:command_%d\", k+1);\n                s = iniparser_getstring(ini, varname, NULL);\n                if (s == NULL){continue;}\n                lenos = strlen(s);\n                cmds[ncmds] = (char *) calloc(lenos+1, sizeof(char));\n                strcpy(cmds[ncmds], s);\n                //printf(\"%s\\n\", cmds[ncmds]);\n                ncmds = ncmds + 1;\n            }\n            // Attach these to the data processing structure\n            for (k=0; k<grns->nobs; k++)\n            {\n                ierr = tdsearch_greens_attachCommandsToGreens(\n                           k, ncmds, (const char **) cmds, grns);\n            }\n            // Free space\n            for (k=0; k<ncmdsWork; k++)\n            {\n                if (cmds[k] != NULL){free(cmds[k]);}\n            }\n            free(cmds);\n        }\n    }\n    iniparser_freedict(ini);\n    return ierr;\n}\n//============================================================================//\n/*!\n * @brief Attaches the Green's functions processing commands to the Green's\n *        structure.\n * \n * @param[in] iobs      Observation number to attach commands to.\n * @param[in] ncmds     Number of commands.\n * @param[in] cmds      Pre-processing commands for the Green's functions\n *                      corresponding to the iobs'th observation [ncmds].\n *\n * @param[in,out] grns  On input has the Green's functions (depths and t*'s)\n *                      corresponding to the observations.\n *                      On output contains the pre-processing commands\n *                      for Green's functions corresponding to the\n *                      observations.\n *\n * @result 0 indicates success.\n *\n * @ingroup tdsearch_greens\n *\n * @author Ben Baker, ISTI\n *\n */\nint tdsearch_greens_attachCommandsToGreens(const int iobs, const int ncmds,\n                                           const char **cmds,\n                                           struct tdSearchGreens_struct *grns)\n{\n    int i;\n    size_t lenos;\n    // Make sure iobs is in bounds \n    if (iobs < 0 || iobs >= grns->nobs)\n    {    \n        fprintf(stderr, \"%s: Error iobs=%d is out of bounds [0,%d]\\n\",\n                __func__, iobs, grns->nobs);\n        return -1;      \n    }        \n    // Try to handle space allocation if not already done\n    if (grns->cmds == NULL && grns->nobs > 0)\n    {    \n        grns->cmds = (struct tdSearchDataProcessingCommands_struct *)\n                     calloc((size_t) grns->nobs,\n                        sizeof(struct tdSearchDataProcessingCommands_struct));\n    }    \n    if (grns->cmds == NULL)\n    {    \n        fprintf(stderr, \"%s: Error grns->cmds is NULL\\n\", __func__);\n        return -1;\n    }\n    if (ncmds == 0){return 0;}\n    grns->cmds[iobs].ncmds = ncmds;\n    grns->cmds[iobs].cmds = (char **) calloc((size_t) ncmds, sizeof(char *));\n    if (cmds == NULL){printf(\"problem 1\\n\");}\n    for (i=0; i<ncmds; i++)\n    {\n        if (cmds[i] == NULL){printf(\"problem 2\\n\");}\n        lenos = strlen(cmds[i]);\n        grns->cmds[iobs].cmds[i] = (char *) calloc(lenos+1, sizeof(char));\n        strcpy(grns->cmds[iobs].cmds[i], cmds[i]);\n    }\n    return 0;\n}\n//============================================================================//\n/*!\n * @brief Convenience function which returns the index of the Green's\n *        function on the Green's function structure.\n *\n * @param[in] GMT_TERM    Name of the desired Green's function:\n *                        (G11_TERM, G22_TERM, ..., G23_TERM).\n * @param[in] iobs        Desired observation number (C numbering).\n * @param[in] itstar      Desired t* (C numbering).\n * @param[in] idepth      Desired depth (C numbering).\n * @param[in] grns        Contains the number of observations, depths, and t*'s\n *                        on the Green's functions structure.\n *\n * @result Negative indicates failure.  Otherwise, this is the index in \n *         grns.grns corresponding to the desired \n *         (iobs, idepth, itstar, G??_GRNS) coordinate.\n *\n * @ingroup tdsearch_greens\n *\n * @author Ben Baker, ISTI\n *\n */\nint tdsearch_greens_getGreensFunctionIndex(\n    const enum prepmtGreens_enum GMT_TERM,\n    const int iobs, const int itstar, const int idepth,\n    const struct tdSearchGreens_struct grns)\n{\n    int igx, indx;\n    indx =-1;\n    igx = (int) GMT_TERM - 1;\n    if (igx < 0 || igx > 5)\n    {\n        fprintf(stderr, \"%s: Can't classify Green's functions index\\n\",\n                __func__);\n        return indx;\n    }\n    indx = iobs*(6*grns.ntstar*grns.ndepth)\n         + idepth*(6*grns.ntstar)\n         + itstar*6\n         + igx;\n    if (indx >= grns.ngrns)\n    {\n        fprintf(stdout, \"%s: indx out of bounds - segfault is coming\\n\",\n                __func__);\n        return -1;\n    }\n    return indx;\n}\n//============================================================================//\n/*!\n * @brief Convenience function for extracting the: \n *        \\$ \\{ G_{xx}, G_{yy}, G_{zz}, G_{xy}, G_{xz}, G_{yz} \\} \\$\n *        Green's functions indices for the observation, t*, and depth.\n *\n * @param[in] iobs      Observation number.\n * @param[in] itstar    t* index.  This is C numbered.\n * @param[in] idepth    Depth index.  This is C numbered.\n * @param[in] grns      Contains the Green's functions.\n * @param[out] indices  Contains the Green's functions indices defining\n *                      the indices that return the:\n *                       \\$ \\{ G_{xx}, G_{yy}, G_{zz}, \n *                             G_{xy}, G_{xz}, G_{yz} \\} \\$\n *                      for this observation, t*, and depth. \n *\n * @result 0 indicates success.\n *\n * @ingroup tdsearch_greens\n *\n * @author Ben Baker, ISTI\n *\n */\nint tdsearch_greens_getGreensFunctionsIndices(\n    const int iobs, const int itstar, const int idepth,\n    const struct tdSearchGreens_struct grns, int indices[6])\n{\n    int i, ierr;\n    const enum prepmtGreens_enum mtTerm[6] = \n       {G11_GRNS, G22_GRNS, G33_GRNS, G12_GRNS, G13_GRNS, G23_GRNS};\n    ierr = 0;\n    for (i=0; i<6; i++)\n    {\n        indices[i] = tdsearch_greens_getGreensFunctionIndex(mtTerm[i],\n                                                          iobs, itstar, idepth,\n                                                          grns); \n        if (indices[i] < 0){ierr = ierr + 1;}\n    } \n    return ierr;\n}\n//============================================================================//\n/*!\n * @brief Releases memory on the Greens functions structure.\n *\n * @param[out] grns   On exit all memory has been freed and variables set to\n *                    0 or NULL.\n *\n * @result 0 indicates success.\n *\n * @ingroup tdsearch_greens\n *\n * @author Ben Baker, ISTI\n *\n */\nint tdsearch_greens_free(struct tdSearchGreens_struct *grns)\n{\n    int i, k;\n    if (grns->grns != NULL && grns->ngrns > 0)\n    {\n        for (k=0; k<grns->ngrns; k++)\n        {\n            sacio_free(&grns->grns[k]);\n        }\n        free(grns->grns);\n    }\n    if (grns->cmds != NULL)\n    {\n        for (k=0; k<grns->nobs; k++)\n        {\n            if (grns->cmds[k].cmds != NULL)\n            {\n                for (i=0; i<grns->cmds[k].ncmds; i++)\n                {\n                    if (grns->cmds[k].cmds[i] != NULL)\n                    {\n                        free(grns->cmds[k].cmds[i]);\n                        grns->cmds[k].cmds[i] = NULL;\n                    }\n                }\n                free(grns->cmds[k].cmds);\n                grns->cmds[k].cmds = NULL;\n            }\n        }\n        free(grns->cmds);\n        grns->cmds = NULL;\n    }\n    if (grns->cmdsGrns != NULL)\n    {\n        for (k=0; k<grns->ngrns; k++)\n        {\n            if (grns->cmdsGrns[k].cmds != NULL)\n            {\n                for (i=0; i<grns->cmdsGrns[k].ncmds; i++)\n                {\n                    if (grns->cmdsGrns[k].cmds != NULL)\n                    {\n                        free(grns->cmdsGrns[k].cmds[i]);\n                        grns->cmdsGrns[k].cmds[i] = NULL;\n                    }\n                }\n                free(grns->cmdsGrns[k].cmds);\n                grns->cmdsGrns[k].cmds = NULL;\n             }\n        } \n        free(grns->cmdsGrns);\n        grns->cmdsGrns = NULL;\n    }\n    memset(grns, 0, sizeof(struct tdSearchGreens_struct));\n    return 0;\n}\n//============================================================================//\n/*!\n * @brief Converts the fundamental faults Green's functions to Green's\n *        functions that can be used by tdsearch.\n *\n * @param[in] data    tdSearch data structure.\n * @param[in] ffGrns  fundamental fault Green's functions for every t* and\n *                    depth in the grid search for each observation. \n *\n * @param[out] grns   Contains the Green's functions that can be applied to\n *                    a moment tensor to produce a synthetic for every t*\n *                    and depth in the grid search for each observation.\n *\n * @result 0 indicates success.\n *\n * @ingroup tdsearch_greens\n *\n * @author Ben Baker, ISTI\n *\n */\nint tdsearch_greens_ffGreensToGreens(const struct tdSearchData_struct data,\n                                     const struct tdSearchHudson_struct ffGrns,\n                                     struct tdSearchGreens_struct *grns)\n{\n    char knetwk[8], kstnm[8], kcmpnm[8], khole[8], phaseName[8],\n         phaseNameGrns[8];\n    double az, baz, cmpaz, cmpinc, cmpincSEED, dt0, epoch, epochNew,\n           evla, evlo, o, pick, pickTime, pickTimeGrns, stel, stla, stlo;\n    int i, icomp, id, ierr, idx, indx, iobs, it, kndx, l, npts;\n    const char *kcmpnms[6] = {\"GXX\\0\", \"GYY\\0\", \"GZZ\\0\",\n                              \"GXY\\0\", \"GXZ\\0\", \"GYZ\\0\"};\n    const double xmom = 1.0;     // no confusing `relative' magnitudes \n    const double xcps = 1.e-20;  // convert dyne-cm mt to output cm\n    const double cm2m = 1.e-2;   // cm to meters\n    const double dcm2nm = 1.e+7; // magnitudes intended to be specified in\n                                 // Dyne-cm but I work in N-m\n    // Given a M0 in Newton-meters get a seismogram in meters\n    const double xscal = xmom*xcps*cm2m*dcm2nm;\n    const int nTimeVars = 11; \n    const enum sacHeader_enum pickVars[11]\n       = {SAC_FLOAT_A,\n          SAC_FLOAT_T0, SAC_FLOAT_T1, SAC_FLOAT_T2, SAC_FLOAT_T3,\n          SAC_FLOAT_T4, SAC_FLOAT_T5, SAC_FLOAT_T6, SAC_FLOAT_T7,\n          SAC_FLOAT_T8, SAC_FLOAT_T9};\n    //memset(grns, 0, sizeof(struct tdSearchGreens_struct));\n    grns->ntstar = ffGrns.ntstar;\n    grns->ndepth = ffGrns.ndepth;\n    grns->nobs = data.nobs;\n    grns->ngrns = 6*grns->ntstar*grns->ndepth*grns->nobs;\n    if (grns->ngrns < 1)\n    {\n        fprintf(stderr, \"%s: Error grns is empty\\n\", __func__);\n        return -1;\n    }\n    grns->grns = (struct sacData_struct *)\n                 calloc((size_t) grns->ngrns, sizeof(struct sacData_struct));\n    for (iobs=0; iobs<data.nobs; iobs++)\n    {\n        ierr = 0;\n        ierr += sacio_getFloatHeader(SAC_FLOAT_AZ,\n                                     data.obs[iobs].header, &az);\n        ierr += sacio_getFloatHeader(SAC_FLOAT_BAZ,\n                                     data.obs[iobs].header, &baz);\n        ierr += sacio_getFloatHeader(SAC_FLOAT_CMPINC,\n                                     data.obs[iobs].header, &cmpinc);\n        ierr += sacio_getFloatHeader(SAC_FLOAT_CMPAZ,\n                                     data.obs[iobs].header, &cmpaz);\n        ierr += sacio_getFloatHeader(SAC_FLOAT_EVLA,\n                                     data.obs[iobs].header, &evla);\n        ierr += sacio_getFloatHeader(SAC_FLOAT_EVLO,\n                                     data.obs[iobs].header, &evlo);\n        ierr += sacio_getFloatHeader(SAC_FLOAT_STLA,\n                                     data.obs[iobs].header, &stla);\n        ierr += sacio_getFloatHeader(SAC_FLOAT_STLO,\n                                     data.obs[iobs].header, &stlo);\n        ierr += sacio_getFloatHeader(SAC_FLOAT_DELTA,\n                                     data.obs[iobs].header, &dt0);\n        ierr += sacio_getCharacterHeader(SAC_CHAR_KNETWK,\n                                         data.obs[iobs].header, knetwk);\n        ierr += sacio_getCharacterHeader(SAC_CHAR_KSTNM,\n                                         data.obs[iobs].header, kstnm);\n        ierr += sacio_getCharacterHeader(SAC_CHAR_KCMPNM,\n                                         data.obs[iobs].header, kcmpnm);\n        // this one isn't critical\n        sacio_getFloatHeader(SAC_FLOAT_STEL,\n                             data.obs[iobs].header, &stel);\n        if (ierr != 0)\n        {\n            fprintf(stderr, \"%s: Error reading header variables\\n\", __func__);\n            break;\n        }\n        // Station location code is not terribly important\n        sacio_getCharacterHeader(SAC_CHAR_KHOLE, data.obs[iobs].header, khole);\n        cmpincSEED = cmpinc - 90.0; // SAC to SEED convention\n        // Get the primary arrival\n        ierr = sacio_getEpochalStartTime(data.obs[iobs].header, &epoch);\n        if (ierr != 0)\n        {\n            fprintf(stderr, \"%s: Error getting start time\\n\", __func__);\n            break;\n        }\n        ierr += getPrimaryArrival(data.obs[iobs].header, &pickTime, phaseName);\n        if (ierr != 0)\n        {\n            fprintf(stderr, \"%s: Error getting primary pick\\n\", __func__);\n            break;\n        }\n        // Need to figure out the component\n        icomp = 1;\n        if (kcmpnm[2] == 'Z' || kcmpnm[2] == 'z' || kcmpnm[2] == '1')\n        {\n            icomp = 1;\n        }\n        else if (kcmpnm[2] == 'N' || kcmpnm[2] == 'n' || kcmpnm[2] == '2')\n        {\n            icomp = 2;\n        }\n        else if (kcmpnm[2] == 'E' || kcmpnm[2] == 'e' || kcmpnm[2] == '3')\n        {\n            icomp = 3;\n        }\n        else\n        {\n            fprintf(stderr, \"%s: Can't classify component: %s\\n\",\n                    __func__, kcmpnm);\n        }\n        // Process all Green's functions in this block\n        for (id=0; id<ffGrns.ndepth; id++)\n        {\n            for (it=0; it<ffGrns.ntstar; it++)\n            {\n                idx = tdsearch_hudson_observationDepthTstarToIndex(iobs, id, it,\n                                                                   ffGrns);\n                kndx = 10*idx;\n                sacio_getFloatHeader(SAC_FLOAT_O, ffGrns.grns[kndx].header, &o);\n                getPrimaryArrival(ffGrns.grns[kndx].header,\n                                  &pickTimeGrns, phaseNameGrns);\n                if (strcasecmp(phaseNameGrns, phaseName) != 0)\n                {\n                    fprintf(stdout, \"%s: Phase name mismatch %s %s\\n\",\n                            __func__, phaseName, phaseNameGrns);\n                }\n                npts = ffGrns.grns[kndx].npts;\n                indx = tdsearch_greens_getGreensFunctionIndex(G11_GRNS,\n                                                              iobs, it, id,\n                                                              *grns);\n                for (i=0; i<6; i++)\n                {\n                    sacio_copy(ffGrns.grns[kndx], &grns->grns[indx+i]);\n                    if (data.obs[iobs].pz.lhavePZ)\n                    {\n                        sacio_copyPolesAndZeros(data.obs[iobs].pz,\n                                                &grns->grns[indx+i].pz);\n                    }\n                    sacio_setFloatHeader(SAC_FLOAT_AZ, az,\n                                         &grns->grns[indx+i].header);\n                    sacio_setFloatHeader(SAC_FLOAT_BAZ, baz,\n                                         &grns->grns[indx+i].header);\n                    sacio_setFloatHeader(SAC_FLOAT_CMPAZ, cmpaz,\n                                         &grns->grns[indx+i].header);\n                    sacio_setFloatHeader(SAC_FLOAT_CMPINC, cmpinc,\n                                         &grns->grns[indx+i].header);\n                    sacio_setFloatHeader(SAC_FLOAT_EVLA, evla,\n                                         &grns->grns[indx+i].header);\n                    sacio_setFloatHeader(SAC_FLOAT_EVLO, evlo,\n                                         &grns->grns[indx+i].header);\n                    sacio_setFloatHeader(SAC_FLOAT_STLA, stla,\n                                         &grns->grns[indx+i].header);\n                    sacio_setFloatHeader(SAC_FLOAT_STLO, stlo,\n                                         &grns->grns[indx+i].header);\n                    sacio_setFloatHeader(SAC_FLOAT_STEL, stel,\n                                         &grns->grns[indx+i].header); \n                    sacio_setCharacterHeader(SAC_CHAR_KNETWK, knetwk,\n                                             &grns->grns[indx+i].header);\n                    sacio_setCharacterHeader(SAC_CHAR_KSTNM, kstnm,\n                                             &grns->grns[indx+i].header);\n                    sacio_setCharacterHeader(SAC_CHAR_KHOLE, khole,\n                                             &grns->grns[indx+i].header);\n                    sacio_setCharacterHeader(SAC_CHAR_KCMPNM, kcmpnms[i],\n                                             &grns->grns[indx+i].header);\n                    sacio_setCharacterHeader(SAC_CHAR_KEVNM, \"SYNTHETIC\\0\",\n                                             &grns->grns[indx+i].header);\n                    // Set the start time by aligning on the arrival\n                    epochNew = epoch + (pickTime - o) - pickTimeGrns;\n                    sacio_setEpochalStartTime(epochNew,\n                                              &grns->grns[indx+i].header);\n                    // Update the pick times\n                    for (l=0; l<11; l++)\n                    {\n                        ierr = sacio_getFloatHeader(pickVars[l],\n                                                    grns->grns[indx+i].header,\n                                                    &pick);\n                        if (ierr == 0)\n                        {\n                            pick = pick + o;\n                            sacio_setFloatHeader(pickVars[l],\n                                                 pick,\n                                                 &grns->grns[indx+i].header);\n                        }\n                    } \n                }\n                ierr = parmt_utils_ff2mtGreens64f(npts, icomp,\n                                                  az, baz,\n                                                  cmpaz, cmpincSEED,\n                                                  ffGrns.grns[kndx+0].data,\n                                                  ffGrns.grns[kndx+1].data,\n                                                  ffGrns.grns[kndx+2].data,\n                                                  ffGrns.grns[kndx+3].data,\n                                                  ffGrns.grns[kndx+4].data,\n                                                  ffGrns.grns[kndx+5].data,\n                                                  ffGrns.grns[kndx+6].data,\n                                                  ffGrns.grns[kndx+7].data,\n                                                  ffGrns.grns[kndx+8].data,\n                                                  ffGrns.grns[kndx+9].data,\n                                                  grns->grns[indx+0].data,\n                                                  grns->grns[indx+1].data,\n                                                  grns->grns[indx+2].data,\n                                                  grns->grns[indx+3].data,\n                                                  grns->grns[indx+4].data,\n                                                  grns->grns[indx+5].data);\n                if (ierr != 0)\n                {\n                    fprintf(stderr, \"%s: Failed to rotate Greens functions\\n\",\n                            __func__);\n                }\n                // Fix the characteristic magnitude scaling in CPS \n                for (i=0; i<6; i++)\n                {\n                    cblas_dscal(npts, xscal, grns->grns[indx+i].data, 1); \n                }\n            }\n        }\n    }\n    return 0;\n}\n//============================================================================//\n/*!\n * @brief Repicks the Green's functions onset time with an STA/LTA picker.\n *\n * @param[in] sta        Short term average window length (seconds).\n * @param[in] lta        Long term average window length (seconds).\n * @param[in] threshPct  Percentage of max STA/LTA after which an arrival\n *                       is declared.\n * @param[in] iobs       C numbered observation index.\n * @param[in] itstar     C numbered t* index.\n * @param[in] idepth     C numbered depth index.\n *\n * @param[in,out] grns   On input contains the Green's functions.\n *                       On output the first arrival time has been modified\n *                       with an STA/LTA picker.\n *\n * @brief 0 indicates success.\n *\n * @ingroup tdsearch_greens\n *\n * @author Ben Baker, ISTI\n *\n */\nint tdsearch_greens_repickGreensWithSTALTA(\n    const double sta, const double lta, const double threshPct,\n    const int iobs, const int itstar, const int idepth,\n    struct tdSearchGreens_struct *grns)\n{\n    struct stalta_struct stalta;\n    double *charFn, *g, *Gxx, *Gyy, *Gzz, *Gxy, *Gxz, *Gyz,\n           *gxxPad, *gyyPad, *gzzPad, *gxyPad, *gxzPad, *gyzPad,\n           charMax, dt, tpick;\n    int indices[6], ierr, k, npts, nlta, npad, nsta, nwork, prePad;\n    // Check STA/LTA \n    ierr = 0;\n    memset(&stalta, 0, sizeof(struct stalta_struct));\n    if (lta < sta || sta < 0.0)\n    {\n        if (lta < sta){fprintf(stderr,\"%s: Error lta < sta\\n\", __func__);}\n        if (sta < 0.0){fprintf(stderr,\"%s: Error sta is negative\\n\", __func__);}\n        return -1;\n    }\n    ierr = tdsearch_greens_getGreensFunctionsIndices(iobs, itstar, idepth,\n                                                     *grns, indices);\n    if (ierr != 0)\n    {\n        fprintf(stderr, \"%s: Failed to get Greens functions indicies\\n\",\n                 __func__);\n        return -1;\n    }\n    ierr = sacio_getIntegerHeader(SAC_INT_NPTS,\n                                  grns->grns[indices[0]].header, &npts);\n    if (ierr != 0 || npts < 1)\n    {\n        if (ierr != 0)\n        {\n            fprintf(stderr, \"%s: Error getting number of points from header\\n\",\n                    __func__);\n        }\n        else\n        {\n            fprintf(stderr, \"%s: ERror no data points\\n\", __func__);\n        }\n        return -1;\n    }\n    ierr = sacio_getFloatHeader(SAC_FLOAT_DELTA,\n                                grns->grns[indices[0]].header, &dt);\n    if (ierr != 0 || dt <= 0.0)\n    {\n        if (ierr != 0){fprintf(stderr, \"%s: failed to get dt\\n\", __func__);}\n        if (dt <= 0.0){fprintf(stderr, \"%s: invalid sampling period\\n\", __func__);}\n        return -1;\n    }\n    // Define the windows\n    nsta = (int) (sta/dt + 0.5);\n    nlta = (int) (lta/dt + 0.5);\n    prePad = MAX(64, fft_nextpow2(nlta, &ierr));\n    npad = prePad + npts;\n    // Set space\n    gxxPad = memory_calloc64f(npad);\n    gyyPad = memory_calloc64f(npad);\n    gzzPad = memory_calloc64f(npad);\n    gxyPad = memory_calloc64f(npad);\n    gxzPad = memory_calloc64f(npad);\n    gyzPad = memory_calloc64f(npad);\n    charFn = memory_calloc64f(npad);\n    // Reference pointers\n    Gxx = grns->grns[indices[0]].data;\n    Gyy = grns->grns[indices[1]].data;\n    Gzz = grns->grns[indices[2]].data;\n    Gxy = grns->grns[indices[3]].data;\n    Gxz = grns->grns[indices[4]].data;\n    Gyz = grns->grns[indices[5]].data;\n    // Pre-pad signals\n    array_set64f_work(prePad, Gxx[0], gxxPad);\n    array_set64f_work(prePad, Gyy[0], gyyPad);\n    array_set64f_work(prePad, Gzz[0], gzzPad); \n    array_set64f_work(prePad, Gxy[0], gxyPad);\n    array_set64f_work(prePad, Gxz[0], gxzPad);\n    array_set64f_work(prePad, Gyz[0], gyzPad);\n    // Copy rest of array\n    array_copy64f_work(npts, Gxx, &gxxPad[prePad]);\n    array_copy64f_work(npts, Gyy, &gyyPad[prePad]);\n    array_copy64f_work(npts, Gzz, &gzzPad[prePad]);\n    array_copy64f_work(npts, Gxy, &gxyPad[prePad]);\n    array_copy64f_work(npts, Gxz, &gxzPad[prePad]);\n    array_copy64f_work(npts, Gyz, &gyzPad[prePad]);\n    // apply the sta/lta\n    for (k=0; k<6; k++)\n    {\n        g = NULL;\n        if (k == 0)\n        {\n            g = gxxPad;\n        }\n        else if (k == 1)\n        {\n            g = gyyPad;\n        }\n        else if (k == 2)\n        {\n            g = gzzPad;\n        }\n        else if (k == 3)\n        {\n            g = gxyPad;\n        }\n        else if (k == 4)\n        {\n            g = gxzPad;\n        }\n        else if (k == 5)\n        {\n            g = gyzPad;\n        }\n        ierr = stalta_setShortAndLongTermAverage(nsta, nlta, &stalta);\n        if (ierr != 0)\n        {\n            printf(\"%s: Error setting STA/LTA\\n\", __func__);\n            break;\n        }\n        ierr = stalta_setData64f(npad, g, &stalta);\n        if (ierr != 0)\n        {\n            printf(\"%s: Error setting data\\n\", __func__);\n            break;\n        }\n        ierr = stalta_applySTALTA(&stalta);\n        if (ierr != 0)\n        {\n            printf(\"%s: Error applying STA/LTA\\n\", __func__);\n            break;\n        }\n        ierr = stalta_getData64f(stalta, npad, &nwork, g);\n        if (ierr != 0)\n        {\n            printf(\"%s: Error getting result\\n\", __func__);\n            break;\n        }\n        cblas_daxpy(npad, 1.0, g, 1, charFn, 1);\n        stalta_resetInitialConditions(&stalta);\n        stalta_resetFinalConditions(&stalta);\n        g = NULL;\n    }\n    // Compute the pick time\n    charMax = array_max64f(npts, &charFn[prePad], &ierr);\n    tpick =-1.0;\n    for (k=prePad; k<npad; k++)\n    {\n        if (charFn[k] > 0.01*threshPct*charMax)\n        {\n            tpick = (double) (k - prePad)*dt;\n            break;\n        }\n    }\n    if (tpick ==-1.0)\n    {\n        tpick = (double) (array_argmax64f(npad, charFn, &ierr) - prePad)*dt;\n    }\n    // Overwrite the pick; by this point should be on SAC_FLOAT_A\n    //double apick;\n    //sacio_getFloatHeader(SAC_FLOAT_A, grns->grns[indices[0]].header, &apick);\n    for (k=0; k<6; k++)\n    {\n        sacio_setFloatHeader(SAC_FLOAT_A, tpick,\n                             &grns->grns[indices[k]].header);\n    }\n    // Dereference pointers and free space\n    Gxx = NULL;\n    Gyy = NULL;\n    Gzz = NULL;\n    Gxy = NULL;\n    Gxz = NULL;\n    Gyz = NULL;\n    memory_free64f(&gxxPad);\n    memory_free64f(&gyyPad);\n    memory_free64f(&gzzPad);\n    memory_free64f(&gxyPad);\n    memory_free64f(&gxzPad);\n    memory_free64f(&gyzPad);\n    memory_free64f(&charFn);\n    stalta_free(&stalta);\n    return ierr;\n}\n//============================================================================//\n/*!\n * @brief Modifies the Green's functions processing commands.\n *\n * @param[in] iodva     The output units for the hudson96 Green's functions.\n * @param[in] iodva     0 indicates the Green's functions have units\n *                      of displacement.\n * @param[in] iodva     1 indicates the Green's functions have units\n *                      of velocity.\n * @param[in] iodva     2 indicates the Green's functions have units\n *                      of acceleration.\n * @param[in] cut0      The cut time in seconds relative to the pick time\n *                      to begin the window around the arrival.\n * @parma[in] cut1      The cut time in seconds relative to the pick time\n *                      to end the window around the arrival.\n * @param[in] targetDt  Desired sampling period in seconds to which the Green's\n *                      functions should be resampled as to match the data.\n *\n * @param[in,out] grns  On input input contains the genreci Green's functions\n *                      processing commands. \n * @param[in,out] grns  On exit the Green's functions processing have been\n *                      made specific to the input Green's functions.\n *\n * @result 0 indicates success.\n *\n * @ingroup tdsearch_greens\n *\n */\nint tdsearch_greens_modifyProcessingCommands(\n    const int iodva,\n    const double cut0, const double cut1, const double targetDt,\n    struct tdSearchGreens_struct *grns)\n{\n    struct tdSearchModifyCommands_struct options;\n    const char **cmds;\n    char **newCmds;\n    size_t lenos;\n    int i, ierr, iobs, k, kndx1, kndx2, ncmds;\n    ierr = 0;\n    grns->cmdsGrns = (struct tdSearchDataProcessingCommands_struct *)\n                     calloc((size_t) grns->ngrns,\n                        sizeof(struct tdSearchDataProcessingCommands_struct));\n    for (iobs=0; iobs<grns->nobs; iobs++)\n    {\n        newCmds = NULL;\n        ncmds =  grns->cmds[iobs].ncmds;\n        if (ncmds < 1){continue;} // Nothing to do\n        cmds = (const char **) grns->cmds[iobs].cmds;\n        options.cut0 = cut0;\n        options.cut1 = cut1;\n        options.targetDt = targetDt;\n        options.ldeconvolution = false;\n        options.iodva = iodva;\n        kndx1 = iobs*(6*grns->ntstar*grns->ndepth);\n        kndx2 = (iobs+1)*(6*grns->ntstar*grns->ndepth);\n        newCmds = tdsearch_commands_modifyCommands(ncmds, (const char **) cmds,\n                                                   options,\n                                                   grns->grns[kndx1], &ierr);\n        if (ierr != 0)\n        {\n            fprintf(stderr, \"%s: Failed to set processing commands\\n\", __func__);\n            goto ERROR;\n        }\n        // Expand the processing commands \n        for (k=kndx1; k<kndx2; k++)\n        {\n            grns->cmdsGrns[k].ncmds = ncmds;\n            grns->cmdsGrns[k].cmds = (char **)\n                                     calloc((size_t) ncmds, sizeof(char *));\n            for (i=0; i<ncmds; i++)\n            {\n                lenos = strlen(newCmds[i]);\n                grns->cmdsGrns[k].cmds[i] = (char *)\n                                            calloc(lenos+1, sizeof(char));\n                strcpy(grns->cmdsGrns[k].cmds[i], newCmds[i]);\n            }\n        } \n        // Release the memory\n        if (newCmds != NULL)\n        {\n            for (i=0; i<ncmds; i++)\n            {\n                if (newCmds[i] != NULL){free(newCmds[i]);}\n            }\n            free(newCmds);\n        }\n    }\nERROR:;\n    return ierr;\n}\n//============================================================================//\n/*!\n * @brief Processes the Green's functions.\n *\n * @param[in,out] grns    On input contains the Green's functions for all\n *                        observations, depths, and t*'s as well as the\n *                        processing chains.\n *                        On output contains the filtered Green's functions\n *                        for all observations, depths, and t*'s.\n *\n * @result 0 indicates success.\n *\n * @ingroup tdsearch_greens\n *\n * @author Ben Baker, ISTI\n *\n */\nint tdsearch_greens_process(struct tdSearchGreens_struct *grns)\n{\n    double *data;\n    struct serialCommands_struct commands;\n    struct parallelCommands_struct parallelCommands;\n    double dt, dt0, epoch, epoch0, time;\n    int dataPtr[7], i, i0, ierr, iobs, idep, it, kndx, l, npts, npts0, nq,\n        nwork, ny, ns;\n    bool lnewDt, lnewStartTime;\n    const int nsignals = 6;\n    const int nTimeVars = 12;\n    const enum sacHeader_enum timeVars[12]\n       = {SAC_FLOAT_A, SAC_FLOAT_O, \n          SAC_FLOAT_T0, SAC_FLOAT_T1, SAC_FLOAT_T2, SAC_FLOAT_T3,\n          SAC_FLOAT_T4, SAC_FLOAT_T5, SAC_FLOAT_T6, SAC_FLOAT_T7,\n          SAC_FLOAT_T8, SAC_FLOAT_T9};\n    // Loop on the observations\n    for (iobs=0; iobs<grns->nobs; iobs++)\n    {\n        for (idep=0; idep<grns->ndepth; idep++)\n        {\n            for (it=0; it<grns->ntstar; it++)\n            {\n                memset(&parallelCommands, 0,\n                       sizeof(struct parallelCommands_struct)); \n                memset(&commands, 0, sizeof(struct serialCommands_struct));\n                kndx = tdsearch_greens_getGreensFunctionIndex(G11_GRNS,\n                                                              iobs, it, idep,\n                                                              *grns);\n                ierr = process_stringsToSerialCommandsOptions(\n                                      grns->cmdsGrns[kndx].ncmds,\n                                      (const char **) grns->cmdsGrns[kndx].cmds,\n                                      &commands);\n                if (ierr != 0)\n                {\n                    fprintf(stderr, \"%s: Error setting serial command string\\n\", __func__);\n                    goto ERROR;\n                }\n                // Determine some characteristics of the processing\n                sacio_getEpochalStartTime(grns->grns[kndx].header, &epoch0);\n                sacio_getFloatHeader(SAC_FLOAT_DELTA,\n                                     grns->grns[kndx].header, &dt0);\n                lnewDt = false;\n                lnewStartTime = false;\n                epoch = epoch0;\n                dt = dt0;\n                for (i=0; i<commands.ncmds; i++)\n                {\n                     if (commands.commands[i].type == CUT_COMMAND)\n                     {\n                         i0 = commands.commands[i].cut.i0;\n                         epoch = epoch + (double) i0*dt;\n                         lnewStartTime = true;\n                     }\n                     if (commands.commands[i].type == DOWNSAMPLE_COMMAND)\n                     {\n                         nq = commands.commands[i].downsample.nq;\n                         dt = dt*(double) nq;\n                         lnewDt = true;\n                     }\n                     if (commands.commands[i].type == DECIMATE_COMMAND)\n                     {\n                         nq = commands.commands[i].decimate.nqAll;\n                         dt = dt*(double) nq;\n                         lnewDt = true;\n                     }\n                }\n                dataPtr[0] = 0;\n                for (i=0; i<nsignals; i++)\n                {\n                    dataPtr[i+1] = dataPtr[i] + grns->grns[kndx+i].npts;\n                }\n                process_setCommandOnAllParallelCommands(nsignals, commands,\n                                                        &parallelCommands);\n                data = memory_calloc64f(dataPtr[nsignals]);\n                for (i=0; i<nsignals; i++)\n                {\n                    ierr = array_copy64f_work(grns->grns[kndx+i].npts,\n                                              grns->grns[kndx+i].data,\n                                              &data[dataPtr[i]]);\n                    if (ierr != 0)\n                    {\n                         fprintf(stderr, \"%s: Failed to copy data\\n\", __func__);\n                         goto ERROR;\n                    }\n                }\n                ierr = process_setParallelCommandsData64f(nsignals, dataPtr,\n                                                          data,\n                                                          &parallelCommands);\n                if (ierr != 0)\n                {\n                    fprintf(stderr, \"%s: Failed to set data\\n\", __func__);\n                    goto ERROR;\n                }\n                ierr = process_applyParallelCommands(&parallelCommands);\n                if (ierr != 0)\n                {\n                    fprintf(stderr ,\"%s: Failed to process data\\n\", __func__);\n                    goto ERROR;\n                }\n                // Get the data\n                nwork = dataPtr[nsignals];\n                ierr = process_getParallelCommandsData64f(parallelCommands,\n                                                          -1, nsignals,\n                                                          &ny, &ns,\n                                                          dataPtr, data);\n                if (ny > nwork)\n                {\n                    memory_free64f(&data);\n                    data = memory_calloc64f(ny);\n                }\n                nwork = ny;\n                ierr = process_getParallelCommandsData64f(parallelCommands,\n                                                          nwork, nsignals,\n                                                          &ny, &ns,\n                                                          dataPtr, data);\n                for (i=0; i<nsignals; i++)\n                {\n                    sacio_getIntegerHeader(SAC_INT_NPTS,  \n                                           grns->grns[kndx+i].header, &npts0);\n                    npts = dataPtr[i+1] - dataPtr[i];\n                    // Resize event\n                    if (npts != npts0)\n                    {\n                        sacio_freeData(&grns->grns[kndx+i]);\n                        grns->grns[kndx+i].data = sacio_malloc64f(npts);\n                        grns->grns[kndx+i].npts = npts;\n                        sacio_setIntegerHeader(SAC_INT_NPTS, npts,\n                                               &grns->grns[kndx+i].header);\n                        ierr = array_copy64f_work(npts,\n                                                  &data[dataPtr[i]],\n                                                  grns->grns[kndx+i].data);\n                    }\n                    else\n                    {\n                        ierr = array_copy64f_work(npts,\n                                                  &data[dataPtr[i]],\n                                                  grns->grns[kndx+i].data);\n                    }\n                }\n                // Update the times\n                if (lnewStartTime)\n                {\n                    for (i=0; i<nsignals; i++)\n                    {\n                        // Update the picks\n                        for (l=0; l<nTimeVars; l++)\n                        {\n                            ierr = sacio_getFloatHeader(timeVars[l],\n                                              grns->grns[kndx+i].header, &time);\n                            if (ierr == 0)\n                            {\n                                time = time + epoch0; // Turn to real time\n                                time = time - epoch;  // Relative to new time\n                                sacio_setFloatHeader(timeVars[l], time,\n                                                    &grns->grns[kndx+i].header);\n                            }\n                        } // Loop on picks\n                        sacio_setEpochalStartTime(epoch,\n                                                  &grns->grns[kndx+i].header);\n                    } // Loop on signals\n                }\n                // Update the sampling period\n                if (lnewDt)\n                {\n                    for (i=0; i<nsignals; i++)\n                    {\n                        sacio_setFloatHeader(SAC_FLOAT_DELTA, dt,\n                                             &grns->grns[kndx+i].header);\n                    }\n                }\n                process_freeSerialCommands(&commands);\n                process_freeParallelCommands(&parallelCommands);\n                memory_free64f(&data);\n//TODO fix this\ntdsearch_greens_repickGreensWithSTALTA(2.0, 10.0, 80.0, iobs, it, idep, grns);\n            }\n        }\n    }\nERROR:;\n    return 0;\n}\n//============================================================================//\n/*!\n * @brief Writes the Green's functions corresponding to the iobs'th observation\n *        for the given tstar, depth index.\n *\n * @param[in] dirnm    Directory name where the Green's functions should be\n *                     written.  If this is NULL then the Green's functions\n *                     will be written to the current working directory.\n * @param[in] iobs     Observation index in the range [0,nobs-1].\n * @param[in] itstar   The t* index in the range [0,ntstar-1].\n * @param[in] idepth   The depth index in the range [0,ndepth-1].\n * @param[in] grns     The structure containing the Green's functions.\n *\n * @result 0 indicates success.\n *\n * @ingroup tdsearch_greens\n *\n */\nint tdsearch_greens_writeSelectGreensFunctions(\n    const char *dirnm,\n    const int iobs, const int itstar, const int idepth,\n    const struct tdSearchGreens_struct grns) \n{\n    char fileName[PATH_MAX], rootName[PATH_MAX];\n    size_t lenos;\n    int i, ierr, indx;\n    memset(rootName, 0, PATH_MAX*sizeof(char));\n    if (dirnm == NULL)\n    {\n        strcpy(rootName, \"./\\0\");\n    }\n    else\n    {\n        lenos = strlen(dirnm);\n        if (lenos > 0)\n        {\n            strcpy(rootName, dirnm);\n            if (rootName[lenos-1] != '/'){strcat(rootName, \"/\\0\");}\n        }\n        else\n        {\n            strcpy(rootName, \"./\\0\");\n        }\n    }\n    if (!os_path_isdir(rootName))\n    {\n        ierr = os_makedirs(rootName);\n        if (ierr != 0)\n        {\n            fprintf(stderr, \"%s: Failed to make output directory %s\\n\",\n                    __func__, rootName);\n            return -1;\n        }\n    }\n    // Get the indices to write\n    indx =  tdsearch_greens_getGreensFunctionIndex(G11_GRNS,\n                                                   iobs, itstar, idepth,\n                                                   grns);\n    if (indx < 0)\n    {\n        fprintf(stderr, \"%s: Invalid index\\n\", __func__);\n        return -1;\n    }\n    for (i=0; i<6; i++)\n    {\n        memset(fileName, 0, PATH_MAX*sizeof(char));\n        sprintf(fileName, \"%s%s.%s.%s.%s.DEPTH_%d.TSTAR_%d.SAC\",\n                rootName, grns.grns[indx+i].header.knetwk,\n                grns.grns[indx+i].header.kstnm,\n                grns.grns[indx+i].header.kcmpnm,\n                grns.grns[indx+i].header.khole, idepth, itstar);\n        sacio_writeTimeSeriesFile(fileName, grns.grns[indx+i]);\n    }\n    return 0;\n}\n//============================================================================//\nstatic int getPrimaryArrival(const struct sacHeader_struct hdr,\n                             double *time, char phaseName[8])\n{\n    const enum sacHeader_enum timeVars[11]\n       = {SAC_FLOAT_A,\n          SAC_FLOAT_T0, SAC_FLOAT_T1, SAC_FLOAT_T2, SAC_FLOAT_T3,\n          SAC_FLOAT_T4, SAC_FLOAT_T5, SAC_FLOAT_T6, SAC_FLOAT_T7,\n          SAC_FLOAT_T8, SAC_FLOAT_T9};\n    const enum sacHeader_enum timeVarNames[11]\n       = {SAC_CHAR_KA,\n          SAC_CHAR_KT0, SAC_CHAR_KT1, SAC_CHAR_KT2, SAC_CHAR_KT3,\n          SAC_CHAR_KT4, SAC_CHAR_KT5, SAC_CHAR_KT6, SAC_CHAR_KT7,\n          SAC_CHAR_KT8, SAC_CHAR_KT9};\n    int i, ifound1, ifound2; \n    memset(phaseName, 0, 8*sizeof(char));\n    for (i=0; i<11; i++)\n    {\n        ifound1 = sacio_getFloatHeader(timeVars[i], hdr, time);\n        ifound2 = sacio_getCharacterHeader(timeVarNames[i], hdr, phaseName); \n        if (ifound1 == 0 && ifound2 == 0){return 0;}\n    }\n    printf(\"%s: Failed to get primary pick\\n\", __func__);\n    *time =-12345.0;\n    memset(phaseName, 0, 8*sizeof(char));\n    strcpy(phaseName, \"-12345\"); \n    return -1;\n}\n", "meta": {"hexsha": "ae3e33e621a99d46f63828cecef62e86a5679c46", "size": 44824, "ext": "c", "lang": "C", "max_stars_repo_path": "src/greens.c", "max_stars_repo_name": "bakerb845/tdsearch", "max_stars_repo_head_hexsha": "fc65471b097aa6a92fcaf558dfa50622345c4025", "max_stars_repo_licenses": ["Intel"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/greens.c", "max_issues_repo_name": "bakerb845/tdsearch", "max_issues_repo_head_hexsha": "fc65471b097aa6a92fcaf558dfa50622345c4025", "max_issues_repo_licenses": ["Intel"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/greens.c", "max_forks_repo_name": "bakerb845/tdsearch", "max_forks_repo_head_hexsha": "fc65471b097aa6a92fcaf558dfa50622345c4025", "max_forks_repo_licenses": ["Intel"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.8086580087, "max_line_length": 91, "alphanum_fraction": 0.4762627164, "num_tokens": 11023, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.1732882016598637, "lm_q2_score": 0.031143832558095677, "lm_q1q2_score": 0.005396858736788313}}
{"text": "#ifndef MKL_TEMPLATE\n#define MKL_TEMPLATE\n\n//#include <cblas.h>\n#include <stddef.h>\n//#include <blas.h>\n#ifdef small\n#undef small\n#endif\n//#include <lapack.h>\n#include <cblas_defvar.h>\n\n#ifdef NEW_MATLAB\n   typedef ptrdiff_t INTT;\n#else\n   typedef int INTT;\n#endif\n\n/// a few static variables for lapack\nstatic char low='l';\nstatic char lower='L';\nstatic char nonUnit='n';\nstatic char upper='u';\nstatic INTT info=0;\nstatic char incr='I';\nstatic char decr='D';\nstatic char all='A';\nstatic char no='N';\nstatic char reduced='S';\nstatic char allV='V';\n\n#ifdef REMOVE_\n#define dnrm2_ dnrm2\n#define snrm2_ snrm2\n#define dcopy_ dcopy\n#define scopy_ scopy\n#define daxpy_ daxpy\n#define saxpy_ saxpy\n#define dscal_ dscal\n#define sscal_ sscal\n#define dasum_ dasum\n#define sasum_ sasum\n#define ddot_ ddot\n#define sdot_ sdot\n#define dgemv_ dgemv\n#define sgemv_ sgemv\n#define dger_ dger\n#define sger_ sger\n#define dtrmv_ dtrmv\n#define strmv_ strmv\n#define dsyr_ dsyr\n#define ssyr_ ssyr\n#define dsymv_ dsymv\n#define ssymv_ ssymv\n#define dgemm_ dgemm\n#define sgemm_ sgemm\n#define dsyrk_ dsyrk\n#define ssyrk_ ssyrk\n#define dtrmm_ dtrmm\n#define strmm_ strmm\n#define dtrtri_ dtrtri\n#define strtri_ strtri\n#define idamax_ idamax\n#define isamax_ isamax\n#define dsytrf_ dsytrf\n#define ssytrf_ ssytrf\n#define dsytri_ dsytri\n#define ssytri_ ssytri\n#define dlasrt_ dlasrt\n#define slasrt_ slasrt\n#define dgesvd_ dgesvd\n#define sgesvd_ sgesvd\n#define dsyev_ dsyev\n#define ssyev_ ssyev\n#endif\n\n/// external functions\n#ifdef HAVE_MKL   // obsolete\nextern \"C\" {\n#endif\n   size_t cblas_idamin( int n,  double* X,  int incX);\n   size_t cblas_isamin( int n,  float* X,  int incX);\n#ifdef HAVE_MKL\n};\n#endif\n\n#ifdef HAVE_MKL\nextern \"C\" {\n   void vdSqr( int n,  double* vecIn, double* vecOut);\n   void vsSqr( int n,  float* vecIn, float* vecOut);\n   void vdSqrt( int n,  double* vecIn, double* vecOut);\n   void vsSqrt( int n,  float* vecIn, float* vecOut);\n   void vdInvSqrt( int n,  double* vecIn, double* vecOut);\n   void vsInvSqrt( int n,  float* vecIn, float* vecOut);\n   void vdSub( int n,  double* vecIn,  double* vecIn2, double* vecOut);\n   void vsSub( int n,  float* vecIn,  float* vecIn2, float* vecOut);\n   void vdDiv( int n,  double* vecIn,  double* vecIn2, double* vecOut);\n   void vsDiv( int n,  float* vecIn,  float* vecIn2, float* vecOut);\n   void vdExp( int n,  double* vecIn, double* vecOut);\n   void vsExp( int n,  float* vecIn, float* vecOut);\n   void vdInv( int n,  double* vecIn, double* vecOut);\n   void vsInv( int n,  float* vecIn, float* vecOut);\n   void vdAdd( int n,  double* vecIn,  double* vecIn2, double* vecOut);\n   void vsAdd( int n,  float* vecIn,  float* vecIn2, float* vecOut);\n   void vdMul( int n,  double* vecIn,  double* vecIn2, double* vecOut);\n   void vsMul( int n,  float* vecIn,  float* vecIn2, float* vecOut);\n   void vdAbs( int n,  double* vecIn, double* vecOut);\n   void vsAbs( int n,  float* vecIn, float* vecOut);\n}\n#endif\n\n\n// INTTerfaces to a few BLAS function, Level 1\n/// INTTerface to cblas_*nrm2\ntemplate <typename T> T cblas_nrm2( INTT n,  T* X,  INTT incX);\n/// INTTerface to cblas_*copy\ntemplate <typename T> void cblas_copy( INTT n,  T* X,  INTT incX, \n      T* Y,  INTT incY);\n/// INTTerface to cblas_*axpy\ntemplate <typename T> void cblas_axpy( INTT n,  T a,  T* X, \n       INTT incX, T* Y,  INTT incY);\n/// INTTerface to cblas_*scal\ntemplate <typename T> void cblas_scal( INTT n,  T a, T* X, \n       INTT incX);\n/// INTTerface to cblas_*asum\ntemplate <typename T> T cblas_asum( INTT n,  T* X,  INTT incX);\n/// INTTerface to cblas_*adot\ntemplate <typename T> T cblas_dot( INTT n,  T* X,  INTT incX, \n       T* Y, INTT incY);\n/// interface to cblas_i*amin\ntemplate <typename T> int cblas_iamin( INTT n,  T* X,  INTT incX);\n/// interface to cblas_i*amax\ntemplate <typename T> int cblas_iamax( INTT n,  T* X,  INTT incX);\n\n// INTTerfaces to a few BLAS function, Level 2\n\n/// INTTerface to cblas_*gemv\ntemplate <typename T> void cblas_gemv( CBLAS_ORDER order,\n       CBLAS_TRANSPOSE TransA,  INTT M, \n       INTT N,  T alpha,  T *A,  INTT lda,  T *X, \n       INTT incX,  T beta,T *Y,   INTT incY);\n/// INTTerface to cblas_*trmv\ntemplate <typename T> void inline cblas_trmv( CBLAS_ORDER order,  CBLAS_UPLO Uplo,\n       CBLAS_TRANSPOSE TransA,  CBLAS_DIAG Diag,  INTT N,\n       T *A,  INTT lda, T *X,  INTT incX);\n/// INTTerface to cblas_*syr\ntemplate <typename T> void inline cblas_syr( CBLAS_ORDER order, \n        CBLAS_UPLO Uplo,  INTT N,  T alpha, \n       T *X,  INTT incX, T *A,  INTT lda);\n\n/// INTTerface to cblas_*symv\ntemplate <typename T> inline void cblas_symv( CBLAS_ORDER order,\n       CBLAS_UPLO Uplo,  INTT N, \n       T alpha,  T *A,  INTT lda,  T *X, \n       INTT incX,  T beta,T *Y,   INTT incY);\n\n\n// INTTerfaces to a few BLAS function, Level 3\n/// INTTerface to cblas_*gemm\ntemplate <typename T> void cblas_gemm( CBLAS_ORDER order, \n       CBLAS_TRANSPOSE TransA,  CBLAS_TRANSPOSE TransB, \n       INTT M,  INTT N,  INTT K,  T alpha, \n       T *A,  INTT lda,  T *B,  INTT ldb,\n       T beta, T *C,  INTT ldc);\n/// INTTerface to cblas_*syrk\ntemplate <typename T> void cblas_syrk( CBLAS_ORDER order, \n       CBLAS_UPLO Uplo,  CBLAS_TRANSPOSE Trans,  INTT N,  INTT K,\n       T alpha,  T *A,  INTT lda,\n       T beta, T*C,  INTT ldc);\n/// INTTerface to cblas_*ger\ntemplate <typename T> void cblas_ger( CBLAS_ORDER order, \n       INTT M,  INTT N,  T alpha,  T *X,  INTT incX,\n       T* Y,  INTT incY, T*A,  INTT lda);\n/// INTTerface to cblas_*trmm\ntemplate <typename T> void cblas_trmm( CBLAS_ORDER order, \n       CBLAS_SIDE Side,  CBLAS_UPLO Uplo, \n       CBLAS_TRANSPOSE TransA,  CBLAS_DIAG Diag,\n       INTT M,  INTT N,  T alpha, \n       T*A,  INTT lda,T *B,  INTT ldb);\n\n// interfaces to a few functions from the intel Vector Mathematical Library\n/// interface to v*Sqr\ntemplate <typename T> void vSqrt( int n,  T* vecIn, T* vecOut);\n/// interface to v*Sqr\ntemplate <typename T> void vInvSqrt( int n,  T* vecIn, T* vecOut);\n/// interface to v*Sqr\ntemplate <typename T> void vSqr( int n,  T* vecIn, T* vecOut);\n/// interface to v*Sub\ntemplate <typename T> void vSub( int n,  T* vecIn,  T* vecIn2, T* vecOut);\n/// interface to v*Div\ntemplate <typename T> void vDiv( int n,  T* vecIn,  T* vecIn2, T* vecOut);\n/// interface to v*Exp\ntemplate <typename T> void vExp( int n,  T* vecIn, T* vecOut);\n/// interface to v*Inv\ntemplate <typename T> void vInv( int n,  T* vecIn, T* vecOut);\n/// interface to v*Add\ntemplate <typename T> void vAdd( int n,  T* vecIn,  T* vecIn2, T* vecOut);\n/// interface to v*Mul\ntemplate <typename T> void vMul( int n,  T* vecIn,  T* vecIn2, T* vecOut);\n/// interface to v*Abs\ntemplate <typename T> void vAbs( int n,  T* vecIn, T* vecOut);\n\n// interfaces to a few LAPACK functions\n/// interface to *trtri\ntemplate <typename T> void trtri(char& uplo, char& diag, \n      INTT n, T * a, INTT lda);\n/// interface to *sytri  // call sytrf\ntemplate <typename T> void sytri(char& uplo, INTT n, T* a, INTT lda);\n//, INTT* ipiv,\n//      T* work);\n/// interaface to *lasrt\ntemplate <typename T> void lasrt(char& id,  INTT n, T *d);\n//template <typename T> void lasrt2(char& id,  INTT& n, T *d, int* key);\ntemplate <typename T> void gesvd( char& jobu, char& jobvt, INTT m, \n      INTT n, T* a, INTT lda, T* s,\n      T* u, INTT ldu, T* vt, INTT ldvt);\ntemplate <typename T> void syev( char& jobz, char& uplo, INTT n,\n         T* a, INTT lda, T* w);\n\n\n/* ******************\n * Implementations\n * *****************/\n\nextern \"C\" {\n   double dnrm2_(INTT *n,double *x,INTT *incX);\n   float snrm2_(INTT *n,float *x,INTT *incX);\n   void dcopy_(INTT *n,double *x,INTT *incX, double *y,INTT *incY);\n   void scopy_(INTT *n,float *x,INTT *incX, float *y,INTT *incY);\n   void daxpy_(INTT *n,double* a, double *x,INTT *incX, double *y,INTT *incY);\n   void saxpy_(INTT *n,float* a, float *x,INTT *incX, float *y,INTT *incY);\n   void dscal_(INTT *n,double* a, double *x,INTT *incX);\n   void sscal_(INTT *n,float* a, float *x,INTT *incX);\n   double dasum_(INTT *n,double *x,INTT *incX);\n   float sasum_(INTT *n,float *x,INTT *incX);\n   double ddot_(INTT *n,double *x,INTT *incX, double *y,INTT *incY);\n   float sdot_(INTT *n,float *x,INTT *incX, float *y,INTT *incY);\n   void dgemv_(char   *trans, INTT *m, INTT *n, double *alpha, double *a,\n         INTT *lda, double *x, INTT *incx, double *beta, double *y,INTT *incy);\n   void sgemv_(char   *trans, INTT *m, INTT *n, float *alpha, float *a,\n         INTT *lda, float *x, INTT *incx, float *beta, float *y,INTT *incy);\n   void dger_(INTT *m, INTT *n, double *alpha, double *x, INTT *incx,\n         double *y, INTT *incy, double *a, INTT *lda);\n   void sger_(INTT *m, INTT *n, float *alpha, float *x, INTT *incx,\n         float *y, INTT *incy, float *a, INTT *lda);\n   void dtrmv_(char *uplo, char *trans, char   *diag, INTT *n, double *a,\n         INTT *lda, double *x, INTT *incx);\n   void strmv_(char *uplo, char *trans, char   *diag, INTT *n, float *a,\n         INTT *lda, float *x, INTT *incx);\n   void dsyr_(char *uplo, INTT *n, double *alpha, double *x, INTT *incx,\n         double *a, INTT *lda);\n   void ssyr_(char *uplo, INTT *n, float *alpha, float *x, INTT *incx,\n         float *a, INTT *lda);\n   void dsymv_(char   *uplo, INTT *n, double *alpha, double *a, INTT *lda,\n         double *x, INTT *incx, double *beta, double *y, INTT *incy);\n   void ssymv_(char   *uplo, INTT *n, float *alpha, float *a, INTT *lda,\n         float *x, INTT *incx, float *beta, float *y, INTT *incy);\n   void dgemm_(char *transa, char *transb, INTT *m, INTT *n, INTT *k,\n         double *alpha, double *a, INTT *lda, double *b, INTT *ldb, double *beta,\n         double *c, INTT *ldc);\n   void sgemm_(char *transa, char *transb, INTT *m, INTT *n, INTT *k,\n         float *alpha, float *a, INTT *lda, float *b, INTT *ldb, float *beta,\n         float *c, INTT *ldc);\n   void dsyrk_(char *uplo, char *trans, INTT *n, INTT *k, double *alpha,\n         double *a, INTT *lda, double *beta, double *c, INTT *ldc);\n   void ssyrk_(char *uplo, char *trans, INTT *n, INTT *k, float *alpha,\n         float *a, INTT *lda, float *beta, float *c, INTT *ldc);\n   void dtrmm_(char *side,char *uplo,char *transa, char *diag, INTT *m,\n         INTT *n, double *alpha, double *a, INTT *lda, double *b, \n         INTT *ldb);\n   void strmm_(char *side,char *uplo,char *transa, char *diag, INTT *m,\n         INTT *n, float *alpha, float *a, INTT *lda, float *b, \n         INTT *ldb);\n   INTT idamax_(INTT *n, double *dx, INTT *incx);\n   INTT isamax_(INTT *n, float *dx, INTT *incx);\n   void dtrtri_(char* uplo, char* diag, INTT* n, double * a, INTT* lda, \n         INTT* info);\n   void strtri_(char* uplo, char* diag, INTT* n, float * a, INTT* lda, \n         INTT* info);\n   void dsytrf_(char* uplo, INTT* n, double* a, INTT* lda, INTT* ipiv,\n         double* work, INTT* lwork, INTT* info);\n   void ssytrf_(char* uplo, INTT* n, float* a, INTT* lda, INTT* ipiv,\n         float* work, INTT* lwork, INTT* info);\n   void dsytri_(char* uplo, INTT* n, double* a, INTT* lda, INTT* ipiv,\n         double* work, INTT* info);\n   void ssytri_(char* uplo, INTT* n, float* a, INTT* lda, INTT* ipiv,\n         float* work, INTT* info);\n   void dlasrt_(char* id,  INTT* n, double *d, INTT* info);\n   void slasrt_(char* id,  INTT* n, float*d, INTT* info);\n   void dgesvd_(char*jobu, char *jobvt, INTT *m, INTT *n, double *a,\n         INTT *lda, double *s, double *u, INTT *ldu, double *vt,\n         INTT *ldvt, double *work, INTT *lwork, INTT *info);\n   void sgesvd_(char*jobu, char *jobvt, INTT *m, INTT *n, float *a,\n         INTT *lda, float *s, float *u, INTT *ldu, float *vt,\n         INTT *ldvt, float *work, INTT *lwork, INTT *info);\n   void dsyev_(char *jobz, char *uplo, INTT *n, double *a, INTT *lda,\n         double *w, double *work, INTT *lwork, INTT *info);\n   void ssyev_(char *jobz, char *uplo, INTT *n, float *a, INTT *lda,\n         float *w, float *work, INTT *lwork, INTT *info);\n}\n\n// Implementations of the INTTerfaces, BLAS Level 1\n/// Implementation of the INTTerface for cblas_dnrm2\ntemplate <> inline double cblas_nrm2<double>( INTT n,  double* X, \n       INTT incX) {\n   //return cblas_dnrm2(n,X,incX);\n   return dnrm2_(&n,X,&incX);\n};\n/// Implementation of the INTTerface for cblas_snrm2\ntemplate <> inline float cblas_nrm2<float>( INTT n,  float* X, \n       INTT incX) {\n   //return cblas_snrm2(n,X,incX);\n   return snrm2_(&n,X,&incX);\n};\n/// Implementation of the INTTerface for cblas_dcopy\ntemplate <> inline void cblas_copy<double>( INTT n,  double* X, \n       INTT incX, double* Y,  INTT incY) {\n   //cblas_dcopy(n,X,incX,Y,incY);\n   dcopy_(&n,X,&incX,Y,&incY);\n};\n/// Implementation of the INTTerface for cblas_scopy\ntemplate <> inline void cblas_copy<float>( INTT n,  float* X,  INTT incX, \n      float* Y,  INTT incY) {\n   //cblas_scopy(n,X,incX,Y,incY);\n   scopy_(&n,X,&incX,Y,&incY);\n};\n/// Implementation of the INTTerface for cblas_scopy\ntemplate <> inline void cblas_copy<int>( INTT n,  int* X,  INTT incX, \n      int* Y,  INTT incY) {\n   for (int i = 0; i<n; ++i)\n      Y[incY*i]=X[incX*i];\n};\n/// Implementation of the INTTerface for cblas_scopy\ntemplate <> inline void cblas_copy<bool>( INTT n,  bool* X,  INTT incX, \n      bool* Y,  INTT incY) {\n   for (int i = 0; i<n; ++i)\n      Y[incY*i]=X[incX*i];\n};\n\n/// Implementation of the INTTerface for cblas_daxpy\ntemplate <> inline void cblas_axpy<double>( INTT n,  double a,  double* X, \n       INTT incX, double* Y,  INTT incY) {\n   //cblas_daxpy(n,a,X,incX,Y,incY);\n   daxpy_(&n,&a,X,&incX,Y,&incY);\n};\n/// Implementation of the INTTerface for cblas_saxpy\ntemplate <> inline void cblas_axpy<float>( INTT n,  float a,  float* X,\n       INTT incX, float* Y,  INTT incY) {\n   //cblas_saxpy(n,a,X,incX,Y,incY);\n   saxpy_(&n,&a,X,&incX,Y,&incY);\n};\n\n/// Implementation of the INTTerface for cblas_saxpy\ntemplate <> inline void cblas_axpy<int>( INTT n,  int a,  int* X,\n       INTT incX, int* Y,  INTT incY) {\n   for (int i = 0; i<n; ++i)\n      Y[i] += a*X[i];\n};\n\n/// Implementation of the INTTerface for cblas_saxpy\ntemplate <> inline void cblas_axpy<bool>( INTT n,  bool a,  bool* X,\n       INTT incX, bool* Y,  INTT incY) {\n   for (int i = 0; i<n; ++i)\n      Y[i] = a*X[i];\n};\n\n\n/// Implementation of the INTTerface for cblas_dscal\ntemplate <> inline void cblas_scal<double>( INTT n,  double a, double* X,\n       INTT incX) {\n   //cblas_dscal(n,a,X,incX);\n   dscal_(&n,&a,X,&incX);\n};\n/// Implementation of the INTTerface for cblas_sscal\ntemplate <> inline void cblas_scal<float>( INTT n,  float a, float* X, \n       INTT incX) {\n   //cblas_sscal(n,a,X,incX);\n   sscal_(&n,&a,X,&incX);\n};\n/// Implementation of the INTTerface for cblas_sscal\ntemplate <> inline void cblas_scal<int>( INTT n,  int a, int* X, \n       INTT incX) {\n   for (int i = 0; i<n; ++i) X[i*incX]*=a;\n};\n/// Implementation of the INTTerface for cblas_sscal\ntemplate <> inline void cblas_scal<bool>( INTT n,  bool a, bool* X, \n       INTT incX) {\n   /// not implemented\n};\n\n/// Implementation of the INTTerface for cblas_dasum\ntemplate <> inline double cblas_asum<double>( INTT n,  double* X,  INTT incX) {\n   //return cblas_dasum(n,X,1);\n   return dasum_(&n,X,&incX);\n};\n/// Implementation of the INTTerface for cblas_sasum\ntemplate <> inline float cblas_asum<float>( INTT n,  float* X,  INTT incX) {\n   //return cblas_sasum(n,X,1);\n   return sasum_(&n,X,&incX);\n};\n/// Implementation of the INTTerface for cblas_ddot\ntemplate <> inline double cblas_dot<double>( INTT n,  double* X,\n       INTT incX,  double* Y, INTT incY) {\n   //return cblas_ddot(n,X,incX,Y,incY);\n   return ddot_(&n,X,&incX,Y,&incY);\n};\n/// Implementation of the INTTerface for cblas_sdot\ntemplate <> inline float cblas_dot<float>( INTT n,  float* X,\n       INTT incX,  float* Y, INTT incY) {\n   //return cblas_sdot(n,X,incX,Y,incY);\n   return sdot_(&n,X,&incX,Y,&incY);\n};\ntemplate <> inline int cblas_dot<int>( INTT n,  int* X,\n       INTT incX,  int* Y, INTT incY) {\n   int total=0;\n   int i,j;\n   j=0;\n   for (i = 0; i<n; ++i) {\n      total+=X[i*incX]*Y[j];\n      //j+=incY;\n      j+=(int)incY;\n   }\n   return total;\n};\n/// Implementation of the INTTerface for cblas_sdot\ntemplate <> inline bool cblas_dot<bool>( INTT n,  bool* X,\n       INTT incX,  bool* Y, INTT incY) {\n   /// not implemented\n   return true;\n};\n\n// Implementations of the INTTerfaces, BLAS Level 2\n///  Implementation of the INTTerface for cblas_dgemv\ntemplate <> inline void cblas_gemv<double>( CBLAS_ORDER order,\n       CBLAS_TRANSPOSE TransA,  INTT M,  INTT N,\n       double alpha,  double *A,  INTT lda,\n       double *X,  INTT incX,  double beta,\n      double *Y,  INTT incY) {\n   //cblas_dgemv(order,TransA,M,N,alpha,A,lda,X,incX,beta,Y,incY);\n   dgemv_(cblas_transpose(TransA),&M,&N,&alpha,A,&lda,X,&incX,&beta,Y,&incY);\n};\n///  Implementation of the INTTerface for cblas_sgemv\ntemplate <> inline void cblas_gemv<float>( CBLAS_ORDER order,\n       CBLAS_TRANSPOSE TransA,  INTT M,  INTT N,\n       float alpha,  float *A,  INTT lda,\n       float *X,  INTT incX,  float beta,\n      float *Y,  INTT incY) {\n   //cblas_sgemv(order,TransA,M,N,alpha,A,lda,X,incX,beta,Y,incY);\n   sgemv_(cblas_transpose(TransA),&M,&N,&alpha,A,&lda,X,&incX,&beta,Y,&incY);\n};\n///  Implementation of the INTTerface for cblas_sgemv\ntemplate <> inline void cblas_gemv<int>( CBLAS_ORDER order,\n       CBLAS_TRANSPOSE TransA,  INTT M,  INTT N,\n       int alpha,  int *A,  INTT lda,\n       int *X,  INTT incX,  int beta,\n      int *Y,  INTT incY) {\n   ///  not implemented\n};\n///  Implementation of the INTTerface for cblas_sgemv\ntemplate <> inline void cblas_gemv<bool>( CBLAS_ORDER order,\n       CBLAS_TRANSPOSE TransA,  INTT M,  INTT N,\n       bool alpha,  bool *A,  INTT lda,\n       bool *X,  INTT incX,  bool beta,\n      bool *Y,  INTT incY) {\n   /// not implemented\n};\n\n///  Implementation of the INTTerface for cblas_dger\ntemplate <> inline void cblas_ger<double>( CBLAS_ORDER order, \n       INTT M,  INTT N,  double alpha,  double *X,  INTT incX,\n       double* Y,  INTT incY, double *A,  INTT lda) {\n   //cblas_dger(order,M,N,alpha,X,incX,Y,incY,A,lda);\n   dger_(&M,&N,&alpha,X,&incX,Y,&incY,A,&lda);\n};\n///  Implementation of the INTTerface for cblas_sger\ntemplate <> inline void cblas_ger<float>( CBLAS_ORDER order, \n       INTT M,  INTT N,  float alpha,  float *X,  INTT incX,\n       float* Y,  INTT incY, float *A,  INTT lda) {\n   //cblas_sger(order,M,N,alpha,X,incX,Y,incY,A,lda);\n   sger_(&M,&N,&alpha,X,&incX,Y,&incY,A,&lda);\n};\n///  Implementation of the INTTerface for cblas_dtrmv\ntemplate <> inline void cblas_trmv<double>( CBLAS_ORDER order,  CBLAS_UPLO Uplo,\n       CBLAS_TRANSPOSE TransA,  CBLAS_DIAG Diag,  INTT N,\n       double *A,  INTT lda, double *X,  INTT incX) {\n   //cblas_dtrmv(order,Uplo,TransA,Diag,N,A,lda,X,incX);\n   dtrmv_(cblas_uplo(Uplo),cblas_transpose(TransA),cblas_diag(Diag),&N,A,&lda,X,&incX);\n};\n///  Implementation of the INTTerface for cblas_strmv\ntemplate <> inline void cblas_trmv<float>( CBLAS_ORDER order,  CBLAS_UPLO Uplo,\n       CBLAS_TRANSPOSE TransA,  CBLAS_DIAG Diag,  INTT N,\n       float *A,  INTT lda, float *X,  INTT incX) {\n   //cblas_strmv(order,Uplo,TransA,Diag,N,A,lda,X,incX);\n   strmv_(cblas_uplo(Uplo),cblas_transpose(TransA),cblas_diag(Diag),&N,A,&lda,X,&incX);\n};\n/// Implementation of cblas_dsyr\ntemplate <> inline void cblas_syr( CBLAS_ORDER order, \n        CBLAS_UPLO Uplo,\n       INTT N,  double alpha,  double*X,\n       INTT incX, double *A,  INTT lda) {\n   //cblas_dsyr(order,Uplo,N,alpha,X,incX,A,lda);\n   dsyr_(cblas_uplo(Uplo),&N,&alpha,X,&incX,A,&lda);\n};\n/// Implementation of cblas_ssyr\ntemplate <> inline void cblas_syr( CBLAS_ORDER order, \n        CBLAS_UPLO Uplo,\n       INTT N,  float alpha,  float*X,\n       INTT incX, float *A,  INTT lda) {\n   //cblas_ssyr(order,Uplo,N,alpha,X,incX,A,lda);\n   ssyr_(cblas_uplo(Uplo),&N,&alpha,X,&incX,A,&lda);\n};\n/// Implementation of cblas_ssymv\ntemplate <> inline void cblas_symv( CBLAS_ORDER order,\n       CBLAS_UPLO Uplo,  INTT N, \n       float alpha,  float *A,  INTT lda,  float *X, \n       INTT incX,  float beta,float *Y,   INTT incY) {\n   //cblas_ssymv(order,Uplo,N,alpha,A,lda,X,incX,beta,Y,incY);\n   ssymv_(cblas_uplo(Uplo),&N,&alpha,A,&lda,X,&incX,&beta,Y,&incY);\n}\n/// Implementation of cblas_dsymv\ntemplate <> inline void cblas_symv( CBLAS_ORDER order,\n       CBLAS_UPLO Uplo,  INTT N, \n       double alpha,  double *A,  INTT lda,  double *X, \n       INTT incX,  double beta,double *Y,   INTT incY) {\n   //cblas_dsymv(order,Uplo,N,alpha,A,lda,X,incX,beta,Y,incY);\n   dsymv_(cblas_uplo(Uplo),&N,&alpha,A,&lda,X,&incX,&beta,Y,&incY);\n}\n\n\n// Implementations of the INTTerfaces, BLAS Level 3\n///  Implementation of the INTTerface for cblas_dgemm\ntemplate <> inline void cblas_gemm<double>( CBLAS_ORDER order, \n       CBLAS_TRANSPOSE TransA,  CBLAS_TRANSPOSE TransB, \n       INTT M,  INTT N,  INTT K,  double alpha, \n       double *A,  INTT lda,  double *B,  INTT ldb,\n       double beta, double *C,  INTT ldc) {\n   //cblas_dgemm(Order,TransA,TransB,M,N,K,alpha,A,lda,B,ldb,beta,C,ldc);\n   dgemm_(cblas_transpose(TransA),cblas_transpose(TransB),&M,&N,&K,&alpha,A,&lda,B,&ldb,&beta,C,&ldc);\n};\n///  Implementation of the INTTerface for cblas_sgemm\ntemplate <> inline void cblas_gemm<float>( CBLAS_ORDER order, \n       CBLAS_TRANSPOSE TransA,  CBLAS_TRANSPOSE TransB, \n       INTT M,  INTT N,  INTT K,  float alpha, \n       float *A,  INTT lda,  float *B,  INTT ldb,\n       float beta, float *C,  INTT ldc) {\n   //cblas_sgemm(Order,TransA,TransB,M,N,K,alpha,A,lda,B,ldb,beta,C,ldc);\n   sgemm_(cblas_transpose(TransA),cblas_transpose(TransB),&M,&N,&K,&alpha,A,&lda,B,&ldb,&beta,C,&ldc);\n};\ntemplate <> inline void cblas_gemm<int>( CBLAS_ORDER order, \n       CBLAS_TRANSPOSE TransA,  CBLAS_TRANSPOSE TransB, \n       INTT M,  INTT N,  INTT K,  int alpha, \n       int *A,  INTT lda,  int *B,  INTT ldb,\n       int beta, int *C,  INTT ldc) {\n   /// not implemented\n};\n///  Implementation of the INTTerface for cblas_sgemm\ntemplate <> inline void cblas_gemm<bool>( CBLAS_ORDER order, \n       CBLAS_TRANSPOSE TransA,  CBLAS_TRANSPOSE TransB, \n       INTT M,  INTT N,  INTT K,  bool alpha, \n       bool *A,  INTT lda,  bool *B,  INTT ldb,\n       bool beta, bool *C,  INTT ldc) {\n   /// not implemented\n};\n\n///  Implementation of the INTTerface for cblas_dsyrk\ntemplate <> inline void cblas_syrk<double>( CBLAS_ORDER order, \n       CBLAS_UPLO Uplo,  CBLAS_TRANSPOSE Trans,  INTT N,  INTT K,\n       double alpha,  double *A,  INTT lda,\n       double beta, double *C,  INTT ldc) {\n   //cblas_dsyrk(Order,Uplo,Trans,N,K,alpha,A,lda,beta,C,ldc);\n   dsyrk_(cblas_uplo(Uplo),cblas_transpose(Trans),&N,&K,&alpha,A,&lda,&beta,C,&ldc);\n};\n///  Implementation of the INTTerface for cblas_ssyrk\ntemplate <> inline void cblas_syrk<float>( CBLAS_ORDER order, \n       CBLAS_UPLO Uplo,  CBLAS_TRANSPOSE Trans,  INTT N,  INTT K,\n       float alpha,  float *A,  INTT lda,\n       float beta, float *C,  INTT ldc) {\n   //cblas_ssyrk(Order,Uplo,Trans,N,K,alpha,A,lda,beta,C,ldc);\n   ssyrk_(cblas_uplo(Uplo),cblas_transpose(Trans),&N,&K,&alpha,A,&lda,&beta,C,&ldc);\n};\n///  Implementation of the INTTerface for cblas_ssyrk\ntemplate <> inline void cblas_syrk<int>( CBLAS_ORDER order, \n       CBLAS_UPLO Uplo,  CBLAS_TRANSPOSE Trans,  INTT N,  INTT K,\n       int alpha,  int *A,  INTT lda,\n       int beta, int *C,  INTT ldc) {\n   /// not implemented\n};\n///  Implementation of the INTTerface for cblas_ssyrk\ntemplate <> inline void cblas_syrk<bool>( CBLAS_ORDER order, \n       CBLAS_UPLO Uplo,  CBLAS_TRANSPOSE Trans,  INTT N,  INTT K,\n       bool alpha,  bool *A,  INTT lda,\n       bool beta, bool *C,  INTT ldc) {\n   /// not implemented\n};\n\n///  Implementation of the INTTerface for cblas_dtrmm\ntemplate <> inline void cblas_trmm<double>( CBLAS_ORDER order, \n       CBLAS_SIDE Side,  CBLAS_UPLO Uplo, \n       CBLAS_TRANSPOSE TransA,  CBLAS_DIAG Diag,\n       INTT M,  INTT N,  double alpha, \n       double *A,  INTT lda,double *B,  INTT ldb) {\n   //cblas_dtrmm(Order,Side,Uplo,TransA,Diag,M,N,alpha,A,lda,B,ldb);\n   dtrmm_(cblas_side(Side),cblas_uplo(Uplo),cblas_transpose(TransA),cblas_diag(Diag),&M,&N,&alpha,A,&lda,B,&ldb);\n};\n///  Implementation of the INTTerface for cblas_strmm\ntemplate <> inline void cblas_trmm<float>( CBLAS_ORDER order, \n       CBLAS_SIDE Side,  CBLAS_UPLO Uplo, \n       CBLAS_TRANSPOSE TransA,  CBLAS_DIAG Diag,\n       INTT M,  INTT N,  float alpha, \n       float *A,  INTT lda,float *B,  INTT ldb) {\n   //cblas_strmm(Order,Side,Uplo,TransA,Diag,M,N,alpha,A,lda,B,ldb);\n   strmm_(cblas_side(Side),cblas_uplo(Uplo),cblas_transpose(TransA),cblas_diag(Diag),&M,&N,&alpha,A,&lda,B,&ldb);\n};\n///  Implementation of the interface for cblas_idamax\ntemplate <> inline int cblas_iamax<double>( INTT n,  double* X,\n       INTT incX) {\n   //return cblas_idamax(n,X,incX);\n   return static_cast<int>(idamax_(&n,X,&incX)-1);\n};\n///  Implementation of the interface for cblas_isamax\ntemplate <> inline int cblas_iamax<float>( INTT n,  float* X, \n       INTT incX) {\n   //return cblas_isamax(n,X,incX);\n   return static_cast<int>(isamax_(&n,X,&incX)-1);\n};\n\n// Implementations of the interfaces, LAPACK\n/// Implemenation of the interface for dtrtri\ntemplate <> inline void trtri<double>(char& uplo, char& diag, \n      INTT n, double * a, INTT lda) {\n   //dtrtri_(&uplo,&diag,&n,a,&lda,&info);\n   dtrtri_(&uplo,&diag,&n,a,&lda,&info);\n};\n/// Implemenation of the interface for strtri\ntemplate <> inline void trtri<float>(char& uplo, char& diag, \n      INTT n, float* a, INTT lda) {\n   //strtri_(&uplo,&diag,&n,a,&lda,&info);\n   strtri_(&uplo,&diag,&n,a,&lda,&info);\n};\n\n/// Implemenation of the interface for dsytri\ntemplate <> inline void sytri<double>(char& uplo, INTT n, double* a, INTT lda) {\n//, INTT* ipiv, double* work) {\n   //dsytri_(&uplo,&n,a,&lda,ipiv,work,&info);\n   INTT lwork=-1;\n   INTT* ipiv= new INTT[n];\n   double* query, *work;\n   query = new double[1];\n   dsytrf_(&uplo,&n,a,&lda,ipiv,query,&lwork,&info);\n   lwork=static_cast<INTT>(*query); \n   delete[](query);\n   work = new double[static_cast<int>(lwork)];\n   dsytrf_(&uplo,&n,a,&lda,ipiv,work,&lwork,&info);\n   delete[](work);\n   work = new double[static_cast<int>(2*n)];\n   dsytri_(&uplo,&n,a,&lda,ipiv,work,&info);\n   delete[](work);\n   delete[](ipiv);\n};\n/// Implemenation of the interface for ssytri\ntemplate <> inline void sytri<float>(char& uplo, INTT n, float* a, INTT lda) {\n   INTT lwork=-1;\n   INTT* ipiv= new INTT[n];\n   float* query, *work;\n   query = new float[1];\n   ssytrf_(&uplo,&n,a,&lda,ipiv,query,&lwork,&info);\n   lwork=static_cast<INTT>(*query); \n   delete[](query);\n   work = new float[static_cast<int>(lwork)];\n   ssytrf_(&uplo,&n,a,&lda,ipiv,work,&lwork,&info);\n   delete[](work);\n   work = new float[static_cast<int>(2*n)];\n   ssytri_(&uplo,&n,a,&lda,ipiv,work,&info);\n   delete[](work);\n   delete[](ipiv);\n};\n/// interaface to *lasrt\ntemplate <> inline void lasrt(char& id, INTT n, double *d) {\n   //dlasrt_(&id,const_cast<int*>(&n),d,&info);\n   dlasrt_(&id,&n,d,&info);\n};\n/// interaface to *lasrt\ntemplate <> inline void lasrt(char& id, INTT n, float *d) {\n   //slasrt_(&id,const_cast<int*>(&n),d,&info);\n   slasrt_(&id,&n,d,&info);\n};\n//template <> inline void lasrt2(char& id, INTT& n, double *d,int* key) {\n//   //dlasrt2_(&id,const_cast<int*>(&n),d,key,&info);\n//   dlasrt2(&id,&n,d,key,&info);\n//};\n///// interaface to *lasrt\n//template <> inline void lasrt2(char& id, INTT& n, float *d, int* key) {\n//   //slasrt2_(&id,const_cast<int*>(&n),d,key,&info);\n//   slasrt2(&id,&n,d,key,&info);\n//};\ntemplate <> void inline gesvd( char& jobu, char& jobvt, INTT m, \n      INTT n, double* a, INTT lda, double* s,\n      double* u, INTT ldu, double* vt, INTT ldvt) {\n   double* query = new double[1];\n   INTT lwork=-1;\n   dgesvd_(&jobu, &jobvt, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt,\n         query, &lwork, &info );\n   lwork=static_cast<INTT>(*query); \n   delete[](query);\n   double* work = new double[static_cast<int>(lwork)];\n   dgesvd_(&jobu, &jobvt, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt,\n         work, &lwork, &info );\n   delete[](work);\n}\ntemplate <> void inline gesvd( char& jobu, char& jobvt, INTT m, \n      INTT n, float* a, INTT lda, float* s,\n      float* u, INTT ldu, float* vt, INTT ldvt) {\n   float* query = new float[1];\n   INTT lwork=-1;\n   sgesvd_(&jobu, &jobvt, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt,\n         query, &lwork, &info );\n   lwork=static_cast<INTT>(*query); \n   delete[](query);\n   float* work = new float[static_cast<int>(lwork)];\n   sgesvd_(&jobu, &jobvt, &m, &n, a, &lda, s, u, &ldu, vt, &ldvt,\n         work, &lwork, &info );\n   delete[](work);\n}\n\ntemplate <> void inline syev( char& jobz, char& uplo, INTT n,\n         float* a, INTT lda, float* w) {\n   float* query = new float[1];\n   INTT lwork=-1;\n   ssyev_(&jobz,&uplo,&n,a,&lda,w,query,&lwork,&info);\n   lwork=static_cast<INTT>(*query); \n   delete[](query);\n   float* work = new float[static_cast<int>(lwork)];\n   ssyev_(&jobz,&uplo,&n,a,&lda,w,work,&lwork,&info);\n   delete[](work);\n};\n\ntemplate <> void inline syev( char& jobz, char& uplo, INTT n,\n         double* a, INTT lda, double* w) {\n   double* query = new double[1];\n   INTT lwork=-1;\n   dsyev_(&jobz,&uplo,&n,a,&lda,w,query,&lwork,&info);\n   lwork=static_cast<INTT>(*query); \n   delete[](query);\n   double* work = new double[static_cast<int>(lwork)];\n   dsyev_(&jobz,&uplo,&n,a,&lda,w,work,&lwork,&info);\n   delete[](work);\n};\n\n\n\n\n/// If the MKL is not present, a slow implementation is used instead.\n#ifdef HAVE_MKL \n/// Implemenation of the interface for vdSqr\ntemplate <> inline void vSqr<double>( int n,  double* vecIn, \n      double* vecOut) {\n   vdSqr(n,vecIn,vecOut);\n};\n/// Implemenation of the interface for vsSqr\ntemplate <> inline void vSqr<float>( int n,  float* vecIn, \n      float* vecOut) {\n   vsSqr(n,vecIn,vecOut);\n};\ntemplate <> inline void vSqrt<double>( int n,  double* vecIn, \n      double* vecOut) {\n   vdSqrt(n,vecIn,vecOut);\n};\n/// Implemenation of the interface for vsSqr\ntemplate <> inline void vSqrt<float>( int n,  float* vecIn, \n      float* vecOut) {\n   vsSqrt(n,vecIn,vecOut);\n};\ntemplate <> inline void vInvSqrt<double>( int n,  double* vecIn, \n      double* vecOut) {\n   vdInvSqrt(n,vecIn,vecOut);\n};\n/// Implemenation of the interface for vsSqr\ntemplate <> inline void vInvSqrt<float>( int n,  float* vecIn, \n      float* vecOut) {\n   vsInvSqrt(n,vecIn,vecOut);\n};\n\n/// Implemenation of the interface for vdSub\ntemplate <> inline void vSub<double>( int n,  double* vecIn, \n       double* vecIn2, double* vecOut) {\n   vdSub(n,vecIn,vecIn2,vecOut);\n};\n/// Implemenation of the interface for vsSub\ntemplate <> inline void vSub<float>( int n,  float* vecIn, \n       float* vecIn2, float* vecOut) {\n   vsSub(n,vecIn,vecIn2,vecOut);\n};\n/// Implemenation of the interface for vdDiv\ntemplate <> inline void vDiv<double>( int n,  double* vecIn, \n       double* vecIn2, double* vecOut) {\n   vdDiv(n,vecIn,vecIn2,vecOut);\n};\n/// Implemenation of the interface for vsDiv\ntemplate <> inline void vDiv<float>( int n,  float* vecIn, \n       float* vecIn2, float* vecOut) {\n   vsDiv(n,vecIn,vecIn2,vecOut);\n};\n/// Implemenation of the interface for vdExp\ntemplate <> inline void vExp<double>( int n,  double* vecIn, \n      double* vecOut) {\n   vdExp(n,vecIn,vecOut);\n};\n/// Implemenation of the interface for vsExp\ntemplate <> inline void vExp<float>( int n,  float* vecIn, \n      float* vecOut) {\n   vsExp(n,vecIn,vecOut);\n};\n/// Implemenation of the interface for vdInv\ntemplate <> inline void vInv<double>( int n,  double* vecIn, \n      double* vecOut) {\n   vdInv(n,vecIn,vecOut);\n};\n/// Implemenation of the interface for vsInv\ntemplate <> inline void vInv<float>( int n,  float* vecIn, \n      float* vecOut) {\n   vsInv(n,vecIn,vecOut);\n};\n/// Implemenation of the interface for vdAdd\ntemplate <> inline void vAdd<double>( int n,  double* vecIn, \n       double* vecIn2, double* vecOut) {\n   vdAdd(n,vecIn,vecIn2,vecOut);\n};\n/// Implemenation of the interface for vsAdd\ntemplate <> inline void vAdd<float>( int n,  float* vecIn, \n       float* vecIn2, float* vecOut) {\n   vsAdd(n,vecIn,vecIn2,vecOut);\n};\n/// Implemenation of the interface for vdMul\ntemplate <> inline void vMul<double>( int n,  double* vecIn, \n       double* vecIn2, double* vecOut) {\n   vdMul(n,vecIn,vecIn2,vecOut);\n};\n/// Implemenation of the interface for vsMul\ntemplate <> inline void vMul<float>( int n,  float* vecIn, \n       float* vecIn2, float* vecOut) {\n   vsMul(n,vecIn,vecIn2,vecOut);\n};\n\n/// interface to vdAbs\ntemplate <> inline void vAbs( int n,  double* vecIn, \n      double* vecOut) {\n   vdAbs(n,vecIn,vecOut);\n};\n/// interface to vdAbs\ntemplate <> inline void vAbs( int n,  float* vecIn, \n      float* vecOut) {\n   vsAbs(n,vecIn,vecOut);\n};\n\n\n/// implemenation of the interface of the non-offical blas, level 1 function \n/// cblas_idamin\ntemplate <> inline int cblas_iamin<double>( int n,  double* x,\n       int incx) {\n   return (int) cblas_idamin(n,x,incx);\n};\n/// implemenation of the interface of the non-offical blas, level 1 function \n/// cblas_isamin\ntemplate <> inline int cblas_iamin<float>( int n,  float* x, \n       int incx) {\n   return (int) cblas_isamin(n,x,incx);\n};\n/// slow alternative implementation of some MKL function\n#else\n/// Slow implementation of vdSqr and vsSqr\ntemplate <typename T> inline void vSqr( int n,  T* vecIn, T* vecOut) {\n   for (int i = 0; i<n; ++i) vecOut[i]=vecIn[i]*vecIn[i];\n};\ntemplate <typename T> inline void vSqrt( int n,  T* vecIn, T* vecOut) {\n   for (int i = 0; i<n; ++i) vecOut[i]=sqr<T>(vecIn[i]);\n};\ntemplate <typename T> inline void vInvSqrt( int n,  T* vecIn, T* vecOut) {\n   for (int i = 0; i<n; ++i) vecOut[i]=T(1.0)/sqr<T>(vecIn[i]);\n};\n\n/// Slow implementation of vdSub and vsSub\ntemplate <typename T> inline void vSub( int n,  T* vecIn1, \n       T* vecIn2, T* vecOut) {\n   for (int i = 0; i<n; ++i) vecOut[i]=vecIn1[i]-vecIn2[i];\n};\n/// Slow implementation of vdInv and vsInv\ntemplate <typename T> inline void vInv( int n,  T* vecIn, T* vecOut) {\n   for (int i = 0; i<n; ++i) vecOut[i]=1.0/vecIn[i];\n};\n/// Slow implementation of vdExp and vsExp\ntemplate <typename T> inline void vExp( int n,  T* vecIn, T* vecOut) {\n   for (int i = 0; i<n; ++i) vecOut[i]=exp(vecIn[i]);\n};\n/// Slow implementation of vdAdd and vsAdd\ntemplate <typename T> inline void vAdd( int n,  T* vecIn1, \n       T* vecIn2, T* vecOut) {\n   for (int i = 0; i<n; ++i) vecOut[i]=vecIn1[i]+vecIn2[i];\n};\n/// Slow implementation of vdMul and vsMul\ntemplate <typename T> inline void vMul( int n,  T* vecIn1, \n       T* vecIn2, T* vecOut) {\n   for (int i = 0; i<n; ++i) vecOut[i]=vecIn1[i]*vecIn2[i];\n};\n/// Slow implementation of vdDiv and vsDiv\ntemplate <typename T> inline void vDiv( int n,  T* vecIn1, \n       T* vecIn2, T* vecOut) {\n   for (int i = 0; i<n; ++i) vecOut[i]=vecIn1[i]/vecIn2[i];\n};\n/// Slow implementation of vAbs\ntemplate <typename T> inline void vAbs( int n,  T* vecIn, \n      T* vecOut) {\n   for (int i = 0; i<n; ++i) vecOut[i]=abs<T>(vecIn[i]);\n};\n\n/// Slow implementation of cblas_idamin and cblas_isamin\ntemplate <typename T> int inline cblas_iamin(INTT n, T* X, INTT incX) {\n   int imin=0;\n   double min=fabs(X[0]);\n   for (int j = 1; j<n; j+=incX) {\n      double cur = fabs(X[j]);\n      if (cur < min) {\n         imin=j;\n         min = cur;\n      }\n   }\n   return imin;\n}\n#endif\n\n#endif \n", "meta": {"hexsha": "e1e6c58f8b5e0c94296bfd104f99cbb2f357e152", "size": 35312, "ext": "h", "lang": "C", "max_stars_repo_path": "util/ISR/spams-matlab/linalg/cblas_alt_template.h", "max_stars_repo_name": "ChrystleMyrnaLobo/person-reid-benchmark", "max_stars_repo_head_hexsha": "d09fa9c57213464f94e37cb3b202dddc6f0b0267", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 202.0, "max_stars_repo_stars_event_min_datetime": "2017-12-08T21:23:53.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-02T15:32:17.000Z", "max_issues_repo_path": "util/ISR/spams-matlab/linalg/cblas_alt_template.h", "max_issues_repo_name": "XuJiaMing1997/person-reid-benchmark", "max_issues_repo_head_hexsha": "d09fa9c57213464f94e37cb3b202dddc6f0b0267", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 13.0, "max_issues_repo_issues_event_min_datetime": "2017-12-18T12:54:20.000Z", "max_issues_repo_issues_event_max_datetime": "2020-04-17T17:33:27.000Z", "max_forks_repo_path": "util/ISR/spams-matlab/linalg/cblas_alt_template.h", "max_forks_repo_name": "XuJiaMing1997/person-reid-benchmark", "max_forks_repo_head_hexsha": "d09fa9c57213464f94e37cb3b202dddc6f0b0267", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 77.0, "max_forks_repo_forks_event_min_datetime": "2017-12-18T01:35:18.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-18T08:37:05.000Z", "avg_line_length": 37.9291084855, "max_line_length": 113, "alphanum_fraction": 0.6449932034, "num_tokens": 12637, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.34864513533394575, "lm_q2_score": 0.014728614741716453, "lm_q1q2_score": 0.0051350598799072816}}
{"text": "/*\n * This file is part of the GROMACS molecular simulation package.\n *\n * Copyright (c) 1991-2000, University of Groningen, The Netherlands.\n * Copyright (c) 2001-2004, The GROMACS development team,\n * check out http://www.gromacs.org for more information.\n * Copyright (c) 2012,2013, by the GROMACS development team, led by\n * David van der Spoel, Berk Hess, Erik Lindahl, and including many\n * others, as listed in the AUTHORS file in the top-level source\n * directory and at http://www.gromacs.org.\n *\n * GROMACS is free software; you can redistribute it and/or\n * modify it under the terms of the GNU Lesser General Public License\n * as published by the Free Software Foundation; either version 2.1\n * of the License, or (at your option) any later version.\n *\n * GROMACS is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n * Lesser General Public License for more details.\n *\n * You should have received a copy of the GNU Lesser General Public\n * License along with GROMACS; if not, see\n * http://www.gnu.org/licenses, or write to the Free Software Foundation,\n * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.\n *\n * If you want to redistribute modifications to GROMACS, please\n * consider that scientific software is very special. Version\n * control is crucial - bugs must be traceable. We will be happy to\n * consider code for inclusion in the official distribution, but\n * derived work must not be called official GROMACS. Details are found\n * in the README & COPYING files - if they are missing, get the\n * official version at http://www.gromacs.org.\n *\n * To help us fund GROMACS development, we humbly ask that you cite\n * the research papers on the package. Check out http://www.gromacs.org.\n */\n#ifdef HAVE_CONFIG_H\n#include <config.h>\n#endif\n#include <math.h>\n#include <string.h>\n#include <stdlib.h>\n#include \"statutil.h\"\n#include \"sysstuff.h\"\n#include \"typedefs.h\"\n#include \"smalloc.h\"\n#include \"macros.h\"\n#include \"gmx_fatal.h\"\n#include \"vec.h\"\n#include \"copyrite.h\"\n#include \"futil.h\"\n#include \"readinp.h\"\n#include \"statutil.h\"\n#include \"txtdump.h\"\n#include \"gstat.h\"\n#include \"xvgr.h\"\n#include \"physics.h\"\n#include \"gmx_ana.h\"\n\nenum {\n    epAuf, epEuf, epAfu, epEfu, epNR\n};\nenum {\n    eqAif, eqEif, eqAfi, eqEfi, eqAui, eqEui, eqAiu, eqEiu, eqNR\n};\nstatic char *eep[epNR] = { \"Af\", \"Ef\", \"Au\", \"Eu\" };\nstatic char *eeq[eqNR] = { \"Aif\", \"Eif\", \"Afi\", \"Efi\", \"Aui\", \"Eui\", \"Aiu\", \"Eiu\" };\n\ntypedef struct {\n    int       nreplica;  /* Number of replicas in the calculation                   */\n    int       nframe;    /* Number of time frames                                   */\n    int       nstate;    /* Number of states the system can be in, e.g. F,I,U       */\n    int       nparams;   /* Is 2, 4 or 8                                            */\n    gmx_bool *bMask;     /* Determine whether this replica is part of the d2 comp.  */\n    gmx_bool  bSum;\n    gmx_bool  bDiscrete; /* Use either discrete folding (0/1) or a continuous       */\n    /* criterion */\n    int       nmask;     /* Number of replicas taken into account                   */\n    real      dt;        /* Timestep between frames                                 */\n    int       j0, j1;    /* Range of frames used in calculating delta               */\n    real    **temp, **data, **data2;\n    int     **state;     /* State index running from 0 (F) to nstate-1 (U)          */\n    real    **beta, **fcalt, **icalt;\n    real     *time, *sumft, *sumit, *sumfct, *sumict;\n    real     *params;\n    real     *d2_replica;\n} t_remd_data;\n\n#ifdef HAVE_LIBGSL\n#include <gsl/gsl_multimin.h>\n\nstatic char *itoa(int i)\n{\n    static char ptr[12];\n\n    sprintf(ptr, \"%d\", i);\n    return ptr;\n}\n\nstatic char *epnm(int nparams, int index)\n{\n    static char buf[32], from[8], to[8];\n    int         nn, ni, ii;\n\n    range_check(index, 0, nparams);\n    if ((nparams == 2) || (nparams == 4))\n    {\n        return eep[index];\n    }\n    else if ((nparams > 4) && (nparams % 4 == 0))\n    {\n        return eeq[index];\n    }\n    else\n    {\n        gmx_fatal(FARGS, \"Don't know how to handle %d parameters\", nparams);\n    }\n\n    return NULL;\n}\n\nstatic gmx_bool bBack(t_remd_data *d)\n{\n    return (d->nparams > 2);\n}\n\nstatic real is_folded(t_remd_data *d, int irep, int jframe)\n{\n    if (d->state[irep][jframe] == 0)\n    {\n        return 1.0;\n    }\n    else\n    {\n        return 0.0;\n    }\n}\n\nstatic real is_unfolded(t_remd_data *d, int irep, int jframe)\n{\n    if (d->state[irep][jframe] == d->nstate-1)\n    {\n        return 1.0;\n    }\n    else\n    {\n        return 0.0;\n    }\n}\n\nstatic real is_intermediate(t_remd_data *d, int irep, int jframe)\n{\n    if ((d->state[irep][jframe] == 1) && (d->nstate > 2))\n    {\n        return 1.0;\n    }\n    else\n    {\n        return 0.0;\n    }\n}\n\nstatic void integrate_dfdt(t_remd_data *d)\n{\n    int    i, j;\n    double beta, ddf, ddi, df, db, fac, sumf, sumi, area;\n\n    d->sumfct[0] = 0;\n    d->sumict[0] = 0;\n    for (i = 0; (i < d->nreplica); i++)\n    {\n        if (d->bMask[i])\n        {\n            if (d->bDiscrete)\n            {\n                ddf = 0.5*d->dt*is_folded(d, i, 0);\n                ddi = 0.5*d->dt*is_intermediate(d, i, 0);\n            }\n            else\n            {\n                ddf = 0.5*d->dt*d->state[i][0];\n                ddi = 0.0;\n            }\n            d->fcalt[i][0] = ddf;\n            d->icalt[i][0] = ddi;\n            d->sumfct[0]  += ddf;\n            d->sumict[0]  += ddi;\n        }\n    }\n    for (j = 1; (j < d->nframe); j++)\n    {\n        if (j == d->nframe-1)\n        {\n            fac = 0.5*d->dt;\n        }\n        else\n        {\n            fac = d->dt;\n        }\n        sumf = sumi = 0;\n        for (i = 0; (i < d->nreplica); i++)\n        {\n            if (d->bMask[i])\n            {\n                beta = d->beta[i][j];\n                if ((d->nstate <= 2) || d->bDiscrete)\n                {\n                    if (d->bDiscrete)\n                    {\n                        df = (d->params[epAuf]*exp(-beta*d->params[epEuf])*\n                              is_unfolded(d, i, j));\n                    }\n                    else\n                    {\n                        area = (d->data2 ? d->data2[i][j] : 1.0);\n                        df   =  area*d->params[epAuf]*exp(-beta*d->params[epEuf]);\n                    }\n                    if (bBack(d))\n                    {\n                        db = 0;\n                        if (d->bDiscrete)\n                        {\n                            db = (d->params[epAfu]*exp(-beta*d->params[epEfu])*\n                                  is_folded(d, i, j));\n                        }\n                        else\n                        {\n                            gmx_fatal(FARGS, \"Back reaction not implemented with continuous\");\n                        }\n                        ddf = fac*(df-db);\n                    }\n                    else\n                    {\n                        ddf = fac*df;\n                    }\n                    d->fcalt[i][j] = d->fcalt[i][j-1] + ddf;\n                    sumf          += ddf;\n                }\n                else\n                {\n                    ddf = fac*((d->params[eqAif]*exp(-beta*d->params[eqEif])*\n                                is_intermediate(d, i, j)) -\n                               (d->params[eqAfi]*exp(-beta*d->params[eqEfi])*\n                                is_folded(d, i, j)));\n                    ddi = fac*((d->params[eqAui]*exp(-beta*d->params[eqEui])*\n                                is_unfolded(d, i, j)) -\n                               (d->params[eqAiu]*exp(-beta*d->params[eqEiu])*\n                                is_intermediate(d, i, j)));\n                    d->fcalt[i][j] = d->fcalt[i][j-1] + ddf;\n                    d->icalt[i][j] = d->icalt[i][j-1] + ddi;\n                    sumf          += ddf;\n                    sumi          += ddi;\n                }\n            }\n        }\n        d->sumfct[j] = d->sumfct[j-1] + sumf;\n        d->sumict[j] = d->sumict[j-1] + sumi;\n    }\n    if (debug)\n    {\n        fprintf(debug, \"@type xy\\n\");\n        for (j = 0; (j < d->nframe); j++)\n        {\n            fprintf(debug, \"%8.3f  %12.5e\\n\", d->time[j], d->sumfct[j]);\n        }\n        fprintf(debug, \"&\\n\");\n    }\n}\n\nstatic void sum_ft(t_remd_data *d)\n{\n    int    i, j;\n    double fac;\n\n    for (j = 0; (j < d->nframe); j++)\n    {\n        d->sumft[j] = 0;\n        d->sumit[j] = 0;\n        if ((j == 0) || (j == d->nframe-1))\n        {\n            fac = d->dt*0.5;\n        }\n        else\n        {\n            fac = d->dt;\n        }\n        for (i = 0; (i < d->nreplica); i++)\n        {\n            if (d->bMask[i])\n            {\n                if (d->bDiscrete)\n                {\n                    d->sumft[j] += fac*is_folded(d, i, j);\n                    d->sumit[j] += fac*is_intermediate(d, i, j);\n                }\n                else\n                {\n                    d->sumft[j] += fac*d->state[i][j];\n                }\n            }\n        }\n    }\n}\n\nstatic double calc_d2(t_remd_data *d)\n{\n    int    i, j;\n    double dd2, d2 = 0, dr2, tmp;\n\n    integrate_dfdt(d);\n\n    if (d->bSum)\n    {\n        for (j = d->j0; (j < d->j1); j++)\n        {\n            if (d->bDiscrete)\n            {\n                d2  += sqr(d->sumft[j]-d->sumfct[j]);\n                if (d->nstate > 2)\n                {\n                    d2 += sqr(d->sumit[j]-d->sumict[j]);\n                }\n            }\n            else\n            {\n                d2  += sqr(d->sumft[j]-d->sumfct[j]);\n            }\n        }\n    }\n    else\n    {\n        for (i = 0; (i < d->nreplica); i++)\n        {\n            dr2 = 0;\n            if (d->bMask[i])\n            {\n                for (j = d->j0; (j < d->j1); j++)\n                {\n                    tmp  = sqr(is_folded(d, i, j)-d->fcalt[i][j]);\n                    d2  += tmp;\n                    dr2 += tmp;\n                    if (d->nstate > 2)\n                    {\n                        tmp  = sqr(is_intermediate(d, i, j)-d->icalt[i][j]);\n                        d2  += tmp;\n                        dr2 += tmp;\n                    }\n                }\n                d->d2_replica[i] = dr2/(d->j1-d->j0);\n            }\n        }\n    }\n    dd2 = (d2/(d->j1-d->j0))/(d->bDiscrete ? d->nmask : 1);\n\n    return dd2;\n}\n\nstatic double my_f(const gsl_vector *v, void *params)\n{\n    t_remd_data *d       = (t_remd_data *) params;\n    double       penalty = 0;\n    int          i;\n\n    for (i = 0; (i < d->nparams); i++)\n    {\n        d->params[i] = gsl_vector_get(v, i);\n        if (d->params[i] < 0)\n        {\n            penalty += 10;\n        }\n    }\n    if (penalty > 0)\n    {\n        return penalty;\n    }\n    else\n    {\n        return calc_d2(d);\n    }\n}\n\nstatic void optimize_remd_parameters(FILE *fp, t_remd_data *d, int maxiter,\n                                     real tol)\n{\n    real   size, d2;\n    int    iter   = 0;\n    int    status = 0;\n    int    i;\n\n    const gsl_multimin_fminimizer_type *T;\n    gsl_multimin_fminimizer            *s;\n\n    gsl_vector                         *x, *dx;\n    gsl_multimin_function               my_func;\n\n    my_func.f      = &my_f;\n    my_func.n      = d->nparams;\n    my_func.params = (void *) d;\n\n    /* Starting point */\n    x = gsl_vector_alloc (my_func.n);\n    for (i = 0; (i < my_func.n); i++)\n    {\n        gsl_vector_set (x, i, d->params[i]);\n    }\n\n    /* Step size, different for each of the parameters */\n    dx = gsl_vector_alloc (my_func.n);\n    for (i = 0; (i < my_func.n); i++)\n    {\n        gsl_vector_set (dx, i, 0.1*d->params[i]);\n    }\n\n    T = gsl_multimin_fminimizer_nmsimplex;\n    s = gsl_multimin_fminimizer_alloc (T, my_func.n);\n\n    gsl_multimin_fminimizer_set (s, &my_func, x, dx);\n    gsl_vector_free (x);\n    gsl_vector_free (dx);\n\n    printf (\"%5s\", \"Iter\");\n    for (i = 0; (i < my_func.n); i++)\n    {\n        printf(\" %12s\", epnm(my_func.n, i));\n    }\n    printf (\" %12s %12s\\n\", \"NM Size\", \"Chi2\");\n\n    do\n    {\n        iter++;\n        status = gsl_multimin_fminimizer_iterate (s);\n\n        if (status != 0)\n        {\n            gmx_fatal(FARGS, \"Something went wrong in the iteration in minimizer %s\",\n                      gsl_multimin_fminimizer_name(s));\n        }\n\n        d2     = gsl_multimin_fminimizer_minimum(s);\n        size   = gsl_multimin_fminimizer_size(s);\n        status = gsl_multimin_test_size(size, tol);\n\n        if (status == GSL_SUCCESS)\n        {\n            printf (\"Minimum found using %s at:\\n\",\n                    gsl_multimin_fminimizer_name(s));\n        }\n\n        printf (\"%5d\", iter);\n        for (i = 0; (i < my_func.n); i++)\n        {\n            printf(\" %12.4e\", gsl_vector_get (s->x, i));\n        }\n        printf (\" %12.4e %12.4e\\n\", size, d2);\n    }\n    while ((status == GSL_CONTINUE) && (iter < maxiter));\n\n    gsl_multimin_fminimizer_free (s);\n}\n\nstatic void preprocess_remd(FILE *fp, t_remd_data *d, real cutoff, real tref,\n                            real ucut, gmx_bool bBack, real Euf, real Efu,\n                            real Ei, real t0, real t1, gmx_bool bSum, gmx_bool bDiscrete,\n                            int nmult)\n{\n    int  i, j, ninter;\n    real dd, tau_f, tau_u;\n\n    ninter = (ucut > cutoff) ? 1 : 0;\n    if (ninter && (ucut <= cutoff))\n    {\n        gmx_fatal(FARGS, \"You have requested an intermediate but the cutoff for intermediates %f is smaller than the normal cutoff(%f)\", ucut, cutoff);\n    }\n\n    if (!bBack)\n    {\n        d->nparams = 2;\n        d->nstate  = 2;\n    }\n    else\n    {\n        d->nparams = 4*(1+ninter);\n        d->nstate  = 2+ninter;\n    }\n    d->bSum      = bSum;\n    d->bDiscrete = bDiscrete;\n    snew(d->beta, d->nreplica);\n    snew(d->state, d->nreplica);\n    snew(d->bMask, d->nreplica);\n    snew(d->d2_replica, d->nreplica);\n    snew(d->sumft, d->nframe);\n    snew(d->sumit, d->nframe);\n    snew(d->sumfct, d->nframe);\n    snew(d->sumict, d->nframe);\n    snew(d->params, d->nparams);\n    snew(d->fcalt, d->nreplica);\n    snew(d->icalt, d->nreplica);\n\n    /* convert_times(d->nframe,d->time); */\n\n    if (t0 < 0)\n    {\n        d->j0 = 0;\n    }\n    else\n    {\n        for (d->j0 = 0; (d->j0 < d->nframe) && (d->time[d->j0] < t0); d->j0++)\n        {\n            ;\n        }\n    }\n    if (t1 < 0)\n    {\n        d->j1 = d->nframe;\n    }\n    else\n    {\n        for (d->j1 = 0; (d->j1 < d->nframe) && (d->time[d->j1] < t1); d->j1++)\n        {\n            ;\n        }\n    }\n    if ((d->j1-d->j0) < d->nparams+2)\n    {\n        gmx_fatal(FARGS, \"Start (%f) or end time (%f) for fitting inconsistent. Reduce t0, increase t1 or supply more data\", t0, t1);\n    }\n    fprintf(fp, \"Will optimize from %g to %g\\n\",\n            d->time[d->j0], d->time[d->j1-1]);\n    d->nmask = d->nreplica;\n    for (i = 0; (i < d->nreplica); i++)\n    {\n        snew(d->beta[i], d->nframe);\n        snew(d->state[i], d->nframe);\n        snew(d->fcalt[i], d->nframe);\n        snew(d->icalt[i], d->nframe);\n        d->bMask[i] = TRUE;\n        for (j = 0; (j < d->nframe); j++)\n        {\n            d->beta[i][j] = 1.0/(BOLTZ*d->temp[i][j]);\n            dd            = d->data[i][j];\n            if (bDiscrete)\n            {\n                if (dd <= cutoff)\n                {\n                    d->state[i][j] = 0;\n                }\n                else if ((ucut > cutoff) && (dd <= ucut))\n                {\n                    d->state[i][j] = 1;\n                }\n                else\n                {\n                    d->state[i][j] = d->nstate-1;\n                }\n            }\n            else\n            {\n                d->state[i][j] = dd*nmult;\n            }\n        }\n    }\n    sum_ft(d);\n\n    /* Assume forward rate constant is half the total time in this\n     * simulation and backward is ten times as long */\n    if (bDiscrete)\n    {\n        tau_f            = d->time[d->nframe-1];\n        tau_u            = 4*tau_f;\n        d->params[epEuf] = Euf;\n        d->params[epAuf] = exp(d->params[epEuf]/(BOLTZ*tref))/tau_f;\n        if (bBack)\n        {\n            d->params[epEfu] = Efu;\n            d->params[epAfu] = exp(d->params[epEfu]/(BOLTZ*tref))/tau_u;\n            if (ninter > 0)\n            {\n                d->params[eqEui] = Ei;\n                d->params[eqAui] = exp(d->params[eqEui]/(BOLTZ*tref))/tau_u;\n                d->params[eqEiu] = Ei;\n                d->params[eqAiu] = exp(d->params[eqEiu]/(BOLTZ*tref))/tau_u;\n            }\n        }\n        else\n        {\n            d->params[epAfu]  = 0;\n            d->params[epEfu]  = 0;\n        }\n    }\n    else\n    {\n        d->params[epEuf] = Euf;\n        if (d->data2)\n        {\n            d->params[epAuf] = 0.1;\n        }\n        else\n        {\n            d->params[epAuf] = 20.0;\n        }\n    }\n}\n\nstatic real tau(real A, real E, real T)\n{\n    return exp(E/(BOLTZ*T))/A;\n}\n\nstatic real folded_fraction(t_remd_data *d, real tref)\n{\n    real tauf, taub;\n\n    tauf = tau(d->params[epAuf], d->params[epEuf], tref);\n    taub = tau(d->params[epAfu], d->params[epEfu], tref);\n\n    return (taub/(tauf+taub));\n}\n\nstatic void print_tau(FILE *gp, t_remd_data *d, real tref)\n{\n    real tauf, taub, ddd, fff, DG, DH, TDS, Tm, Tb, Te, Fb, Fe, Fm;\n    int  i, np = d->nparams;\n\n    ddd = calc_d2(d);\n    fprintf(gp, \"Final value for Chi2 = %12.5e (%d replicas)\\n\", ddd, d->nmask);\n    tauf = tau(d->params[epAuf], d->params[epEuf], tref);\n    fprintf(gp, \"%s = %12.5e %s = %12.5e (kJ/mole)\\n\",\n            epnm(np, epAuf), d->params[epAuf],\n            epnm(np, epEuf), d->params[epEuf]);\n    if (bBack(d))\n    {\n        taub = tau(d->params[epAfu], d->params[epEfu], tref);\n        fprintf(gp, \"%s = %12.5e %s = %12.5e (kJ/mole)\\n\",\n                epnm(np, epAfu), d->params[epAfu],\n                epnm(np, epEfu), d->params[epEfu]);\n        fprintf(gp, \"Equilibrium properties at T = %g\\n\", tref);\n        fprintf(gp, \"tau_f = %8.3f ns, tau_b = %8.3f ns\\n\", tauf/1000, taub/1000);\n        fff = taub/(tauf+taub);\n        DG  = BOLTZ*tref*log(fff/(1-fff));\n        DH  = d->params[epEfu]-d->params[epEuf];\n        TDS = DH-DG;\n        fprintf(gp, \"Folded fraction     F = %8.3f\\n\", fff);\n        fprintf(gp, \"Unfolding energies: DG = %8.3f  DH = %8.3f TDS = %8.3f\\n\",\n                DG, DH, TDS);\n        Tb = 260;\n        Te = 420;\n        Tm = 0;\n        Fm = 0;\n        Fb = folded_fraction(d, Tb);\n        Fe = folded_fraction(d, Te);\n        while ((Te-Tb > 0.001) && (Fm != 0.5))\n        {\n            Tm = 0.5*(Tb+Te);\n            Fm = folded_fraction(d, Tm);\n            if (Fm > 0.5)\n            {\n                Fb = Fm;\n                Tb = Tm;\n            }\n            else if (Fm < 0.5)\n            {\n                Te = Tm;\n                Fe = Fm;\n            }\n        }\n        if ((Fb-0.5)*(Fe-0.5) <= 0)\n        {\n            fprintf(gp, \"Melting temperature Tm = %8.3f K\\n\", Tm);\n        }\n        else\n        {\n            fprintf(gp, \"No melting temperature detected between 260 and 420K\\n\");\n        }\n        if (np > 4)\n        {\n            char *ptr;\n            fprintf(gp, \"Data for intermediates at T = %g\\n\", tref);\n            fprintf(gp, \"%8s  %10s  %10s  %10s\\n\", \"Name\", \"A\", \"E\", \"tau\");\n            for (i = 0; (i < np/2); i++)\n            {\n                tauf = tau(d->params[2*i], d->params[2*i+1], tref);\n                ptr  = epnm(d->nparams, 2*i);\n                fprintf(gp, \"%8s  %10.3e  %10.3e  %10.3e\\n\", ptr+1,\n                        d->params[2*i], d->params[2*i+1], tauf/1000);\n            }\n        }\n    }\n    else\n    {\n        fprintf(gp, \"Equilibrium properties at T = %g\\n\", tref);\n        fprintf(gp, \"tau_f = %8.3f\\n\", tauf);\n    }\n}\n\nstatic void dump_remd_parameters(FILE *gp, t_remd_data *d, const char *fn,\n                                 const char *fn2, const char *rfn,\n                                 const char *efn, const char *mfn, int skip, real tref,\n                                 output_env_t oenv)\n{\n    FILE       *fp, *hp;\n    int         i, j, np = d->nparams;\n    real        rhs, tauf, taub, fff, DG;\n    real       *params;\n    const char *leg[]  = { \"Measured\", \"Fit\", \"Difference\" };\n    const char *mleg[] = { \"Folded fraction\", \"DG (kJ/mole)\"};\n    char      **rleg;\n    real        fac[] = { 0.97, 0.98, 0.99, 1.0, 1.01, 1.02, 1.03 };\n#define NFAC asize(fac)\n    real        d2[NFAC];\n    double      norm;\n\n    integrate_dfdt(d);\n    print_tau(gp, d, tref);\n    norm = (d->bDiscrete ? 1.0/d->nmask : 1.0);\n\n    if (fn)\n    {\n        fp = xvgropen(fn, \"Optimized fit to data\", \"Time (ps)\", \"Fraction Folded\", oenv);\n        xvgr_legend(fp, asize(leg), leg, oenv);\n        for (i = 0; (i < d->nframe); i++)\n        {\n            if ((skip <= 0) || ((i % skip) == 0))\n            {\n                fprintf(fp, \"%12.5e  %12.5e  %12.5e  %12.5e\\n\", d->time[i],\n                        d->sumft[i]*norm, d->sumfct[i]*norm,\n                        (d->sumft[i]-d->sumfct[i])*norm);\n            }\n        }\n        ffclose(fp);\n    }\n    if (!d->bSum && rfn)\n    {\n        snew(rleg, d->nreplica*2);\n        for (i = 0; (i < d->nreplica); i++)\n        {\n            snew(rleg[2*i], 32);\n            snew(rleg[2*i+1], 32);\n            sprintf(rleg[2*i], \"\\\\f{4}F(t) %d\", i);\n            sprintf(rleg[2*i+1], \"\\\\f{12}F \\\\f{4}(t) %d\", i);\n        }\n        fp = xvgropen(rfn, \"Optimized fit to data\", \"Time (ps)\", \"Fraction Folded\", oenv);\n        xvgr_legend(fp, d->nreplica*2, (const char**)rleg, oenv);\n        for (j = 0; (j < d->nframe); j++)\n        {\n            if ((skip <= 0) || ((j % skip) == 0))\n            {\n                fprintf(fp, \"%12.5e\", d->time[j]);\n                for (i = 0; (i < d->nreplica); i++)\n                {\n                    fprintf(fp, \"  %5f  %9.2e\", is_folded(d, i, j), d->fcalt[i][j]);\n                }\n                fprintf(fp, \"\\n\");\n            }\n        }\n        ffclose(fp);\n    }\n\n    if (fn2 && (d->nstate > 2))\n    {\n        fp = xvgropen(fn2, \"Optimized fit to data\", \"Time (ps)\",\n                      \"Fraction Intermediate\", oenv);\n        xvgr_legend(fp, asize(leg), leg, oenv);\n        for (i = 0; (i < d->nframe); i++)\n        {\n            if ((skip <= 0) || ((i % skip) == 0))\n            {\n                fprintf(fp, \"%12.5e  %12.5e  %12.5e  %12.5e\\n\", d->time[i],\n                        d->sumit[i]*norm, d->sumict[i]*norm,\n                        (d->sumit[i]-d->sumict[i])*norm);\n            }\n        }\n        ffclose(fp);\n    }\n    if (mfn)\n    {\n        if (bBack(d))\n        {\n            fp = xvgropen(mfn, \"Melting curve\", \"T (K)\", \"\", oenv);\n            xvgr_legend(fp, asize(mleg), mleg, oenv);\n            for (i = 260; (i <= 420); i++)\n            {\n                tauf = tau(d->params[epAuf], d->params[epEuf], 1.0*i);\n                taub = tau(d->params[epAfu], d->params[epEfu], 1.0*i);\n                fff  = taub/(tauf+taub);\n                DG   = BOLTZ*i*log(fff/(1-fff));\n                fprintf(fp, \"%5d  %8.3f  %8.3f\\n\", i, fff, DG);\n            }\n            ffclose(fp);\n        }\n    }\n\n    if (efn)\n    {\n        snew(params, d->nparams);\n        for (i = 0; (i < d->nparams); i++)\n        {\n            params[i] = d->params[i];\n        }\n\n        hp = xvgropen(efn, \"Chi2 as a function of relative parameter\",\n                      \"Fraction\", \"Chi2\", oenv);\n        for (j = 0; (j < d->nparams); j++)\n        {\n            /* Reset all parameters to optimized values */\n            fprintf(hp, \"@type xy\\n\");\n            for (i = 0; (i < d->nparams); i++)\n            {\n                d->params[i] = params[i];\n            }\n            /* Now modify one of them */\n            for (i = 0; (i < NFAC); i++)\n            {\n                d->params[j] = fac[i]*params[j];\n                d2[i]        = calc_d2(d);\n                fprintf(gp, \"%s = %12g  d2 = %12g\\n\", epnm(np, j), d->params[j], d2[i]);\n                fprintf(hp, \"%12g  %12g\\n\", fac[i], d2[i]);\n            }\n            fprintf(hp, \"&\\n\");\n        }\n        ffclose(hp);\n        for (i = 0; (i < d->nparams); i++)\n        {\n            d->params[i] = params[i];\n        }\n        sfree(params);\n    }\n    if (!d->bSum)\n    {\n        for (i = 0; (i < d->nreplica); i++)\n        {\n            fprintf(gp, \"Chi2[%3d] = %8.2e\\n\", i, d->d2_replica[i]);\n        }\n    }\n}\n#endif /*HAVE_LIBGSL*/\n\nint gmx_kinetics(int argc, char *argv[])\n{\n    const char     *desc[] = {\n        \"[TT]g_kinetics[tt] reads two [TT].xvg[tt] files, each one containing data for N replicas.\",\n        \"The first file contains the temperature of each replica at each timestep,\",\n        \"and the second contains real values that can be interpreted as\",\n        \"an indicator for folding. If the value in the file is larger than\",\n        \"the cutoff it is taken to be unfolded and the other way around.[PAR]\",\n        \"From these data an estimate of the forward and backward rate constants\",\n        \"for folding is made at a reference temperature. In addition,\",\n        \"a theoretical melting curve and free energy as a function of temperature\",\n        \"are printed in an [TT].xvg[tt] file.[PAR]\",\n        \"The user can give a max value to be regarded as intermediate\",\n        \"([TT]-ucut[tt]), which, when given will trigger the use of an intermediate state\",\n        \"in the algorithm to be defined as those structures that have\",\n        \"cutoff < DATA < ucut. Structures with DATA values larger than ucut will\",\n        \"not be regarded as potential folders. In this case 8 parameters are optimized.[PAR]\",\n        \"The average fraction foled is printed in an [TT].xvg[tt] file together with the fit to it.\",\n        \"If an intermediate is used a further file will show the build of the intermediate and the fit to that process.[PAR]\",\n        \"The program can also be used with continuous variables (by setting\",\n        \"[TT]-nodiscrete[tt]). In this case kinetics of other processes can be\",\n        \"studied. This is very much a work in progress and hence the manual\",\n        \"(this information) is lagging behind somewhat.[PAR]\",\n        \"In order to compile this program you need access to the GNU\",\n        \"scientific library.\"\n    };\n    static int      nreplica  = 1;\n    static real     tref      = 298.15;\n    static real     cutoff    = 0.2;\n    static real     ucut      = 0.0;\n    static real     Euf       = 10;\n    static real     Efu       = 30;\n    static real     Ei        = 10;\n    static gmx_bool bHaveT    = TRUE;\n    static real     t0        = -1;\n    static real     t1        = -1;\n    static real     tb        = 0;\n    static real     te        = 0;\n    static real     tol       = 1e-3;\n    static int      maxiter   = 100;\n    static int      skip      = 0;\n    static int      nmult     = 1;\n    static gmx_bool bBack     = TRUE;\n    static gmx_bool bSplit    = TRUE;\n    static gmx_bool bSum      = TRUE;\n    static gmx_bool bDiscrete = TRUE;\n    t_pargs         pa[]      = {\n        { \"-time\",    FALSE, etBOOL, {&bHaveT},\n          \"Expect a time in the input\" },\n        { \"-b\",       FALSE, etREAL, {&tb},\n          \"First time to read from set\" },\n        { \"-e\",       FALSE, etREAL, {&te},\n          \"Last time to read from set\" },\n        { \"-bfit\",    FALSE, etREAL, {&t0},\n          \"Time to start the fit from\" },\n        { \"-efit\",    FALSE, etREAL, {&t1},\n          \"Time to end the fit\" },\n        { \"-T\",       FALSE, etREAL, {&tref},\n          \"Reference temperature for computing rate constants\" },\n        { \"-n\",       FALSE, etINT, {&nreplica},\n          \"Read data for this number of replicas. Only necessary when files are written in xmgrace format using @type and & as delimiters.\" },\n        { \"-cut\",     FALSE, etREAL, {&cutoff},\n          \"Cut-off (max) value for regarding a structure as folded\" },\n        { \"-ucut\",    FALSE, etREAL, {&ucut},\n          \"Cut-off (max) value for regarding a structure as intermediate (if not folded)\" },\n        { \"-euf\",     FALSE, etREAL, {&Euf},\n          \"Initial guess for energy of activation for folding (kJ/mol)\" },\n        { \"-efu\",     FALSE, etREAL, {&Efu},\n          \"Initial guess for energy of activation for unfolding (kJ/mol)\" },\n        { \"-ei\",      FALSE, etREAL, {&Ei},\n          \"Initial guess for energy of activation for intermediates (kJ/mol)\" },\n        { \"-maxiter\", FALSE, etINT, {&maxiter},\n          \"Max number of iterations\" },\n        { \"-back\",    FALSE, etBOOL, {&bBack},\n          \"Take the back reaction into account\" },\n        { \"-tol\",     FALSE, etREAL, {&tol},\n          \"Absolute tolerance for convergence of the Nelder and Mead simplex algorithm\" },\n        { \"-skip\",    FALSE, etINT, {&skip},\n          \"Skip points in the output [TT].xvg[tt] file\" },\n        { \"-split\",   FALSE, etBOOL, {&bSplit},\n          \"Estimate error by splitting the number of replicas in two and refitting\" },\n        { \"-sum\",     FALSE, etBOOL, {&bSum},\n          \"Average folding before computing [GRK]chi[grk]^2\" },\n        { \"-discrete\", FALSE, etBOOL, {&bDiscrete},\n          \"Use a discrete folding criterion (F <-> U) or a continuous one\" },\n        { \"-mult\",    FALSE, etINT, {&nmult},\n          \"Factor to multiply the data with before discretization\" }\n    };\n#define NPA asize(pa)\n\n    FILE        *fp;\n    real         dt_t, dt_d, dt_d2;\n    int          nset_t, nset_d, nset_d2, n_t, n_d, n_d2, i;\n    const char  *tfile, *dfile, *dfile2;\n    t_remd_data  remd;\n    output_env_t oenv;\n\n    t_filenm     fnm[] = {\n        { efXVG, \"-f\",    \"temp\",    ffREAD   },\n        { efXVG, \"-d\",    \"data\",    ffREAD   },\n        { efXVG, \"-d2\",   \"data2\",   ffOPTRD  },\n        { efXVG, \"-o\",    \"ft_all\",  ffWRITE  },\n        { efXVG, \"-o2\",   \"it_all\",  ffOPTWR  },\n        { efXVG, \"-o3\",   \"ft_repl\", ffOPTWR  },\n        { efXVG, \"-ee\",   \"err_est\", ffOPTWR  },\n        { efLOG, \"-g\",    \"remd\",    ffWRITE  },\n        { efXVG, \"-m\",    \"melt\",    ffWRITE  }\n    };\n#define NFILE asize(fnm)\n\n    CopyRight(stderr, argv[0]);\n    parse_common_args(&argc, argv, PCA_CAN_VIEW | PCA_BE_NICE | PCA_TIME_UNIT,\n                      NFILE, fnm, NPA, pa, asize(desc), desc, 0, NULL, &oenv);\n\n#ifdef HAVE_LIBGSL\n    please_cite(stdout, \"Spoel2006d\");\n    if (cutoff < 0)\n    {\n        gmx_fatal(FARGS, \"cutoff should be >= 0 (rather than %f)\", cutoff);\n    }\n\n    tfile   = opt2fn(\"-f\", NFILE, fnm);\n    dfile   = opt2fn(\"-d\", NFILE, fnm);\n    dfile2  = opt2fn_null(\"-d2\", NFILE, fnm);\n\n    fp = ffopen(opt2fn(\"-g\", NFILE, fnm), \"w\");\n\n    remd.temp = read_xvg_time(tfile, bHaveT,\n                              opt2parg_bSet(\"-b\", NPA, pa), tb,\n                              opt2parg_bSet(\"-e\", NPA, pa), te,\n                              nreplica, &nset_t, &n_t, &dt_t, &remd.time);\n    printf(\"Read %d sets of %d points in %s, dt = %g\\n\\n\", nset_t, n_t, tfile, dt_t);\n    sfree(remd.time);\n\n    remd.data = read_xvg_time(dfile, bHaveT,\n                              opt2parg_bSet(\"-b\", NPA, pa), tb,\n                              opt2parg_bSet(\"-e\", NPA, pa), te,\n                              nreplica, &nset_d, &n_d, &dt_d, &remd.time);\n    printf(\"Read %d sets of %d points in %s, dt = %g\\n\\n\", nset_d, n_d, dfile, dt_d);\n\n    if ((nset_t != nset_d) || (n_t != n_d) || (dt_t != dt_d))\n    {\n        gmx_fatal(FARGS, \"Files %s and %s are inconsistent. Check log file\",\n                  tfile, dfile);\n    }\n\n    if (dfile2)\n    {\n        remd.data2 = read_xvg_time(dfile2, bHaveT,\n                                   opt2parg_bSet(\"-b\", NPA, pa), tb,\n                                   opt2parg_bSet(\"-e\", NPA, pa), te,\n                                   nreplica, &nset_d2, &n_d2, &dt_d2, &remd.time);\n        printf(\"Read %d sets of %d points in %s, dt = %g\\n\\n\",\n               nset_d2, n_d2, dfile2, dt_d2);\n        if ((nset_d2 != nset_d) || (n_d != n_d2) || (dt_d != dt_d2))\n        {\n            gmx_fatal(FARGS, \"Files %s and %s are inconsistent. Check log file\",\n                      dfile, dfile2);\n        }\n    }\n    else\n    {\n        remd.data2 = NULL;\n    }\n\n    remd.nreplica  = nset_d;\n    remd.nframe    = n_d;\n    remd.dt        = 1;\n    preprocess_remd(fp, &remd, cutoff, tref, ucut, bBack, Euf, Efu, Ei, t0, t1,\n                    bSum, bDiscrete, nmult);\n\n    optimize_remd_parameters(fp, &remd, maxiter, tol);\n\n    dump_remd_parameters(fp, &remd, opt2fn(\"-o\", NFILE, fnm),\n                         opt2fn_null(\"-o2\", NFILE, fnm),\n                         opt2fn_null(\"-o3\", NFILE, fnm),\n                         opt2fn_null(\"-ee\", NFILE, fnm),\n                         opt2fn(\"-m\", NFILE, fnm), skip, tref, oenv);\n\n    if (bSplit)\n    {\n        printf(\"Splitting set of replicas in two halves\\n\");\n        for (i = 0; (i < remd.nreplica); i++)\n        {\n            remd.bMask[i] = FALSE;\n        }\n        remd.nmask = 0;\n        for (i = 0; (i < remd.nreplica); i += 2)\n        {\n            remd.bMask[i] = TRUE;\n            remd.nmask++;\n        }\n        sum_ft(&remd);\n        optimize_remd_parameters(fp, &remd, maxiter, tol);\n        dump_remd_parameters(fp, &remd, \"test1.xvg\", NULL, NULL, NULL, NULL, skip, tref, oenv);\n\n        for (i = 0; (i < remd.nreplica); i++)\n        {\n            remd.bMask[i] = !remd.bMask[i];\n        }\n        remd.nmask = remd.nreplica - remd.nmask;\n\n        sum_ft(&remd);\n        optimize_remd_parameters(fp, &remd, maxiter, tol);\n        dump_remd_parameters(fp, &remd, \"test2.xvg\", NULL, NULL, NULL, NULL, skip, tref, oenv);\n\n        for (i = 0; (i < remd.nreplica); i++)\n        {\n            remd.bMask[i] = FALSE;\n        }\n        remd.nmask = 0;\n        for (i = 0; (i < remd.nreplica/2); i++)\n        {\n            remd.bMask[i] = TRUE;\n            remd.nmask++;\n        }\n        sum_ft(&remd);\n        optimize_remd_parameters(fp, &remd, maxiter, tol);\n        dump_remd_parameters(fp, &remd, \"test1.xvg\", NULL, NULL, NULL, NULL, skip, tref, oenv);\n\n        for (i = 0; (i < remd.nreplica); i++)\n        {\n            remd.bMask[i] = FALSE;\n        }\n        remd.nmask = 0;\n        for (i = remd.nreplica/2; (i < remd.nreplica); i++)\n        {\n            remd.bMask[i] = TRUE;\n            remd.nmask++;\n        }\n        sum_ft(&remd);\n        optimize_remd_parameters(fp, &remd, maxiter, tol);\n        dump_remd_parameters(fp, &remd, \"test1.xvg\", NULL, NULL, NULL, NULL, skip, tref, oenv);\n    }\n    ffclose(fp);\n\n    view_all(oenv, NFILE, fnm);\n\n    thanx(stderr);\n#else\n    fprintf(stderr, \"This program should be compiled with the GNU scientific library. Please install the library and reinstall GROMACS.\\n\");\n#endif /*HAVE_LIBGSL*/\n\n    return 0;\n}\n", "meta": {"hexsha": "dce1cb7bec0068f6672b7089803cda297135c232", "size": 34615, "ext": "c", "lang": "C", "max_stars_repo_path": "gromacs-4.6.5/src/tools/gmx_kinetics.c", "max_stars_repo_name": "farajilab/gifs_release", "max_stars_repo_head_hexsha": "ffa674110bcd15de851a8b6a703b4f4bc96fcd2d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2022-03-04T18:56:08.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-22T16:49:22.000Z", "max_issues_repo_path": "gromacs-4.6.5/src/tools/gmx_kinetics.c", "max_issues_repo_name": "farajilab/gifs_release", "max_issues_repo_head_hexsha": "ffa674110bcd15de851a8b6a703b4f4bc96fcd2d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "gromacs-4.6.5/src/tools/gmx_kinetics.c", "max_forks_repo_name": "farajilab/gifs_release", "max_forks_repo_head_hexsha": "ffa674110bcd15de851a8b6a703b4f4bc96fcd2d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2022-02-08T00:11:00.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-08T00:11:00.000Z", "avg_line_length": 31.9621421976, "max_line_length": 151, "alphanum_fraction": 0.4635273725, "num_tokens": 10576, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.2509127980882971, "lm_q2_score": 0.017442487864607472, "lm_q1q2_score": 0.0043765434357298265}}
{"text": "/*\r\n * Copyright (c) 2016-2021 lymastee, All rights reserved.\r\n * Contact: lymastee@hotmail.com\r\n *\r\n * This file is part of the gslib project.\r\n * \r\n * Permission is hereby granted, free of charge, to any person obtaining a copy\r\n * of this software and associated documentation files (the \"Software\"), to deal\r\n * in the Software without restriction, including without limitation the rights\r\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r\n * copies of the Software, and to permit persons to whom the Software is\r\n * furnished to do so, subject to the following conditions:\r\n * \r\n * The above copyright notice and this permission notice shall be included in all\r\n * copies or substantial portions of the Software.\r\n * \r\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r\n * SOFTWARE.\r\n */\r\n\r\n#pragma once\r\n\r\n#ifndef avl_6c9ab2d0_f8bc_4fb1_bc21_7fc0c6eb4bec_h\r\n#define avl_6c9ab2d0_f8bc_4fb1_bc21_7fc0c6eb4bec_h\r\n\r\n#include <assert.h>\r\n#include <gslib/std.h>\r\n\r\n__gslib_begin__\r\n\r\nstruct _avltree_trait_copy {};\r\nstruct _avltree_trait_detach {};\r\n\r\ntemplate<class _ty>\r\nstruct _avltreenode_cpy_wrapper\r\n{\r\n    typedef _ty value;\r\n    typedef _avltreenode_cpy_wrapper<_ty> myref;\r\n    typedef _avltree_trait_copy tsf_behavior;\r\n\r\n    value               _value;\r\n    myref*              _left;\r\n    myref*              _right;\r\n    myref*              _parent;\r\n    int                 _balance;\r\n\r\n    myref()\r\n    {\r\n        _left = _right = _parent = nullptr;\r\n        _balance = 0;\r\n    }\r\n    value* get_ptr() { return &_value; }\r\n    const value* const_ptr() const { return &_value; }\r\n    value& get_ref() { return _value; }\r\n    const value& const_ref() const { return _value; }\r\n    void born() {}\r\n    void kill() {}\r\n    template<class _ctor>\r\n    void born() {}\r\n    template<class _ctor>\r\n    void kill() {}\r\n    void copy(const myref* a) { get_ref() = a->const_ref(); }\r\n    void attach(myref* a) { assert(0); }\r\n    void swap_data(myref* a) { std::swap(_value, a->_value); }\r\n};\r\n\r\ntemplate<class _ty>\r\nstruct _avltreenode_wrapper\r\n{\r\n    typedef _ty value;\r\n    typedef _avltreenode_wrapper<_ty> myref;\r\n    typedef _avltree_trait_detach tsf_behavior;\r\n\r\n    value*              _value;\r\n    myref*              _left;\r\n    myref*              _right;\r\n    myref*              _parent;\r\n    int                 _balance;\r\n\r\n    myref()\r\n    {\r\n        _left = _right = _parent = nullptr;\r\n        _value = nullptr;\r\n        _balance = 0;\r\n    }\r\n    value* get_ptr() { return _value; }\r\n    const value* const_ptr() const { return _value; }\r\n    value& get_ref() { return *_value; }\r\n    const value& const_ref() const { return *_value; }\r\n    void copy(const myref* a) { get_ref() = a->const_ref(); }\r\n    void born() { !! }\r\n    template<class _ctor>\r\n    void born() { _value = new _ctor; }\r\n    void kill() { if(_value) { delete _value; _value = nullptr; } }\r\n    template<class _ctor>\r\n    void kill() { if(_value) { delete _value; _value = nullptr; } }\r\n    void attach(myref* a)\r\n    {\r\n        assert(a && a->_value);\r\n        kill();\r\n        _value = a->_value;\r\n        a->_value = nullptr;\r\n    }\r\n    void swap_data(myref* a) { gs_swap(_value, a->_value); }\r\n};\r\n\r\ntemplate<class _wrapper>\r\nstruct _avltree_allocator\r\n{\r\n    typedef _wrapper wrapper;\r\n    static wrapper* born() { return new wrapper; }\r\n    static void kill(wrapper* w) { delete w; }\r\n};\r\n\r\ntemplate<class _val>\r\nstruct _avltreenode_val\r\n{\r\n    typedef _val value;\r\n    typedef const _val const_value;\r\n    typedef _avltreenode_val<_val> myref;\r\n\r\n    union\r\n    {\r\n        value*          _vptr;\r\n        const_value*    _cvptr;\r\n    };\r\n\r\n    myref() { _vptr = nullptr; }\r\n    value* get_wrapper() const { return _vptr; }\r\n    operator bool() const { return _vptr != nullptr; }\r\n    bool is_left() const { return (_cvptr && _cvptr->_parent) ? _cvptr->_parent->_left == _cvptr : false; }\r\n    bool is_right() const { return (_cvptr && _cvptr->_parent) ? _cvptr->_parent->_right == _cvptr : false; }\r\n    bool is_root() const { return _cvptr ? (!_cvptr->_parent) : false; }\r\n    bool is_leaf() const { return _cvptr ? (!_cvptr->_left && !_cvptr->_right) : false; }\r\n    int up_depth() const\r\n    {\r\n        int depth = 0;\r\n        for(value* p = _vptr; p; p = p->_parent, depth ++);\r\n        return depth;\r\n    }\r\n    int down_depth() const { return _down_depth(_vptr, 0); }\r\n    bool operator==(const value* v) const { return _vptr == v; }\r\n    bool operator!=(const value* v) const { return _vptr != v; }\r\n    int get_balance() const { return _vptr->_balance; }\r\n    void set_balance(int b) { _vptr->_balance = b; }\r\n    void swap_data(myref& a) { _vptr->swap_data(a._vptr); }\r\n\r\npublic:\r\n    static void connect_left_child(value* p, value* l)\r\n    {\r\n        assert(p);\r\n        p->_left = l;\r\n        if(l)\r\n            l->_parent = p;\r\n    }\r\n    static void connect_right_child(value* p, value* r)\r\n    {\r\n        assert(p);\r\n        p->_right = r;\r\n        if(r)\r\n            r->_parent = p;\r\n    }\r\n    static bool disconnect_parent_child(value* p, value* c)\r\n    {\r\n        assert(p && c && (c->_parent == p));\r\n        if(p->_left == c) {\r\n            p->_left = c->_parent = nullptr;\r\n            return true;\r\n        }\r\n        assert(p->_right == c);\r\n        p->_right = c->_parent = nullptr;\r\n        return false;\r\n    }\r\n\r\nprivate:\r\n    static int _down_depth(value* v, int ctr)\r\n    {\r\n        if(v == nullptr)\r\n            return ctr;\r\n        ctr ++;\r\n        return gs_max(_down_depth(v->_left, ctr), \r\n            _down_depth(v->_right, ctr)\r\n            );\r\n    }\r\n\r\nprotected:\r\n    value* vleft() const { return _vptr ? _vptr->_left : nullptr; }\r\n    value* vright() const { return _vptr ? _vptr->_right : nullptr; }\r\n    value* vparent() const { return _vptr ? _vptr->_parent : nullptr; }\r\n    value* vsibling() const\r\n    {\r\n        if(!_vptr || !_vptr->_parent)\r\n            return nullptr;\r\n        if(is_left())\r\n            return _vptr->_right;\r\n        else if(is_right())\r\n            return _vptr->_left;\r\n        assert(!\"unexpected.\");\r\n        return nullptr;\r\n    }\r\n    value* vroot() const\r\n    {\r\n        if(!_vptr)\r\n            return nullptr;\r\n        value* p = _vptr;\r\n        for( ; p->_parent; p = p->_parent);\r\n        return p;\r\n    }\r\n\r\nprotected:\r\n    template<class _lambda, class _value>\r\n    static void preorder_traversal(_lambda lam, _value* v)\r\n    {\r\n        assert(v);\r\n        lam(v);\r\n        if(v->_left)\r\n            preorder_traversal(lam, v->_left);\r\n        if(v->_right)\r\n            preorder_traversal(lam, v->_right);\r\n    }\r\n    template<class _lambda, class _value>\r\n    static void inorder_traversal(_lambda lam, _value* v)\r\n    {\r\n        assert(v);\r\n        if(v->_left)\r\n            inorder_traversal(lam, v->_left);\r\n        lam(v);\r\n        if(v->_right)\r\n            inorder_traversal(lam, v->_right);\r\n    }\r\n    template<class _lambda, class _value>\r\n    static void postorder_traversal(_lambda lam, _value* v)\r\n    {\r\n        assert(v);\r\n        if(v->_left)\r\n            postorder_traversal(lam, v->_left);\r\n        if(v->_right)\r\n            postorder_traversal(lam, v->-right);\r\n        lam(v);\r\n    }\r\n\r\npublic:\r\n    template<class _lambda>\r\n    void inorder_traversal(_lambda lam) { if(_vptr) inorder_traversal(lam, _vptr); }\r\n    template<class _lambda>\r\n    void inorder_traversal(_lambda lam) const { if(_cvptr) inorder_traversal(lam, _cvptr); }\r\n    template<class _lambda>\r\n    void preorder_traversal(_lambda lam) { if(_vptr) preorder_traversal(lam, _vptr); }\r\n    template<class _lambda>\r\n    void preorder_traversal(_lambda lam) const { if(_cvptr) preorder_traversal(lam, _cvptr); }\r\n    template<class _lambda>\r\n    void postorder_traversal(_lambda lam) { if(_vptr) postorder_traversal(lam, _vptr); }\r\n    template<class _lambda>\r\n    void postorder_traversal(_lambda lam) const { if(_cvptr) postorder_traversal(lam, _cvptr); }\r\n};\r\n\r\ntemplate<class _ty,\r\n    class _wrapper = _avltreenode_cpy_wrapper<_ty> >\r\nclass _avltree_const_iterator:\r\n    public _avltreenode_val<_wrapper>\r\n{\r\npublic:\r\n    typedef _ty value;\r\n    typedef _wrapper wrapper;\r\n    typedef _avltree_const_iterator<_ty, _wrapper> iterator;\r\n\r\npublic:\r\n    iterator(const wrapper* w = nullptr) { _cvptr = w; }\r\n    bool is_valid() const { return _cvptr != nullptr; }\r\n    const value* get_ptr() const { return _cvptr->const_ptr(); }\r\n    const value* operator->() const { return _cvptr->const_ptr(); }\r\n    const value& operator*() const { return _cvptr->const_ref(); }\r\n    iterator left() const { return iterator(vleft()); }\r\n    iterator right() const { return iterator(vright()); }\r\n    iterator parent() const { return iterator(vparent()); }\r\n    iterator sibling() const { return iterator(vsibling()); }\r\n    iterator root() const { return iterator(vroot()); }\r\n    bool operator==(const iterator& that) const { return _cvptr == that._cvptr; }\r\n    bool operator!=(const iterator& that) const { return _cvptr != that._cvptr; }\r\n};\r\n\r\ntemplate<class _ty,\r\n    class _wrapper = _avltreenode_cpy_wrapper<_ty> >\r\nclass _avltree_iterator:\r\n    public _avltree_const_iterator<_ty, _wrapper>\r\n{\r\npublic:\r\n    typedef _ty value;\r\n    typedef _wrapper wrapper;\r\n    typedef _avltree_const_iterator<_ty, _wrapper> const_iterator;\r\n    typedef _avltree_const_iterator<_ty, _wrapper> superref;\r\n    typedef _avltree_iterator<_ty, _wrapper> iterator;\r\n\r\npublic:\r\n    iterator(wrapper* w): superref(w) {}\r\n    value* get_ptr() const { return _vptr->get_ptr(); }\r\n    value* operator->() const { return _vptr->get_ptr(); }\r\n    value& operator*() const { return _vptr->get_ref(); }\r\n    bool operator==(const iterator& that) const { return _vptr == that._vptr; }\r\n    bool operator!=(const iterator& that) const { return _vptr != that._vptr; }\r\n    bool operator==(const const_iterator& that) const { return _vptr == that._vptr; }\r\n    bool operator!=(const const_iterator& that) const { return _vptr != that._vptr; }\r\n    operator const_iterator() { return const_iterator(_cvptr); }\r\n    void to_root() { _vptr = vroot(); }\r\n    void to_left() { _vptr = vleft(); }\r\n    void to_right() { _vptr = vright(); }\r\n    void to_sibling() { _vptr = vsibling(); }\r\n    void to_parent() { _vptr = vparent(); }\r\n    iterator left() const { return iterator(vleft()); }\r\n    iterator right() const { return iterator(vright()); }\r\n    iterator parent() const { return iterator(vparent()); }\r\n    iterator sibling() const { return iterator(vsibling()); }\r\n    iterator root() const { return iterator(vroot()); }\r\n};\r\n\r\ntemplate<class _ty,\r\n    class _wrapper = _avltreenode_cpy_wrapper<_ty>,\r\n    class _alloc = _avltree_allocator<_wrapper> >\r\nclass avltree:\r\n    public _avltreenode_val<_wrapper>\r\n{\r\npublic:\r\n    typedef _ty value;\r\n    typedef _wrapper wrapper;\r\n    typedef _alloc alloc;\r\n    typedef avltree<value, wrapper, alloc> myref;\r\n    typedef _avltree_const_iterator<_ty, _wrapper> const_iterator;\r\n    typedef _avltree_iterator<_ty, _wrapper> iterator;\r\n\r\npublic:\r\n    avltree() { _vptr = nullptr; }\r\n    ~avltree() { clear(); }\r\n    void clear() { destroy(get_root()); }\r\n    void destroy(iterator i)\r\n    {\r\n        if(!i.is_valid())\r\n            return;\r\n        if(iterator p = i.parent())\r\n            disconnect_parent_child(p.get_wrapper(), i.get_wrapper());\r\n        else {\r\n            assert(is_root(i));\r\n            _vptr = nullptr;\r\n        }\r\n        _destroy(i);\r\n    }\r\n    void adopt(wrapper* w)\r\n    {\r\n        assert(!_vptr && \"use attach method.\");\r\n        _vptr = w;\r\n    }\r\n    iterator get_root() const { return iterator(_vptr); }\r\n    const_iterator const_root() const { return const_iterator(_cvptr); }\r\n    bool is_root(iterator i) const { return i.is_valid() ? (_cvptr == i.get_wrapper()) : false; }\r\n    bool is_valid() const { return _cvptr != nullptr; }\r\n    bool is_mine(iterator i) const\r\n    {\r\n        if(!i.is_valid())\r\n            return false;\r\n        i.to_root();\r\n        return i.get_wrapper() == _vptr;\r\n    }\r\n    int depth() const { return _cvptr->down_depth(); }\r\n    void swap(myref& that) { gs_swap(_vptr, that._vptr); }\r\n    iterator find(const value& v) const { return find(get_root(), v); }\r\n    iterator find(iterator i, const value& v) const\r\n    {\r\n        if(!i) {\r\n            if(!is_valid())\r\n                return i;\r\n            i = get_root();\r\n        }\r\n        assert(i);\r\n        if(v == *i)\r\n            return i;\r\n        iterator n = (v < *i) ? i.left() : i.right();\r\n        return n ? find(n, v) : i;\r\n    }\r\n    template<class _ctor = value>\r\n    iterator insert(const value& v)\r\n    {\r\n        iterator i = get_root();\r\n        return !i ? _init<_ctor>(v) : _insert<_ctor>(i, v);\r\n    }\r\n    void erase(iterator i)\r\n    {\r\n        assert(i && is_mine(i));\r\n        if(i.is_leaf()) {\r\n            iterator p = i.parent();\r\n            if(p) {\r\n                disconnect_parent_child(p.get_wrapper(), i.get_wrapper());\r\n                _destroy(i);\r\n                _balance_erase(p);\r\n                return;\r\n            }\r\n            else {\r\n                assert(is_root(i));\r\n                _destroy(i);\r\n                _vptr = nullptr;\r\n                return;\r\n            }\r\n        }\r\n        if(i.left()) {\r\n            if(i.right()) {     /* left & right */\r\n                iterator l = i.left();\r\n                iterator li = l;\r\n                for(; li.right(); li.to_right());\r\n                iterator lil = li.left();\r\n                i.swap_data(li);\r\n                if(lil) {\r\n                    li.swap_data(lil);\r\n                    destroy(lil);\r\n                    _balance_erase(li);\r\n                    return;\r\n                }\r\n                else {\r\n                    iterator q = li.parent();\r\n                    assert(q);\r\n                    destroy(li);\r\n                    _balance_erase(q);\r\n                    return;\r\n                }\r\n            }\r\n            else {      /* only left */\r\n                if(i.parent()) {\r\n                    myref t;\r\n                    iterator j = attach(detach(t, i.left()), i);\r\n                    j.set_balance(i.get_balance());\r\n                    _balance_erase(j);\r\n                    return;\r\n                }\r\n                else {\r\n                    myref t;\r\n                    swap(detach(t, i.left()));\r\n                    return;\r\n                }\r\n            }\r\n        }\r\n        else {\r\n            assert(i.right());      /* only right */\r\n            if(i.parent()) {\r\n                myref t;\r\n                iterator j = attach(detach(t, i.right()), i);\r\n                j.set_balance(i.get_balance());\r\n                _balance_erase(j);\r\n                return;\r\n            }\r\n            else {\r\n                myref t;\r\n                swap(detach(t, i.right()));\r\n                return;\r\n            }\r\n        }\r\n    }\r\n    void erase(const value& v)\r\n    {\r\n        if(iterator i = find(v))\r\n            erase(i);\r\n    }\r\n\r\n    /* The detach and attach methods, provide subtree operations */\r\n    myref& detach(myref& subtree, iterator i)\r\n    {\r\n        assert(i && is_mine(i));\r\n        if(subtree.is_valid())\r\n            subtree.clear();\r\n        detach<myref>(subtree, i);\r\n        return subtree;\r\n    }\r\n    template<class _cont>\r\n    void detach(_cont& cont)\r\n    {\r\n        cont.adopt(_vptr);\r\n        _vptr = nullptr;\r\n    }\r\n    template<class _cont>\r\n    void detach(_cont& cont, iterator i)\r\n    {\r\n        assert(i && is_mine(i));\r\n        if(i == get_root())\r\n            return detach(cont);\r\n        iterator p = i.parent();\r\n        assert(p);\r\n        disconnect_parent_child(p.get_wrapper(), i.get_wrapper());\r\n        cont.adopt(i.get_wrapper());\r\n    }\r\n    iterator attach(myref& subtree, iterator i)\r\n    {\r\n        assert(i && is_mine(i) && i.is_leaf());\r\n        if(i.is_root()) {\r\n            swap(subtree);\r\n            return get_root();\r\n        }\r\n        iterator p = i.parent();\r\n        assert(p);\r\n        bool leftp = disconnect_parent_child(p.get_wrapper(), i.get_wrapper());\r\n        gs_swap(subtree._vptr, i._vptr);\r\n        leftp ? connect_left_child(p.get_wrapper(), i.get_wrapper()) :\r\n            connect_right_child(p.get_wrapper(), i.get_wrapper());\r\n        subtree.clear();\r\n        return i;\r\n    }\r\n\r\npublic:\r\n    template<class _lambda>\r\n    void preorder_for_each(_lambda lam) { preorder_traversal([](wrapper* w) { lam(w->get_ptr()); }); }\r\n    template<class _lambda>\r\n    void preorder_const_for_each(_lambda lam) const { preorder_traversal([](const wrapper* w) { lam(w->const_ptr()); }); }\r\n    template<class _lambda>\r\n    void inorder_for_each(_lambda lam) { inorder_traversal([](wrapper* w) { lam(w->get_ptr()); }); }\r\n    template<class _lambda>\r\n    void inorder_const_for_each(_lambda lam) const { inorder_traversal([](const wrapper* w) { lam(w->const_ptr()); }); }\r\n    template<class _lambda>\r\n    void postorder_for_each(_lambda lam) { postorder_traversal([](wrapper* w) { lam(w->get_ptr()); }); }\r\n    template<class _lambda>\r\n    void postorder_const_for_each(_lambda lam) const { postorder_traversal([](const wrapper* w) { lam(w->const_ptr()); }); }\r\n\r\nprotected:\r\n    void _destroy(iterator i)\r\n    {\r\n        if(!i.is_valid())\r\n            return;\r\n        _destroy(i.left());\r\n        _destroy(i.right());\r\n        wrapper* w = i.get_wrapper();\r\n        w->kill();\r\n        alloc::kill(w);\r\n    }\r\n    template<class _ctor>\r\n    iterator _insert(iterator i, const value& v)\r\n    {\r\n        assert(i);\r\n        if(v == *i)\r\n            return iterator(nullptr);     /* failed */\r\n        if(v < *i) {\r\n            if(i.left())\r\n                return _insert<_ctor>(i.left(), v);\r\n            iterator j = _add_left<_ctor>(i, v);\r\n            _balance_insert(j);\r\n            return j;\r\n        }\r\n        else {\r\n            if(i.right())\r\n                return _insert<_ctor>(i.right(), v);\r\n            iterator j = _add_right<_ctor>(i, v);\r\n            _balance_insert(j);\r\n            return j;\r\n        }\r\n    }\r\n    void _balance_insert(iterator i)\r\n    {\r\n        assert(i);\r\n        iterator p = i.parent();\r\n        if(!p)\r\n            return;\r\n        if(i.is_left()) {\r\n            switch(p.get_balance())\r\n            {\r\n            case -1:\r\n                (i.get_balance() == 1) ?\r\n                    _left_right_rotate(p) :\r\n                    _right_rotate(p);\r\n                break;\r\n            case 0:\r\n                p.set_balance(-1);\r\n                return _balance_insert(p);\r\n            case 1:\r\n                p.set_balance(0);\r\n                break;\r\n            default:\r\n                assert(!\"unexpected.\");\r\n                break;\r\n            }\r\n        }\r\n        else {\r\n            switch(p.get_balance())\r\n            {\r\n            case -1:\r\n                p.set_balance(0);\r\n                break;\r\n            case 0:\r\n                p.set_balance(1);\r\n                return _balance_insert(p);\r\n            case 1:\r\n                (i.get_balance() == -1) ?\r\n                    _right_left_rotate(p) :\r\n                    _left_rotate(p);\r\n                break;\r\n            default:\r\n                assert(!\"unexpected.\");\r\n                break;\r\n            }\r\n        }\r\n    }\r\n    void _balance_erase(iterator i)\r\n    {\r\n        assert(i);\r\n        int b = i.get_balance();\r\n        if(!b) {\r\n            i.set_balance(i.left() ? -1 : 1);\r\n            return;\r\n        }\r\n        if(!i.left()) {\r\n            if(b == -1)\r\n                i.set_balance(0);\r\n            else if(b == 1) {\r\n                iterator r = i.right();\r\n                if(!r)\r\n                    i.set_balance(0);\r\n                else {\r\n                    (r.get_balance() == -1) ?\r\n                        _right_left_rotate(i) :\r\n                        _left_rotate(i);\r\n                    i.to_parent();\r\n                    if(i.get_balance() == -1)\r\n                        return;\r\n                }\r\n            }\r\n            else {\r\n                assert(!\"unexpected.\");\r\n            }\r\n        }\r\n        else if(!i.right()) {\r\n            if(b == 1)\r\n                i.set_balance(0);\r\n            else if(b == -1) {\r\n                iterator l = i.left();\r\n                if(!l)\r\n                    i.set_balance(0);\r\n                else {\r\n                    (l.get_balance() == 1) ?\r\n                        _left_right_rotate(i) :\r\n                        _right_rotate(i);\r\n                    i.to_parent();\r\n                    if(i.get_balance() == 1)\r\n                        return;\r\n                }\r\n            }\r\n            else {\r\n                assert(!\"unexpected.\");\r\n            }\r\n        }\r\n        _balance_erase_(i);\r\n    }\r\n    void _balance_erase_(iterator i)\r\n    {\r\n        assert(i);\r\n        iterator p = i.parent();\r\n        if(!p)\r\n            return;\r\n        if(i.is_left()) {\r\n            switch(p.get_balance())\r\n            {\r\n            case -1:\r\n                p.set_balance(0);\r\n                return _balance_erase_(p);\r\n            case 0:\r\n                p.set_balance(1);\r\n                break;\r\n            case 1:\r\n                (p.right().get_balance() == -1) ?\r\n                    _right_left_rotate(p) :\r\n                    _left_rotate(p);\r\n                if(p.parent().get_balance() != -1)\r\n                    return _balance_erase_(p.parent());\r\n                break;\r\n            default:\r\n                assert(!\"unexpected.\");\r\n                break;\r\n            }\r\n        }\r\n        else {\r\n            switch(p.get_balance())\r\n            {\r\n            case -1:\r\n                (p.left().get_balance() == 1) ?\r\n                    _left_right_rotate(p) :\r\n                    _right_rotate(p);\r\n                if(p.parent().get_balance() != 1)\r\n                    return _balance_erase_(p.parent());\r\n                break;\r\n            case 0:\r\n                p.set_balance(-1);\r\n                break;\r\n            case 1:\r\n                p.set_balance(0);\r\n                return _balance_erase_(p);\r\n            default:\r\n                assert(!\"unexpected.\");\r\n                break;\r\n            }\r\n        }\r\n    }\r\n    iterator _left_rotate(iterator i)\r\n    {\r\n        assert(i && i.right());\r\n        iterator p = i.parent();\r\n        iterator r = i.right();\r\n        iterator rl = r.left();\r\n        if(p) {\r\n            i.is_left() ? connect_left_child(p.get_wrapper(), r.get_wrapper()) :\r\n                connect_right_child(p.get_wrapper(), r.get_wrapper());\r\n        }\r\n        else {\r\n            _vptr = r.get_wrapper();\r\n            _vptr->_parent = nullptr;\r\n        }\r\n        connect_left_child(r.get_wrapper(), i.get_wrapper());\r\n        connect_right_child(i.get_wrapper(), rl.get_wrapper());\r\n        if(r.get_balance() == 0) {\r\n            i.set_balance(1);\r\n            r.set_balance(-1);\r\n        }\r\n        else {\r\n            i.set_balance(0);\r\n            r.set_balance(0);\r\n        }\r\n        return r;\r\n    }\r\n    iterator _right_rotate(iterator i)\r\n    {\r\n        assert(i && i.left());\r\n        iterator p = i.parent();\r\n        iterator l = i.left();\r\n        iterator lr = l.right();\r\n        if(p) {\r\n            i.is_left() ? connect_left_child(p.get_wrapper(), l.get_wrapper()) :\r\n                connect_right_child(p.get_wrapper(), l.get_wrapper());\r\n        }\r\n        else {\r\n            _vptr = l.get_wrapper();\r\n            _vptr->_parent = nullptr;\r\n        }\r\n        connect_right_child(l.get_wrapper(), i.get_wrapper());\r\n        connect_left_child(i.get_wrapper(), lr.get_wrapper());\r\n        if(l.get_balance() == 0) {\r\n            i.set_balance(-1);\r\n            l.set_balance(1);\r\n        }\r\n        else {\r\n            i.set_balance(0);\r\n            l.set_balance(0);\r\n        }\r\n        return l;\r\n    }\r\n    iterator _left_right_rotate(iterator i)\r\n    {\r\n        assert(i && i.left());\r\n        iterator l = i.left();\r\n        iterator lr = l.right();\r\n        assert(lr);\r\n        iterator lrl = lr.left();\r\n        iterator lrr = lr.right();\r\n        iterator p = i.parent();\r\n        if(p) {\r\n            i.is_left() ? connect_left_child(p.get_wrapper(), lr.get_wrapper()) :\r\n                connect_right_child(p.get_wrapper(), lr.get_wrapper());\r\n        }\r\n        else {\r\n            _vptr = lr.get_wrapper();\r\n            _vptr->_parent = nullptr;\r\n        }\r\n        connect_left_child(lr.get_wrapper(), l.get_wrapper());\r\n        connect_right_child(lr.get_wrapper(), i.get_wrapper());\r\n        connect_right_child(l.get_wrapper(), lrl.get_wrapper());\r\n        connect_left_child(i.get_wrapper(), lrr.get_wrapper());\r\n        switch(lr.get_balance())\r\n        {\r\n        case -1:\r\n            i.set_balance(1);\r\n            l.set_balance(0);\r\n            break;\r\n        case 0:\r\n            i.set_balance(0);\r\n            l.set_balance(0);\r\n            break;\r\n        case 1:\r\n            i.set_balance(0);\r\n            l.set_balance(-1);\r\n            break;\r\n        default:\r\n            assert(!\"unexpected.\");\r\n            break;\r\n        }\r\n        lr.set_balance(0);\r\n        return lr;\r\n    }\r\n    iterator _right_left_rotate(iterator i)\r\n    {\r\n        assert(i && i.right());\r\n        iterator r = i.right();\r\n        iterator rl = r.left();\r\n        assert(rl);\r\n        iterator rll = rl.left();\r\n        iterator rlr = rl.right();\r\n        iterator p = i.parent();\r\n        if(p) {\r\n            i.is_left() ? connect_left_child(p.get_wrapper(), rl.get_wrapper()) :\r\n                connect_right_child(p.get_wrapper(), rl.get_wrapper());\r\n        }\r\n        else {\r\n            _vptr = rl.get_wrapper();\r\n            _vptr->_parent = nullptr;\r\n        }\r\n        connect_right_child(rl.get_wrapper(), r.get_wrapper());\r\n        connect_left_child(rl.get_wrapper(), i.get_wrapper());\r\n        connect_right_child(i.get_wrapper(), rll.get_wrapper());\r\n        connect_left_child(r.get_wrapper(), rlr.get_wrapper());\r\n        switch(rl.get_balance())\r\n        {\r\n        case -1:\r\n            i.set_balance(0);\r\n            r.set_balance(1);\r\n            break;\r\n        case 0:\r\n            i.set_balance(0);\r\n            r.set_balance(0);\r\n            break;\r\n        case 1:\r\n            i.set_balance(-1);\r\n            r.set_balance(0);\r\n            break;\r\n        default:\r\n            assert(!\"unexpected.\");\r\n            break;\r\n        }\r\n        rl.set_balance(0);\r\n        return rl;\r\n    }\r\n\r\n    template<class _ctor>\r\n    iterator _init()\r\n    {\r\n        assert(!_vptr);\r\n        _vptr = alloc::born();\r\n        _vptr->born<_ctor>();\r\n        return iterator(_vptr);\r\n    }\r\n    template<class _ctor>\r\n    iterator _init(const value& v)\r\n    {\r\n        assert(!_vptr);\r\n        _vptr = initval<_ctor, wrapper::tsf_behavior>::run(alloc::born(), v);\r\n        assert(_vptr);\r\n        return iterator(_vptr);\r\n    }\r\n    template<class _ctor>\r\n    iterator _add_left(iterator i, const value& v)\r\n    {\r\n        assert(i && !i.left());\r\n        wrapper* n = initval<_ctor, wrapper::tsf_behavior>::run(alloc::born(), v);\r\n        connect_left_child(i.get_wrapper(), n);\r\n        return iterator(n);\r\n    }\r\n    template<class _ctor>\r\n    iterator _add_right(iterator i, const value& v)\r\n    {\r\n        assert(i && !i.right());\r\n        wrapper* n = initval<_ctor, wrapper::tsf_behavior>::run(alloc::born(), v);\r\n        connect_right_child(i.get_wrapper(), n);\r\n        return iterator(n);\r\n    }\r\n    void _modified()\r\n    {\r\n#if defined (DEBUG) || defined (_DEBUG)\r\n        debug_check(get_root());\r\n#endif\r\n    }\r\n\r\nprotected:\r\n    friend struct initval;\r\n    template<class _ctor, class _tsftrait>\r\n    struct initval;\r\n    template<class _ctor>\r\n    struct initval<_ctor, _avltree_trait_copy>\r\n    {\r\n        static wrapper* run(wrapper* w, const value& v)\r\n        {\r\n            assert(w);\r\n            w->get_ref() = v;\r\n            return w;\r\n        }\r\n    };\r\n    template<class _ctor>\r\n    struct initval<_ctor, _avltree_trait_detach>\r\n    {\r\n        static wrapper* run(wrapper* w, const value& v)\r\n        {\r\n            assert(w);\r\n            w->_value = &v;     /* or duplicate? */\r\n            return w;\r\n        }\r\n    };\r\n\r\npublic:\r\n    bool debug_check(iterator i)\r\n    {\r\n        if(!i)\r\n            return true;\r\n        check_root(i);\r\n        check_linkage(i);\r\n        check_order(i);\r\n        check_balance(i);\r\n        iterator l = i.left(), r = i.right();\r\n        if(!(l && debug_check(l)))\r\n            return false;\r\n        if(!(r && debug_check(r)))\r\n            return false;\r\n        return true;\r\n    }\r\n    bool check_root(iterator i)\r\n    {\r\n        assert(i);\r\n        if(is_root(i)) {\r\n            assert(!i.parent() && \"root has no parent.\");\r\n            return true;\r\n        }\r\n        assert(i.parent() && \"non-root must have parent.\");\r\n        return false;\r\n    }\r\n    void check_linkage(iterator i)\r\n    {\r\n        assert(i);\r\n        iterator l = i.left(), r = i.right();\r\n        if(l) { assert(l.parent() == i && \"left link wrong.\"); }\r\n        if(r) { assert(r.parent() == i && \"right link wrong.\"); }\r\n    }\r\n    void check_order(iterator i)\r\n    {\r\n        assert(i);\r\n        iterator l = i.left(), r = i.right();\r\n        if(l) {\r\n            iterator lm = l;\r\n            for(; lm.right(); lm = lm.right());\r\n            assert(*lm < *i && \"left order wrong.\");\r\n        }\r\n        if(r) {\r\n            iterator rm = r;\r\n            for(; rm.left(); rm = rm.left());\r\n            assert(*i < *rm && \"right order wrong.\");\r\n        }\r\n    }\r\n    void check_balance(iterator i)\r\n    {\r\n        assert(i);\r\n        iterator l = i.left(), r = i.right();\r\n        int h1 = 0, h2 = 0;\r\n        if(l) h1 = l.down_depth();\r\n        if(r) h2 = r.down_depth();\r\n        int b = i.get_balance();\r\n        assert(b == h2 - h1 && \"balance wrong.\");\r\n    }\r\n};\r\n\r\n__gslib_end__\r\n\r\n#endif\r\n", "meta": {"hexsha": "07a831cc8933e11be84b3b1da84a99bcaa0cd551", "size": 30346, "ext": "h", "lang": "C", "max_stars_repo_path": "include/gslib/avl.h", "max_stars_repo_name": "lymastee/gslib", "max_stars_repo_head_hexsha": "1b165b7a812526c4b2a3179588df9a7c2ff602a6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 9.0, "max_stars_repo_stars_event_min_datetime": "2016-10-18T09:40:09.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-11T09:44:51.000Z", "max_issues_repo_path": "include/gslib/avl.h", "max_issues_repo_name": "lymastee/gslib", "max_issues_repo_head_hexsha": "1b165b7a812526c4b2a3179588df9a7c2ff602a6", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/gslib/avl.h", "max_forks_repo_name": "lymastee/gslib", "max_forks_repo_head_hexsha": "1b165b7a812526c4b2a3179588df9a7c2ff602a6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2016-10-19T15:20:58.000Z", "max_forks_repo_forks_event_max_datetime": "2016-10-19T15:20:58.000Z", "avg_line_length": 31.5446985447, "max_line_length": 125, "alphanum_fraction": 0.5044486918, "num_tokens": 7006, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.12085324515618749, "lm_q2_score": 0.03410042890256554, "lm_q1q2_score": 0.0041211474940928946}}
{"text": "/*\nCopyright (c) 2015, Patrick Weltevrede\nAll rights reserved.\n\nRedistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:\n\n1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.\n\n2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.\n\n3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.\n\nTHIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n\n#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <gsl/gsl_sort_float.h>\n#include <gsl/gsl_statistics_float.h>\n#include <gsl/gsl_integration.h>\n#include \"psrsalsa.h\"\nint filterPApoints(datafile_definition *datafile, verbose_definition verbose)\n{\n  int dPa_polnr;\n  long i, j, nrpoints;\n  float *olddata;\n  if(datafile->poltype != POLTYPE_ILVPAdPA && datafile->poltype != POLTYPE_PAdPA && datafile->poltype != POLTYPE_ILVPAdPATEldEl) {\n    printerror(verbose.debug, \"ERROR filterPApoints: Data doesn't appear to have poltype ILVPAdPA, PAdPA or ILVPAdPATEldEl.\");\n    return 0;\n  }\n  if(datafile->poltype == POLTYPE_ILVPAdPA && datafile->NrPols != 5) {\n    printerror(verbose.debug, \"ERROR filterPApoints: 5 polarization channels were expected, but there are only %ld.\", datafile->NrPols);\n    return 0;\n  }else if(datafile->poltype == POLTYPE_ILVPAdPATEldEl && datafile->NrPols != 8) {\n    printerror(verbose.debug, \"ERROR filterPApoints: 8 polarization channels were expected, but there are only %ld.\", datafile->NrPols);\n    return 0;\n  }else if(datafile->poltype == POLTYPE_PAdPA && datafile->NrPols != 2) {\n    printerror(verbose.debug, \"ERROR filterPApoints: 2 polarization channels were expected, but there are only %ld.\", datafile->NrPols);\n    return 0;\n  }\n  if(datafile->NrSubints > 1 || datafile->NrFreqChan > 1) {\n    printerror(verbose.debug, \"ERROR filterPApoints: Can only do this opperation if there is one subint and one frequency channel.\");\n    return 0;\n  }\n  if(datafile->tsampMode != TSAMPMODE_LONGITUDELIST) {\n    printerror(verbose.debug, \"ERROR filterPApoints: Expected pulse longitudes to be defined.\");\n    return 0;\n  }\n  if(datafile->poltype == POLTYPE_ILVPAdPA || datafile->poltype == POLTYPE_ILVPAdPATEldEl) {\n    dPa_polnr = 4;\n  }else if(datafile->poltype == POLTYPE_PAdPA) {\n    dPa_polnr = 1;\n  }\n  nrpoints = 0;\n  for(i = 0; i < datafile->NrBins; i++) {\n    if(datafile->data[i+dPa_polnr*datafile->NrBins] > 0) {\n      nrpoints++;\n    }\n  }\n  if(verbose.verbose)\n    printf(\"Keeping %ld significant PA points\\n\", nrpoints);\n  olddata = datafile->data;\n  datafile->data = (float *)malloc(nrpoints*datafile->NrPols*sizeof(float));\n  if(datafile->data == NULL) {\n    printerror(verbose.debug, \"ERROR filterPApoints: Memory allocation error.\");\n    return 0;\n  }\n  j = 0;\n  for(i = 0; i < datafile->NrBins; i++) {\n    if(olddata[i+dPa_polnr*datafile->NrBins] > 0) {\n      if(datafile->poltype == POLTYPE_ILVPAdPA) {\n datafile->data[j+0*nrpoints] = olddata[i+0*datafile->NrBins];\n datafile->data[j+1*nrpoints] = olddata[i+1*datafile->NrBins];\n datafile->data[j+2*nrpoints] = olddata[i+2*datafile->NrBins];\n datafile->data[j+3*nrpoints] = olddata[i+3*datafile->NrBins];\n datafile->data[j+4*nrpoints] = olddata[i+4*datafile->NrBins];\n      }else if(datafile->poltype == POLTYPE_ILVPAdPATEldEl) {\n datafile->data[j+0*nrpoints] = olddata[i+0*datafile->NrBins];\n datafile->data[j+1*nrpoints] = olddata[i+1*datafile->NrBins];\n datafile->data[j+2*nrpoints] = olddata[i+2*datafile->NrBins];\n datafile->data[j+3*nrpoints] = olddata[i+3*datafile->NrBins];\n datafile->data[j+4*nrpoints] = olddata[i+4*datafile->NrBins];\n datafile->data[j+5*nrpoints] = olddata[i+5*datafile->NrBins];\n datafile->data[j+6*nrpoints] = olddata[i+6*datafile->NrBins];\n datafile->data[j+7*nrpoints] = olddata[i+7*datafile->NrBins];\n      }else {\n datafile->data[j+0*nrpoints] = olddata[i+0*datafile->NrBins];\n datafile->data[j+1*nrpoints] = olddata[i+1*datafile->NrBins];\n      }\n      datafile->tsamp_list[j] = datafile->tsamp_list[i];\n      j++;\n    }\n  }\n  free(olddata);\n  datafile->NrBins = nrpoints;\n  return datafile->NrBins;\n}\nint make_paswing_fromIQUV(datafile_definition *datafile, int extended, pulselongitude_regions_definition onpulse, int normalize, int correctLbias, float correctQV, float correctV, int nolongitudes, float loffset, float paoffset, datafile_definition *rms_file, float rebin_factor, verbose_definition verbose)\n{\n  int indent, rms_file_specified;\n  long i, j, NrOffpulseBins, pulsenr, freqnr, output_nr_pols;\n  float ymax, baseline_intensity, RMSQ, RMSU, *Loffpulse, *Poffpulse, medianL, medianP, *newdata, *newdata_rms;\n  rms_file_specified = 1;\n  if(rms_file == NULL) {\n    rms_file = datafile;\n    rms_file_specified = 0;\n  }\n  if(verbose.verbose) {\n    for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n    printf(\"Constructing PA and degree of linear polarization\");\n    if(extended)\n      printf(\", total polarization and ellipticity\");\n    if(rms_file_specified)\n      printf(\" (using a seperate file to determine the off-pulse rms)\");\n    printf(\"\\n\");\n    for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n    printf(\"  Reference frequency for PA is \");\n    if(datafile->isDeFarad) {\n      if((datafile->freq_ref > -1.1 && datafile->freq_ref < -0.9) || (datafile->freq_ref > 0.99e10 && datafile->freq_ref < 1.01e10))\n printf(\"infinity\\n\");\n      else if(datafile->freq_ref < 0)\n printf(\"unknown\\n\");\n      else\n printf(\"%f MHz\\n\", datafile->freq_ref);\n    }else {\n      if(datafile->NrFreqChan == 1)\n printf(\"%lf MHz\\n\", get_centre_frequency(*datafile, verbose));\n      else\n printf(\"observing frequencies of individual frequency channels\\n\");\n    }\n    for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n    printf(\"  \");\n    switch(correctLbias) {\n    case -1: printf(\"No L de-bias applied\"); break;\n    case 0: printf(\"De-bias L using median noise subtraction\"); break;\n    case 1: printf(\"De-bias L using Wardle & Kronberg correction\"); break;\n    default: printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Undefined L de-bias method specified.\"); return 0;\n    }\n    if(correctQV != 1 || correctV != 1)\n      printf(\", Q correction factor %f, V correction factor %f\", 1.0/correctQV, 1.0/(correctQV*correctV));\n    if(normalize)\n      printf(\", output is normalised\");\n    if(loffset != 0)\n      printf(\", pulse longitude shifted by %f deg\\n\", loffset);\n    if(paoffset != 0)\n      printf(\", PA shifted by %f deg\\n\", paoffset);\n    printf(\"\\n\");\n    if(extended) {\n      printwarning(verbose.debug, \"WARNING make_paswing_fromIQUV: Total polarization is computed, and the median off-pulse value is subtracted (probably not a very good idea).\");\n    }\n  }\n  if(datafile->NrPols != 4 || rms_file->NrPols != 4) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Expected 4 input polarizations.\");\n    return 0;\n  }\n  if(datafile->poltype != POLTYPE_STOKES) {\n    if(datafile->poltype == POLTYPE_UNKNOWN) {\n      printwarning(verbose.debug, \"WARNING make_paswing_fromIQUV: Polarization state unknown, it is assumed the data are Stokes parameters.\");\n    }else {\n      printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Convert data into Stokes parameters first.\");\n      return 0;\n    }\n  }\n  if(rms_file_specified) {\n    if(rms_file->poltype != POLTYPE_STOKES) {\n      if(rms_file->poltype == POLTYPE_UNKNOWN) {\n printwarning(verbose.debug, \"WARNING make_paswing_fromIQUV: Polarization state of the data to be used to determine the off-pulse rms is unknown, it is assumed the data are Stokes parameters.\");\n      }else {\n printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Convert data to be used to determine the off-pulse rms into Stokes parameters first.\");\n return 0;\n      }\n    }\n  }\n  if(datafile->tsampMode != TSAMPMODE_FIXEDTSAMP) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Expects input to have a regular sampling.\");\n    return 0;\n  }\n  if(correctQV == 0) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: correctQV is set to zero, you probably want this to be 1.\");\n    return 0;\n  }\n  if(correctV == 0) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: correctV is set to zero, you probably want this to be 1.\");\n    return 0;\n  }\n  if(datafile->isDebase == 0) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Please remove baseline first, i.e. use pmod -debase.\");\n    return 0;\n  }else if(datafile->isDebase != 1) {\n    fflush(stdout);\n    printwarning(verbose.debug, \"WARNING make_paswing_fromIQUV: Unknown baseline state. It is assumed the baseline has already removed from the data.\");\n  }\n  if(rms_file_specified) {\n    if(rms_file->isDebase == 0) {\n      fflush(stdout);\n      printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Please remove baseline first, i.e. use pmod -debase.\");\n      return 0;\n    }else if(rms_file->isDebase != 1) {\n      fflush(stdout);\n      printwarning(verbose.debug, \"WARNING make_paswing_fromIQUV: Unknown baseline state. It is assumed the baseline has already removed from the data.\");\n    }\n  }\n  if(rms_file_specified) {\n    if(datafile->NrSubints != rms_file->NrSubints) {\n      printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Number of subintegrations is different in the data to be used to determine the off-pulse rms.\");\n return 0;\n    }\n    if(datafile->NrFreqChan != rms_file->NrFreqChan) {\n      printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Number of frequency channels is different in the data to be used to determine the off-pulse rms (%ld != %ld).\", rms_file->NrFreqChan, datafile->NrFreqChan);\n return 0;\n    }\n    if(correctLbias == 0) {\n      printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Subtracting the median of L is not supported when a separate file is used for the offpulse statistics.\");\n      return 0;\n    }\n    if(extended) {\n      printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Subtracting the median of P is not supported when a separate file is used for the offpulse statistics.\");\n      return 0;\n    }\n  }\n  if(datafile->offpulse_rms != NULL) {\n    free(datafile->offpulse_rms);\n  }\n  Loffpulse = (float *)malloc((rms_file->NrBins)*sizeof(float));\n  Poffpulse = (float *)malloc((rms_file->NrBins)*sizeof(float));\n  if(extended) {\n    output_nr_pols = 8;\n  }else {\n    output_nr_pols = 5;\n  }\n  newdata = (float *)malloc(datafile->NrBins*datafile->NrSubints*datafile->NrFreqChan*output_nr_pols*sizeof(float));\n  if(rms_file_specified) {\n    newdata_rms = (float *)malloc(rms_file->NrBins*rms_file->NrSubints*rms_file->NrFreqChan*output_nr_pols*sizeof(float));\n  }else {\n    newdata_rms = newdata;\n  }\n  datafile->offpulse_rms = (float *)malloc(datafile->NrSubints*datafile->NrFreqChan*output_nr_pols*sizeof(float));\n  if(Loffpulse == NULL || Poffpulse == NULL || newdata == NULL || datafile->offpulse_rms == NULL || newdata_rms == NULL) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Memory allocation error.\");\n    return 0;\n  }\n  if(nolongitudes == 0) {\n    datafile->tsamp_list = (double *)malloc(datafile->NrBins*sizeof(double));\n    if(datafile->tsamp_list == NULL) {\n      fflush(stdout);\n      printerror(verbose.debug, \"ERROR make_paswing_fromIQUV: Memory allocation error.\");\n      return 0;\n    }\n    for(j = 0; j < (datafile->NrBins); j++) {\n      datafile->tsamp_list[j] = get_pulse_longitude(*datafile, 0, j, verbose);\n      datafile->tsamp_list[j] += loffset;\n    }\n  }\n  if(normalize && (datafile->NrSubints > 1 || datafile->NrFreqChan > 1)) {\n    fflush(stdout);\n    printwarning(verbose.debug, \"WARNING make_paswing_fromIQUV: Normalization will cause all subintegrations/frequency channels to be normalised individually. This may not be desired.\");\n  }\n  long sindex_I, sindex_Q, sindex_U, sindex_V, sindex_I_rms, sindex_Q_rms, sindex_U_rms, sindex_V_rms, newindex_I, newindex_L, newindex_V, newindex_Pa, newindex_dPa, newindex_T, newindex_Ell, newindex_dEll, newindex_L_rms, newindex_T_rms;\n  for(pulsenr = 0; pulsenr < datafile->NrSubints; pulsenr++) {\n    for(freqnr = 0; freqnr < datafile->NrFreqChan; freqnr++) {\n      sindex_I = datafile->NrBins*(0+datafile->NrPols*(freqnr+pulsenr*datafile->NrFreqChan));\n      sindex_Q = datafile->NrBins*(1+datafile->NrPols*(freqnr+pulsenr*datafile->NrFreqChan));\n      sindex_U = datafile->NrBins*(2+datafile->NrPols*(freqnr+pulsenr*datafile->NrFreqChan));\n      sindex_V = datafile->NrBins*(3+datafile->NrPols*(freqnr+pulsenr*datafile->NrFreqChan));\n      newindex_I = datafile->NrBins*(0+output_nr_pols*(freqnr+datafile->NrFreqChan*pulsenr));\n      newindex_L = datafile->NrBins*(1+output_nr_pols*(freqnr+datafile->NrFreqChan*pulsenr));\n      newindex_V = datafile->NrBins*(2+output_nr_pols*(freqnr+datafile->NrFreqChan*pulsenr));\n      newindex_Pa = datafile->NrBins*(3+output_nr_pols*(freqnr+datafile->NrFreqChan*pulsenr));\n      newindex_dPa = datafile->NrBins*(4+output_nr_pols*(freqnr+datafile->NrFreqChan*pulsenr));\n      if(extended) {\n newindex_T = datafile->NrBins*(5+output_nr_pols*(freqnr+datafile->NrFreqChan*pulsenr));\n newindex_Ell = datafile->NrBins*(6+output_nr_pols*(freqnr+datafile->NrFreqChan*pulsenr));\n newindex_dEll = datafile->NrBins*(7+output_nr_pols*(freqnr+datafile->NrFreqChan*pulsenr));\n      }\n      if(rms_file_specified) {\n sindex_I_rms = rms_file->NrBins*(0+rms_file->NrPols*(freqnr+pulsenr*rms_file->NrFreqChan));\n sindex_Q_rms = rms_file->NrBins*(1+rms_file->NrPols*(freqnr+pulsenr*rms_file->NrFreqChan));\n sindex_U_rms = rms_file->NrBins*(2+rms_file->NrPols*(freqnr+pulsenr*rms_file->NrFreqChan));\n sindex_V_rms = rms_file->NrBins*(3+rms_file->NrPols*(freqnr+pulsenr*rms_file->NrFreqChan));\n newindex_L_rms = rms_file->NrBins*(1+output_nr_pols*(freqnr+rms_file->NrFreqChan*pulsenr));\n if(extended) {\n   newindex_T_rms = rms_file->NrBins*(5+output_nr_pols*(freqnr+rms_file->NrFreqChan*pulsenr));\n }\n      }else {\n sindex_I_rms = sindex_I;\n sindex_Q_rms = sindex_Q;\n sindex_U_rms = sindex_U;\n sindex_V_rms = sindex_V;\n newindex_L_rms = newindex_L;\n if(extended) {\n   newindex_T_rms = newindex_T;\n }\n      }\n      if(normalize == 0) {\n ymax = 1;\n      }else {\n ymax = datafile->data[sindex_I];\n for(j = 1; j < (datafile->NrBins); j++) {\n   if(datafile->data[sindex_I+j] > ymax)\n     ymax = datafile->data[sindex_I+j];\n }\n      }\n      if(ymax == 0)\n ymax = 1;\n      for(j = 0; j < (datafile->NrBins); j++) {\n datafile->data[sindex_I + j] /= ymax;\n datafile->data[sindex_Q + j] /= correctQV*ymax;\n datafile->data[sindex_U + j] /= ymax;\n datafile->data[sindex_V + j] /= correctV*correctQV*ymax;\n newdata[j+newindex_L] = sqrt((datafile->data[sindex_Q+j])*(datafile->data[sindex_Q+j])+(datafile->data[sindex_U+j])*(datafile->data[sindex_U+j]));\n if(extended) {\n   newdata[j+newindex_T] = sqrt(newdata[j+newindex_L]*newdata[j+newindex_L]+datafile->data[sindex_V+j]*datafile->data[sindex_V+j]);\n }\n      }\n      if(rms_file_specified) {\n for(j = 0; j < (rms_file->NrBins); j++) {\n   rms_file->data[sindex_I_rms + j] /= ymax;\n   rms_file->data[sindex_Q_rms + j] /= correctQV*ymax;\n   rms_file->data[sindex_U_rms + j] /= ymax;\n   rms_file->data[sindex_V_rms + j] /= correctV*correctQV*ymax;\n   newdata_rms[j+newindex_L_rms] = sqrt((rms_file->data[sindex_Q_rms+j])*(rms_file->data[sindex_Q_rms+j])+(rms_file->data[sindex_U_rms+j])*(rms_file->data[sindex_U_rms+j]));\n   if(extended) {\n     newdata_rms[j+newindex_T_rms] = sqrt(newdata[j+newindex_L_rms]*newdata[j+newindex_L_rms]+rms_file->data[sindex_V_rms+j]*rms_file->data[sindex_V_rms+j]);\n   }\n }\n      }\n      datafile->offpulse_rms[0+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] = 0;\n      datafile->offpulse_rms[1+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] = 0;\n      datafile->offpulse_rms[2+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] = 0;\n      datafile->offpulse_rms[3+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] = -1;\n      datafile->offpulse_rms[4+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] = -1;\n      if(extended) {\n datafile->offpulse_rms[5+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] = 0;\n datafile->offpulse_rms[6+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] = -1;\n datafile->offpulse_rms[7+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] = -1;\n      }\n      baseline_intensity = 0;\n      RMSQ = 0;\n      RMSU = 0;\n      NrOffpulseBins = 0;\n      for(i = 0; i < (rms_file->NrBins); i++) {\n Loffpulse[i] = 0;\n if(checkRegions(i, &onpulse, 0, verbose) == 0) {\n   NrOffpulseBins++;\n   baseline_intensity += rms_file->data[sindex_I_rms+i];\n   RMSQ += (rms_file->data[sindex_Q_rms+i])*(rms_file->data[sindex_Q_rms+i]);\n   RMSU += (rms_file->data[sindex_U_rms+i])*(rms_file->data[sindex_U_rms+i]);\n   datafile->offpulse_rms[0+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] += (rms_file->data[sindex_I_rms+i])*(rms_file->data[sindex_I_rms+i]);\n   datafile->offpulse_rms[1+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] += (newdata_rms[i+newindex_L_rms])*(newdata_rms[i+newindex_L_rms]);\n   datafile->offpulse_rms[2+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] += (rms_file->data[sindex_V_rms+i])*(rms_file->data[sindex_V_rms+i]);\n   if(extended) {\n     datafile->offpulse_rms[5+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] += (newdata_rms[i+newindex_L_rms])*(newdata_rms[i+newindex_L_rms]) + (rms_file->data[sindex_V_rms+i])*(rms_file->data[sindex_V_rms+i]);\n   }\n   Loffpulse[NrOffpulseBins-1] = newdata_rms[i+newindex_L_rms];\n   if(extended)\n     Poffpulse[NrOffpulseBins-1] = newdata_rms[i+newindex_T_rms];\n }\n      }\n      baseline_intensity /= (float)NrOffpulseBins;\n      RMSQ = sqrt(RMSQ/(float)NrOffpulseBins);\n      RMSU = sqrt(RMSU/(float)NrOffpulseBins);\n      datafile->offpulse_rms[0+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] = sqrt(datafile->offpulse_rms[0+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)]/(float)NrOffpulseBins);\n      datafile->offpulse_rms[1+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] = sqrt(datafile->offpulse_rms[1+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)]/(float)NrOffpulseBins);\n      datafile->offpulse_rms[2+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] = sqrt(datafile->offpulse_rms[2+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)]/(float)NrOffpulseBins);\n      if(extended) {\n datafile->offpulse_rms[5+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] = sqrt(datafile->offpulse_rms[5+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)]/(float)NrOffpulseBins);\n      }\n      if(rms_file_specified) {\n float scale = 1.0/sqrt(rebin_factor);\n RMSQ *= scale;\n RMSU *= scale;\n datafile->offpulse_rms[0+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] *= scale;\n datafile->offpulse_rms[1+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] *= scale;\n datafile->offpulse_rms[2+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] *= scale;\n if(extended) {\n   datafile->offpulse_rms[5+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)] *= scale;\n }\n      }\n      if(verbose.verbose) {\n if((freqnr == 0 && pulsenr == 0) || verbose.debug) {\n   for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n   fprintf(stdout, \"  PA conversion output for subint %ld frequency channel %ld:\\n\", pulsenr, freqnr);\n   for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n   fprintf(stdout, \"    Average baseline Stokes I: %f\\n\", baseline_intensity);\n   for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n   fprintf(stdout, \"    RMS I:                  %f\\n\", datafile->offpulse_rms[0+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)]);\n   for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n   fprintf(stdout, \"    RMS Q:                  %f\\n\", RMSQ);\n   for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n   fprintf(stdout, \"    RMS U:                  %f\\n\", RMSU);\n   for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n   fprintf(stdout, \"    RMS V:                  %f\\n\", datafile->offpulse_rms[2+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)]);\n   for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n   fprintf(stdout, \"    RMS L (before de-bias): %f\\n\", datafile->offpulse_rms[1+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)]);\n   if(extended) {\n     for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n     fprintf(stdout, \"    RMS sqrt(Q^2+U^2+V^2):  %f\\n\", datafile->offpulse_rms[5+output_nr_pols*(freqnr + datafile->NrFreqChan*pulsenr)]);\n   }\n }\n      }\n      gsl_sort_float (Loffpulse, 1, NrOffpulseBins);\n      medianL = gsl_stats_float_median_from_sorted_data(Loffpulse, 1, NrOffpulseBins);\n      fflush(stdout);\n      if((verbose.verbose && freqnr == 0 && pulsenr == 0) || verbose.debug) {\n for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n fprintf(stdout, \"    Median L: %f\\n\", medianL);\n      }\n      if(extended) {\n gsl_sort_float (Poffpulse, 1, NrOffpulseBins);\n medianP = gsl_stats_float_median_from_sorted_data(Poffpulse, 1, NrOffpulseBins);\n fflush(stdout);\n if((verbose.verbose && freqnr == 0 && pulsenr == 0) || verbose.debug) {\n   for(indent = 0; indent < verbose.indent; indent++) printf(\" \");\n   fprintf(stdout, \"    Median sqrt(Q^2+U^2+V^2): %f\\n\", medianP);\n }\n      }\n      for(j = 0; j < (datafile->NrBins); j++) {\n if(correctLbias == 1) {\n   float junk = (0.5*(RMSQ+RMSU)/newdata[j+newindex_L]);\n   if(junk < 1)\n     newdata[j+newindex_L] *= sqrt(1.0-junk*junk);\n   else\n     newdata[j+newindex_L] = 0.0;\n }else if(correctLbias == 0) {\n   newdata[j+newindex_L] -= medianL;\n }\n if(extended)\n   newdata[j+newindex_T] -= medianP;\n      }\n      for(i = 0; i < (datafile->NrBins); i++) {\n newdata[i+newindex_Pa] = 90.0*atan2(datafile->data[sindex_U+i],datafile->data[sindex_Q+i])/M_PI;\n if(paoffset) {\n   newdata[i+newindex_Pa] += paoffset;\n   newdata[i+newindex_Pa] = derotate_180_small_double(newdata[i+newindex_Pa]);\n }\n if(datafile->data[i+sindex_Q] != 0 || datafile->data[i+sindex_U] != 0) {\n   newdata[i+newindex_dPa] = sqrt((datafile->data[sindex_Q+i]*RMSU)*(datafile->data[sindex_Q+i]*RMSU) + (datafile->data[sindex_U+i]*RMSQ)*(datafile->data[sindex_U+i]*RMSQ));\n   newdata[i+newindex_dPa] /= 2.0*(datafile->data[i+sindex_Q]*datafile->data[i+sindex_Q] + datafile->data[i+sindex_U]*datafile->data[i+sindex_U]);\n   newdata[i+newindex_dPa] *= 180.0/M_PI;\n }else {\n   newdata[i+newindex_dPa] = 0;\n }\n if(extended) {\n   newdata[i+newindex_Ell] = 0;\n     newdata[i+newindex_dEll] = 0;\n }\n      }\n      for(j = 0; j < (datafile->NrBins); j++) {\n newdata[j+newindex_I] = datafile->data[j+sindex_I];\n newdata[j+newindex_V] = datafile->data[j+sindex_V];\n      }\n    }\n  }\n  free(datafile->data);\n  datafile->data = newdata;\n  if(rms_file_specified) {\n    free(newdata_rms);\n  }\n  if(nolongitudes == 0) {\n    datafile->tsampMode = TSAMPMODE_LONGITUDELIST;\n  }\n  datafile->NrPols = output_nr_pols;\n  if(extended) {\n    datafile->poltype = POLTYPE_ILVPAdPATEldEl;\n  }else {\n    datafile->poltype = POLTYPE_ILVPAdPA;\n  }\n  free(Loffpulse);\n  free(Poffpulse);\n  return 1;\n}\nint writePPOLHeader(datafile_definition datafile, int argc, char **argv, verbose_definition verbose)\n{\n  char *txt;\n  txt = malloc(10000);\n  if(txt == NULL) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR writePPOLHeader: Memory allocation error.\");\n    return 0;\n  }\n  constructCommandLineString(txt, 10000, argc, argv, verbose);\n  fprintf(datafile.fptr_hdr, \"#ppol file: %s\\n\", txt);\n  free(txt);\n  return 1;\n}\nint readPPOLHeader(datafile_definition *datafile, int extended, verbose_definition verbose)\n{\n  float dummy_float;\n  int ret, maxlinelength, nrwords;\n  char *txt, *ret_ptr, *word_ptr;\n  maxlinelength = 2000;\n  txt = malloc(maxlinelength);\n  if(txt == NULL) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR readPPOLHeader: Memory allocation error.\");\n    return 0;\n  }\n  datafile->isFolded = 1;\n  datafile->foldMode = FOLDMODE_FIXEDPERIOD;\n  datafile->fixedPeriod = 0;\n  datafile->tsampMode = TSAMPMODE_LONGITUDELIST;\n  datafile->fixedtsamp = 0;\n  datafile->tsubMode = TSUBMODE_FIXEDTSUB;\n  if(datafile->tsub_list != NULL)\n    free(datafile->tsub_list);\n  datafile->tsub_list = (double *)malloc(sizeof(double));\n  if(datafile->tsub_list == NULL) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR readPPOLHeader: Memory allocation error\");\n    return 0;\n  }\n  datafile->tsub_list[0] = 0;\n  datafile->NrSubints = 1;\n  datafile->NrFreqChan = 1;\n  datafile->datastart = 0;\n  rewind(datafile->fptr);\n  ret = fread(txt, 1, 3, datafile->fptr);\n  txt[3] = 0;\n  if(ret != 3) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR readPPOLHeader: cannot read from file.\");\n    free(txt);\n    return 0;\n  }\n  if(strcmp(txt, \"#pp\") != 0\n) {\n    fflush(stdout);\n    printwarning(verbose.debug, \"WARNING readPPOLHeader: File does not appear to be in PPOL or PPOLSHORT format. I will try to load file, but this will probably fail. Did you run ppol first?\");\n  }\n  skipallhashedlines(datafile);\n  datafile->NrBins = 0;\n  dummy_float = 0;\n  do {\n    ret_ptr = fgets(txt, maxlinelength, datafile->fptr);\n    if(ret_ptr != NULL) {\n      if(txt[0] != '#') {\n if(extended) {\n   word_ptr = pickWordFromString(txt, 2, &nrwords, 1, ' ', verbose);\n   if(nrwords != 10 && nrwords != 14) {\n     fflush(stdout);\n     printerror(verbose.debug, \"ERROR readPPOLHeader: Line should have 10 or 14 words, got %d\", nrwords);\n     if(nrwords == 3)\n       printerror(verbose.debug, \"                             Maybe file is in format %s?\", returnFileFormat_str(PPOL_SHORT_format));\n     printerror(verbose.debug, \"                             Line: '%s'.\", txt);\n     free(txt);\n     return 0;\n   }\n   if(nrwords == 10) {\n     datafile->poltype = POLTYPE_ILVPAdPA;\n     datafile->NrPols = 5;\n   }else {\n     datafile->poltype = POLTYPE_ILVPAdPATEldEl;\n     datafile->NrPols = 8;\n   }\n }else {\n   word_ptr = pickWordFromString(txt, 1, &nrwords, 1, ' ', verbose);\n   if(nrwords != 3) {\n     fflush(stdout);\n     printerror(verbose.debug, \"ERROR readPPOLHeader: Line should have 3 words, got %d\", nrwords);\n     if(nrwords == 10)\n       printerror(verbose.debug, \"                             Maybe file is in format %s?\", returnFileFormat_str(PPOL_format));\n     printerror(verbose.debug, \"                             Line: '%s'.\", txt);\n     free(txt);\n     return 0;\n   }\n }\n ret = sscanf(word_ptr, \"%f\", &dummy_float);\n if(ret != 1) {\n   fflush(stdout);\n   printerror(verbose.debug, \"ERROR readPPOLHeader: Cannot interpret as a float: '%s'.\", txt);\n   free(txt);\n   return 0;\n }\n if(dummy_float >= 360) {\n   fflush(stdout);\n   printwarning(verbose.debug, \"WARNING: IGNORING POINTS AT PULSE LONGITUDES > 360 deg.\");\n }else {\n   (datafile->NrBins)++;\n }\n      }\n    }\n  }while(ret_ptr != NULL && dummy_float < 360);\n  if(extended == 0) {\n    datafile->poltype = POLTYPE_PAdPA;\n    datafile->NrPols = 2;\n  }\n  fflush(stdout);\n  if(verbose.verbose) fprintf(stdout, \"Going to load %ld points from %s\\n\", datafile->NrBins, datafile->filename);\n  if(datafile->NrBins == 0) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR readPPOLHeader: No data in %s\", datafile->filename);\n    free(txt);\n    return 0;\n  }\n  fseek(datafile->fptr, datafile->datastart, SEEK_SET);\n  free(txt);\n  if(datafile->offpulse_rms != NULL) {\n    free(datafile->offpulse_rms);\n    datafile->offpulse_rms = NULL;\n  }\n  if(extended) {\n    datafile->offpulse_rms = (float *)malloc(datafile->NrSubints*datafile->NrFreqChan*datafile->NrPols*sizeof(float));\n    if(datafile->offpulse_rms == NULL) {\n      fflush(stdout);\n      printerror(verbose.debug, \"ERROR readPPOLHeader: Memory allocation error\");\n      return 0;\n    }\n  }\n  datafile->tsamp_list = (double *)malloc(datafile->NrBins*sizeof(double));\n  if(datafile->tsamp_list == NULL) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR readPPOLHeader: Memory allocation error\");\n    return 0;\n  }\n  return 1;\n}\nint readPPOLfile(datafile_definition *datafile, float *data, int extended, float add_longitude_shift, verbose_definition verbose)\n{\n  int maxlinelength;\n  long i, k, dummy_long;\n  char *txt, *ret_ptr;\n  if(datafile->NrBins == 0) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR readPPOLfile: No data in %s\", datafile->filename);\n    return 0;\n  }\n  maxlinelength = 2000;\n  txt = malloc(maxlinelength);\n  if(txt == NULL) {\n    fflush(stdout);\n    printerror(verbose.debug, \"ERROR readPPOLfile: Memory allocation error.\");\n    return 0;\n  }\n  fseek(datafile->fptr, datafile->datastart, SEEK_SET);\n  k = 0;\n  if(extended) {\n    datafile->offpulse_rms[3] = -1;\n    datafile->offpulse_rms[4] = -1;\n    if(datafile->NrPols == 8) {\n      datafile->offpulse_rms[6] = -1;\n      datafile->offpulse_rms[7] = -1;\n    }\n  }\n  for(i = 0; i < datafile->NrBins; i++) {\n    ret_ptr = fgets(txt, maxlinelength, datafile->fptr);\n    if(ret_ptr == NULL) {\n      fflush(stdout);\n      printerror(verbose.debug, \"ERROR readPPOLfile: Cannot read next line, should not happen after successfully reading in header\");\n      free(txt);\n      return 0;\n    }\n    if(txt[0] != '#') {\n      if(extended == 0) {\n sscanf(txt, \"%lf %f %f\", &(datafile->tsamp_list[k]), &(data[k]), &(data[k+datafile->NrBins]));\n      }else {\n if(datafile->NrPols == 8) {\n   sscanf(txt, \"%ld %lf %f %f %f %f %f %f %f %f %f %f %f %f\", &dummy_long, &(datafile->tsamp_list[k]), &(data[k]), &(datafile->offpulse_rms[0]), &(data[k+datafile->NrBins]), &(datafile->offpulse_rms[1]), &(data[k+2*datafile->NrBins]), &(datafile->offpulse_rms[2]), &(data[k+3*datafile->NrBins]), &(data[k+4*datafile->NrBins]), &(data[k+5*datafile->NrBins]), &(datafile->offpulse_rms[5]), &(data[k+6*datafile->NrBins]), &(data[k+7*datafile->NrBins]));\n }else {\n   sscanf(txt, \"%ld %lf %f %f %f %f %f %f %f %f\", &dummy_long, &(datafile->tsamp_list[k]), &(data[k]), &(datafile->offpulse_rms[0]), &(data[k+datafile->NrBins]), &(datafile->offpulse_rms[1]), &(data[k+2*datafile->NrBins]), &(datafile->offpulse_rms[2]), &(data[k+3*datafile->NrBins]), &(data[k+4*datafile->NrBins]));\n }\n      }\n      datafile->tsamp_list[k] += add_longitude_shift;\n      if(datafile->tsamp_list[k] >= 0 && datafile->tsamp_list[k] < 360) {\n   k++;\n      }else {\n fflush(stdout);\n printwarning(verbose.debug, \"WARNING readPPOLfile: IGNORING POINTS AT PULSE LONGITUDES > 360 deg.\");\n      }\n    }\n  }\n  if(k != datafile->NrBins) {\n    fflush(stdout);\n    printerror(verbose.debug, \"WARNING readPPOLfile: The nr of bins read in is different as determined from header. Something is wrong.\");\n    return 0;\n  }\n  fflush(stdout);\n  if(verbose.verbose) fprintf(stdout, \"readPPOLfile: Accepted %ld points\\n\", datafile->NrBins);\n     free(txt);\n  return 1;\n}\nint writePPOLfile(datafile_definition datafile, float *data, int extended, int onlysignificantPA, int twoprofiles, float PAoffset, verbose_definition verbose)\n{\n  long j;\n  if(datafile.poltype != POLTYPE_ILVPAdPA && datafile.poltype != POLTYPE_PAdPA && datafile.poltype != POLTYPE_ILVPAdPATEldEl) {\n    printerror(verbose.debug, \"ERROR writePPOLfile: Data doesn't appear to have poltype ILVPAdPA, PAdPA or ILVPAdPATEldEl (it is %d).\", datafile.poltype);\n    return 0;\n  }\n  if(datafile.poltype == POLTYPE_ILVPAdPA && datafile.NrPols != 5) {\n    printerror(verbose.debug, \"ERROR writePPOLfile: 5 polarization channels were expected, but there are %ld.\", datafile.NrPols);\n    return 0;\n  }else if(datafile.poltype == POLTYPE_PAdPA && datafile.NrPols != 2) {\n    printerror(verbose.debug, \"ERROR writePPOLfile: 2 polarization channels were expected, but there are %ld.\", datafile.NrPols);\n    return 0;\n  }else if(datafile.poltype == POLTYPE_ILVPAdPATEldEl && datafile.NrPols != 8) {\n    printerror(verbose.debug, \"ERROR writePPOLfile: 8 polarization channels were expected, but there are %ld.\", datafile.NrPols);\n    return 0;\n  }\n  if(datafile.NrSubints > 1 || datafile.NrFreqChan > 1) {\n    printerror(verbose.debug, \"ERROR writePPOLfile: Can only do this opperation if there is one subint and one frequency channel.\");\n    return 0;\n  }\n  if(datafile.tsampMode != TSAMPMODE_LONGITUDELIST) {\n    printerror(verbose.debug, \"ERROR writePPOLfile: Expected pulse longitudes to be defined.\");\n    return 0;\n  }\n  int pa_offset, dpa_offset;\n  if(datafile.poltype == POLTYPE_ILVPAdPA || datafile.poltype == POLTYPE_ILVPAdPATEldEl) {\n    pa_offset = 3;\n    dpa_offset = 4;\n  }else if(datafile.poltype == POLTYPE_PAdPA) {\n    pa_offset = 0;\n    dpa_offset = 1;\n  }\n  for(j = 0; j < datafile.NrBins; j++) {\n    if(data[j+dpa_offset*datafile.NrBins] > 0 || onlysignificantPA == 0) {\n      if(extended) {\n fprintf(datafile.fptr, \"%ld %e %e %e %e %e %e %e %e %e\", j, datafile.tsamp_list[j], data[j], datafile.offpulse_rms[0], data[j+datafile.NrBins], datafile.offpulse_rms[1], data[j+2*datafile.NrBins], datafile.offpulse_rms[2], data[j+pa_offset*datafile.NrBins]+PAoffset, data[j+dpa_offset*datafile.NrBins]);\n if(datafile.poltype == POLTYPE_ILVPAdPATEldEl)\n   fprintf(datafile.fptr, \" %e %e %e %e\", data[j+5*datafile.NrBins], datafile.offpulse_rms[5], data[j+6*datafile.NrBins], data[j+7*datafile.NrBins]);\n fprintf(datafile.fptr, \"\\n\");\n      }else {\n fprintf(datafile.fptr, \"%e %e %e\\n\", datafile.tsamp_list[j], data[j+pa_offset*datafile.NrBins]+PAoffset, data[j+dpa_offset*datafile.NrBins]);\n      }\n    }\n  }\n  if(twoprofiles) {\n    for(j = 0; j < datafile.NrBins; j++) {\n      if(data[j+dpa_offset*datafile.NrBins] > 0 || onlysignificantPA == 0) {\n if(extended) {\n   fprintf(datafile.fptr, \"%ld %e %e %e %e %e %e %e %e %e\", j, datafile.tsamp_list[j]+360, data[j], datafile.offpulse_rms[0], data[j+datafile.NrBins], datafile.offpulse_rms[1], data[j+2*datafile.NrBins], datafile.offpulse_rms[2], data[j+pa_offset*datafile.NrBins]+PAoffset, data[j+dpa_offset*datafile.NrBins]);\n   if(datafile.poltype == POLTYPE_ILVPAdPATEldEl)\n     fprintf(datafile.fptr, \" %e %e %e %e\", data[j+5*datafile.NrBins], datafile.offpulse_rms[5], data[j+6*datafile.NrBins], data[j+7*datafile.NrBins]);\n   fprintf(datafile.fptr, \"\\n\");\n }else {\n   fprintf(datafile.fptr, \"%e %e %e\\n\", datafile.tsamp_list[j]+360, data[j]+PAoffset, data[j+dpa_offset*datafile.NrBins]);\n }\n      }\n    }\n  }\n  return 1;\n}\n", "meta": {"hexsha": "393ea22da10936e432e4a1ea070145001b3c3e34", "size": 35337, "ext": "c", "lang": "C", "max_stars_repo_path": "src/lib/psrio_paswing.c", "max_stars_repo_name": "David-McKenna/psrsalsa", "max_stars_repo_head_hexsha": "e5074b552d1c404123dee058d5cee79ea230b5a9", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/lib/psrio_paswing.c", "max_issues_repo_name": "David-McKenna/psrsalsa", "max_issues_repo_head_hexsha": "e5074b552d1c404123dee058d5cee79ea230b5a9", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/lib/psrio_paswing.c", "max_forks_repo_name": "David-McKenna/psrsalsa", "max_forks_repo_head_hexsha": "e5074b552d1c404123dee058d5cee79ea230b5a9", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 47.1789052069, "max_line_length": 755, "alphanum_fraction": 0.6861646433, "num_tokens": 10960, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.18952110048512089, "lm_q2_score": 0.018546566478605368, "lm_q1q2_score": 0.0035149656892457426}}
{"text": "#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <math.h>\n#include <gsl/gsl_rng.h>\n#include <time.h>\n#include <assert.h>\n\n#include \"core_allvars.h\"\n#include \"core_proto.h\"\n#include \"temporal_array.h\"\n\nvoid init_galaxy(int p, int halonr, int treenr, int32_t filenr)\n{\n  int32_t j, step, status;\n  \n\tassert(halonr == Halo[halonr].FirstHaloInFOFgroup);\n\n  Gal[p].FileNr = filenr;\n\n  Gal[p].Type = 0;\n  Gal[p].TreeNr = treenr;\n\n  Gal[p].GalaxyNr = GalaxyCounter;\n  GalaxyCounter++;\n  \n  Gal[p].HaloNr = halonr;\n   \n  Gal[p].MostBoundID = Halo[halonr].MostBoundID;\n  //Gal[p].MostBoundID = -1; \n  Gal[p].SnapNum = Halo[halonr].SnapNum - 1;\n\n  Gal[p].mergeType = 0;\n  Gal[p].mergeIntoID = -1;\n  Gal[p].mergeIntoSnapNum = -1;\n  Gal[p].dT = -1.0;\n\n  for(j = 0; j < 3; j++)\n  {\n    Gal[p].Pos[j] = Halo[halonr].Pos[j];\n    Gal[p].Vel[j] = Halo[halonr].Vel[j];\n  }\n\n  Gal[p].Len = Halo[halonr].Len;\n  Gal[p].Vmax = Halo[halonr].Vmax;\n  Gal[p].Vvir = get_virial_velocity(halonr);\n  Gal[p].Mvir = get_virial_mass(halonr);\n  Gal[p].Rvir = get_virial_radius(halonr);\n\n  Gal[p].deltaMvir = 0.0;\n\n  Gal[p].ColdGas = 0.0;\n  Gal[p].StellarMass = 0.0;\n  Gal[p].BulgeMass = 0.0;\n  Gal[p].HotGas = 0.0;\n  Gal[p].EjectedMass = 0.0;\n  Gal[p].EjectedMassSN = 0.0;\n  Gal[p].EjectedMassQSO = 0.0;\n  Gal[p].BlackHoleMass = 0.0;\n  Gal[p].ICS = 0.0;\n\n  Gal[p].MetalsColdGas = 0.0;\n  Gal[p].MetalsStellarMass = 0.0;\n  Gal[p].MetalsBulgeMass = 0.0;\n  Gal[p].MetalsHotGas = 0.0;\n  Gal[p].MetalsEjectedMass = 0.0;\n  Gal[p].MetalsICS = 0.0;\n  \n  for(step = 0; step < STEPS; step++)\n  {\n    Gal[p].SfrDisk[step] = 0.0;\n    Gal[p].SfrBulge[step] = 0.0;\n    Gal[p].SfrDiskColdGas[step] = 0.0;\n    Gal[p].SfrDiskColdGasMetals[step] = 0.0;\n    Gal[p].SfrBulgeColdGas[step] = 0.0;\n    Gal[p].SfrBulgeColdGasMetals[step] = 0.0;\n  }\n\n  Gal[p].DiskScaleRadius = get_disk_radius(halonr, p);\n  Gal[p].MergTime = 999.9;\n  Gal[p].Cooling = 0.0;\n  Gal[p].Heating = 0.0;\n  Gal[p].r_heat = 0.0;\n  Gal[p].QuasarModeBHaccretionMass = 0.0;\n  Gal[p].TimeOfLastMajorMerger = -1.0;\n  Gal[p].TimeOfLastMinorMerger = -1.0;\n  Gal[p].OutflowRate = 0.0;\n\tGal[p].TotalSatelliteBaryons = 0.0;\n\t// infall properties\n  Gal[p].infallMvir = -1.0;  \n  Gal[p].infallVvir = -1.0;\n  Gal[p].infallVmax = -1.0;\n \n  Gal[p].IsMerged = -1;\n\n  status = malloc_temporal_arrays(&Gal[p]);\n  if (status == EXIT_FAILURE)\n  {\n    ABORT(EXIT_FAILURE);\n  }\n  ++gal_mallocs;\t\n \n  for (j = 0; j < MAXSNAPS; ++j)\n  {\n    Gal[p].GridType[j] = -1;\n    Gal[p].GridFoFHaloNr[j] = -1;\n    Gal[p].GridHistory[j] = -1;\n    Gal[p].GridColdGas[j] = 0.0;\n    Gal[p].GridHotGas[j] = 0.0;\n    Gal[p].GridEjectedMass[j] = 0.0;\n    Gal[p].GridDustColdGas[j] = 0.0;\n    Gal[p].GridDustHotGas[j] = 0.0;\n    Gal[p].GridDustEjectedMass[j] = 0.0;\n    Gal[p].GridStellarMass[j] = 0.0;\n    Gal[p].GridBHMass[j] = 0.0;\n    Gal[p].GridSFR[j] = 0.0;\n    Gal[p].GridZ[j] = 0.0;\n    Gal[p].GridFoFMass[j] = 0.0;\n    Gal[p].GridHaloMass[j] = 0.0;\n    Gal[p].EjectedFraction[j] = 0.0;\n    Gal[p].EjectedFractionSN[j] = 0.0;\n    Gal[p].EjectedFractionQSO[j] = 0.0;\n    Gal[p].LenHistory[j] = -1;\n    Gal[p].GridOutflowRate[j] = 0.0;\n    Gal[p].GridInfallRate[j] = 0.0;\n    Gal[p].QuasarActivity[j] = 0;\n    Gal[p].QuasarSubstep[j] = -1;\n    Gal[p].DynamicalTime[j] = 0.0;\n    Gal[p].LenMergerGal[j] = -1;\n    Gal[p].GridReionMod[j] = -1.0;\n    Gal[p].GridNgamma_HI[j] = 0.0;\n    Gal[p].Gridfesc[j] = 0.0;\n    Gal[p].ColdCrit[j] = 0.0;\n    Gal[p].MUV[j] = 999.99;\n  }\n\n  Gal[p].GrandSum = 0.0;\n \n  Gal[p].StellarAge_Numerator = 0.0;\n  Gal[p].StellarAge_Denominator = 0.0;\n\n  Gal[p].reheated_mass = 0.0;\n  Gal[p].ejected_mass = 0.0;\n  Gal[p].mass_stars_recycled = 0.0;\n  Gal[p].mass_metals_new = 0.0; \n  Gal[p].NSN = 0.0;\n\n  if (IRA == 0)\n  {\n    for (j = 0; j < SN_Array_Len; ++j)\n    {\n      Gal[p].SN_Stars[j] = 0.0;\n    }\n  }\n  Gal[p].Total_SN_SF_Time = 0.0;\n  Gal[p].Total_SN_Stars = 0.0;\n\n  // Dust Reservoirs.\n\n  Gal[p].DustColdGas = 0.0;\n  Gal[p].DustHotGas = 0.0;\n  Gal[p].DustEjectedMass = 0.0;\n\n  // Quasar Activity Tracking \n  \n  Gal[p].QuasarActivityToggle = 0;\n  Gal[p].TargetQuasarTime = 0.0;\n  Gal[p].QuasarBoostActiveTime = 0.0;\n  Gal[p].QuasarFractionalPhotons = 0.0;\n\n  // Stellar Age Tracking\n\n  if (PhotonPrescription == 1)\n  {\n    for (j = 0; j < StellarTracking_Len; ++j)\n    {\n      Gal[p].Stellar_Stars[j] = 0.0;\n    }\n  }\n  Gal[p].Total_Stellar_SF_Time = 0.0;\n  Gal[p].Total_Stellar_Stars = 0.0;\n\n}\n\ndouble get_disk_radius(int halonr, int p)\n{\n  double SpinMagnitude, SpinParameter;\n  \n\tif(Gal[p].Vvir > 0.0 && Gal[p].Rvir > 0.0)\n\t{\n\t\t// See Mo, Shude & White (1998) eq12, and using a Bullock style lambda.\n\t\tSpinMagnitude = sqrt(Halo[halonr].Spin[0] * Halo[halonr].Spin[0] + \n\t\t\tHalo[halonr].Spin[1] * Halo[halonr].Spin[1] + Halo[halonr].Spin[2] * Halo[halonr].Spin[2]);\n  \n\t\tSpinParameter = SpinMagnitude / (1.414 * Gal[p].Vvir * Gal[p].Rvir);\n\t\treturn (SpinParameter / 1.414) * Gal[p].Rvir;\t\t\n\t}\n\telse\n\t\treturn 0.1 * Gal[p].Rvir;\n\n}\n\n\n\ndouble get_metallicity(double gas, double metals)\n{\n  double metallicity;\n\n  if(gas > 0.0 && metals > 0.0)\n  {\n    metallicity = metals / gas;\n    if(metallicity < 1.0)\n      return metallicity;\n    else\n      return 1.0;\n  }\n  else\n    return 0.0;\n\n}\n\ndouble get_dust_fraction(double gas, double dust)\n{\n\n  double dust_fraction;\n  if (gas > 0.0 && dust > 0.0)\n  {\n    dust_fraction = dust / gas;\n    if (dust_fraction < 1.0)\n      return dust_fraction;\n    else\n      return 1.0;\n  }\n  else\n  {\n    return 0.0;\n  }\n  \n}\n\ndouble dmax(double x, double y)\n{\n  if(x > y)\n    return x;\n  else\n    return y;\n}\n\n\n\ndouble get_virial_mass(int halonr)\n{\n  if(halonr == Halo[halonr].FirstHaloInFOFgroup && Halo[halonr].Mvir >= 0.0)\n  {\n    ++count_Mvir;\n    return Halo[halonr].Mvir;   /* take spherical overdensity mass estimate */\n  } \n  else\n  {    \n    ++count_Len;\n    return Halo[halonr].Len * PartMass;\n  }\n}\n\n\n\ndouble get_virial_velocity(int halonr)\n{\n\tdouble Rvir;\n\t\n\tRvir = get_virial_radius(halonr);\n\t\n  if(Rvir > 0.0)\n\t\treturn sqrt(sage_G * get_virial_mass(halonr) / Rvir);\n\telse\n\t\treturn 0.0;\n}\n\n\n\ndouble get_virial_radius(int halonr)\n{\n  // return Halo[halonr].Rvir;  // Used for Bolshoi\n\n  double zplus1, hubble_of_z_sq, rhocrit, fac;\n  \n  zplus1 = 1 + ZZ[Halo[halonr].SnapNum];\n  hubble_of_z_sq =\n    sage_Hubble * sage_Hubble *(Omega * zplus1 * zplus1 * zplus1 + (1 - Omega - OmegaLambda) * zplus1 * zplus1 +\n    OmegaLambda);\n  \n  rhocrit = 3 * hubble_of_z_sq / (8 * M_PI * sage_G);\n  fac = 1 / (200 * 4 * M_PI / 3.0 * rhocrit);\n  \n  return cbrt(get_virial_mass(halonr) * fac);\n}\n\nint32_t determine_1D_idx(float pos_x, float pos_y, float pos_z, int32_t *grid_1D)\n{\n\n  int32_t x_grid, y_grid, z_grid;\n\n  x_grid = round(pos_x * GridSize/BoxSize);\n  if (x_grid == GridSize)\n    --x_grid;\n\n  y_grid = round(pos_y * GridSize/BoxSize);\n  if (y_grid == GridSize)\n    --y_grid;\n\n  z_grid = round(pos_z * GridSize/BoxSize);\n  if (z_grid == GridSize)\n    --z_grid;\n  \n\n  *grid_1D = (z_grid*GridSize+y_grid)*GridSize+x_grid; // Convert the grid (x,y,z) to a 1D value.\n\n  if(*grid_1D > CUBE(GridSize) || *grid_1D < 0) // Sanity check to ensure that no Grid Positions are outside the box.\n  {\n    fprintf(stderr, \"Found a Grid Position outside the bounds of the box or negative\\nPos[0] = %.4f\\tPos[1] = %.4f\\tPos[2] = %.4f\\n\", pos_x, pos_y, pos_z);\n    fprintf(stderr, \"Grid indices were x = %d\\ty = %d\\tz = %d\\t1D = %d\\tMaximum Allowed = %d\\n\", x_grid, y_grid, z_grid, *grid_1D, CUBE(GridSize) - 1);\n \n    return EXIT_FAILURE;\n  }\n\n  return EXIT_SUCCESS;\n}\n\n", "meta": {"hexsha": "af494f3f40b312e1c6ab4a839da5f42ec509cd6d", "size": 7519, "ext": "c", "lang": "C", "max_stars_repo_path": "src/sage/model_misc.c", "max_stars_repo_name": "jacobseiler/rsage", "max_stars_repo_head_hexsha": "b3b0a3fa3c676eab188991e37d06894396bfc74f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2019-05-23T04:11:32.000Z", "max_stars_repo_stars_event_max_datetime": "2019-05-23T04:11:32.000Z", "max_issues_repo_path": "src/sage/model_misc.c", "max_issues_repo_name": "jacobseiler/rsage", "max_issues_repo_head_hexsha": "b3b0a3fa3c676eab188991e37d06894396bfc74f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 7.0, "max_issues_repo_issues_event_min_datetime": "2018-08-17T05:04:57.000Z", "max_issues_repo_issues_event_max_datetime": "2019-01-16T05:40:16.000Z", "max_forks_repo_path": "src/sage/model_misc.c", "max_forks_repo_name": "jacobseiler/rsage", "max_forks_repo_head_hexsha": "b3b0a3fa3c676eab188991e37d06894396bfc74f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 22.8541033435, "max_line_length": 155, "alphanum_fraction": 0.6153743849, "num_tokens": 2966, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.18952109132967757, "lm_q2_score": 0.009859854985312994, "lm_q1q2_score": 0.0018686504771688805}}