copasi_api.h

/*! \mainpage Simplifed API for the COPASI Library
 *
 * \section intro_sec Introduction
 *
 * The developers of COPASI provide COPASI as a reusable library as well as
 * the well known COPASI user interface. The library however has a fairly
 * complex API and can take some time getting used. We have therefore layered
 * on top of the COPASI library a new C based API that we feel is much simpler
 * to use. For example, to run a simple SBML model and generate time series data
 * we would call:
 *
 \code
 copasi_model m;
 c_matrix output;

 m = cReadSBMLFile ("mymodel.xml");

 output = cSimulationDeterministic (m, 0, 10, 100);
 \endcode

 More complex example:

 \code
 #include <stdlib.h>
 #include <stdio.h>
 #include "copasi_api.h"

 int main(int nargs, char** argv)
 {
        c_matrix efm, output, params;
        copasi_model m1, m2;

        if (nargs < 2)
        {
            m1 = model1();
        }
        else
        {
            printf("loading model file %s\n", argv[1]);
            m1 = cReadSBMLFile(argv[1]);
        }

        cWriteAntimonyFile(m1, "model.txt");

        printf("Antimony file written to model.txt\nSimulating...\n");
        output = cSimulateDeterministic(m1, 0, 100, 1000);  //model, start, end, num. points
        printf("output.tab has %i rows and %i columns\n",output.rows, output.cols);
        c_printMatrixToFile("output.tab", output);
        c_deleteMatrix(output);

        cRemoveModel(m1);
        copasi_end();
        return 0;
 }
 \endcode
 * \section install_sec Installation
 *
 * Installation documentation is provided in the main google code page.

 \defgroup loadsave Read and Write models
 \brief Read and write models to files or strings. Support for SBML and Antimony formats.

 \defgroup create Define models
 \brief Create models and set model components using code

 \defgroup state Current state of system
 \brief Compute derivatives, fluxed, and other values of the system at the current state

 \defgroup reaction Reaction group
 \brief Get information about reaction rates

 \defgroup rateOfChange Rates of change group
 \brief Get information about rates of change

 \defgroup boundary Boundary species group
 \brief Get information about reaction rates

 \defgroup floating Floating species group
 \brief Get information about reaction rates

 \defgroup parameters Parameter group
 \brief set and get global and local parameters

 \defgroup compartment Compartment group
 \brief set and get information on compartments

 \defgroup simulation Time-course simulation
 \brief Deterministic, stochastic, and hybrid simulation algorithms

 \defgroup mca Metabolic Control Analysis
 \brief Calculate control coefficients and sensitivities

 \defgroup matrix Stoichiometry analysis
 \brief Linear algebra based methods for analyzing a reaction network

 \defgroup optim Parameter optimization
 \brief Optimization of parameters to match given data
*/

#ifndef COPASI_SIMPLE_C_API
#define COPASI_SIMPLE_C_API

 /**
  * @file    copasi_api.h
  * @brief   Simple C API for the Copasi C++ library

This is a C API for the COPASI C++ library. Rate equations in COPASI require the "complete name",
e.g. instead of X, the rate must specify <model.compartment.X>. In this C API, those complete names
are stored in a hash table. The API replaces the simple strings, i.e. "C", with the complete names by
using the hash-table. This is mainly for speed; otherwise, every cSetReactionRate would be searching
through the entire model for each of its variables. The hash-table idea is used for functions such
as cSetValue, which can set the value of a parameter or that of a molecular species. Again, it uses the
hash table to identify what a variable is.

The C API hides the C++ classes by casting some of the main classes into void pointers inside
C structs.

std::map is used for performing the hashing (it is not a real hash-table, but close enough).
boost::regex is used for string substitutions.
*/

#include "cstructs.h"
#define COPASIAPIEXPORT CAPIEXPORT

/*!\brief This struct is used to contain a pointer to an instance of a COPASI object*/
typedef struct
{
	void * CopasiModelPtr;
	void * CopasiDataModelPtr;
	void * qHash;
	char * errorMessage;
	char * warningMessage;
} copasi_model;

/*!\brief This struct is used to contain a pointer to an instance of a COPASI reaction object*/
typedef struct
{
	void * CopasiReactionPtr;
	void * CopasiModelPtr;
	void * qHash;
} copasi_reaction;

/*!\brief This struct is used to contain a pointer to an instance of a COPASI compartment object*/
typedef struct
{
	void * CopasiCompartmentPtr;
	void * CopasiModelPtr;
	void * qHash;
} copasi_compartment;

BEGIN_C_DECLS

COPASIAPIEXPORT void copasi_init();

// -----------------------------------------------------------------------
/**
  * @name Memory management
  */
/** \{*/

/*!
 \brief destroy copasi -- MUST BE CALLED at the end of program
 \ingroup memory
*/
COPASIAPIEXPORT void copasi_end();

/*!
 \brief remove a model
 \ingroup memory
*/
COPASIAPIEXPORT void cRemoveModel(copasi_model);


// -----------------------------------------------------------------------
/** \} */
/**
  * @name Read and write models
  */
/** \{ */

/*!
 \brief Set the expected version and level of SBML files and strings; default is 2.4
 \param int level
 \param in version
 \ingroup loadsave
*/
COPASIAPIEXPORT void cSetSBMLLevelAndVersion(int level, int version);


/*!
 \brief Create a model from an Antimony, see antimony.sf.net for details of Antimony syntax
 \param char* file name
 \return copasi_model Copasi model of the Antimony file
 \ingroup loadsave
*/
COPASIAPIEXPORT copasi_model cReadAntimonyFile(const char * filename);


/*!
 \brief Create a model from an Antimony string
 \param char* Antimony string
 \return copasi_model Copasi model of the Antimony string
 \ingroup loadsave
*/
COPASIAPIEXPORT copasi_model cReadAntimonyString(const char * sbml);


/*!
 \brief Create a model from an SBML file
 \param char* file name
 \return copasi_model Copasi model of the SBML file
 \ingroup loadsave
*/
COPASIAPIEXPORT copasi_model cReadSBMLFile(const char * filename);


/*!
 \brief Create a model from an SBML string
 \param char* SBML string
 \return copasi_model Copasi model of the SBML string
 \ingroup loadsave
*/
COPASIAPIEXPORT copasi_model cReadSBMLString(const char * sbml);


/*!
 \brief Save a model as an SBML file
 \param copasi_model copasi model
 \param char* file name
 \ingroup loadsave
*/
COPASIAPIEXPORT void cWriteSBMLFile(copasi_model model, const char * filename);


/*!
 \brief Save a model as an Antimony file, see antimony.sf.net for details of Antimony syntax
 \param copasi_model copasi model
 \param char* file name
 \ingroup loadsave
*/
COPASIAPIEXPORT void cWriteAntimonyFile(copasi_model model, const char * filename);


// -----------------------------------------------------------------------
/** \} */
/**
  * @name Create model group
  */
/** \{ */

/*!
 \brief Create a model
 \param char* model name
 \return copasi_model a new copasi model
 \ingroup create
*/
COPASIAPIEXPORT copasi_model cCreateModel(const char * name);


/*!
 \brief This function MUST be called after creating a model or modifying a model (except parameter changes)
             This function was called internally inside every analysis function, but that was inefficient, so it must be
			 called manually.
			 Note that when models are generated from a file or string (e.g. sbml), they do not need to be compiled again.
 \param copasi_model model
 \ingroup create
*/
COPASIAPIEXPORT void cCompileModel(copasi_model model);

// -----------------------------------------------------------------------
/** \} */
/**
  * @name Compartment group
  */
/** \{ */

/*!
 \brief Create compartment
 \param char* compartment name
 \param double volume
 \return copasi_compartment a new compartment
 \ingroup create
*/
COPASIAPIEXPORT copasi_compartment cCreateCompartment(copasi_model model, const char* name, double volume);

/*!
 \brief Set a volume of compartment
 \param copasi_model model
 \param char * compartment name
 \param double volume
 \ingroup create
*/
COPASIAPIEXPORT void cSetVolume(copasi_model, const char * compartment, double volume);

/*!
 \brief Get the vector of compartment names and volumes
 \param copasi_model model
 \return c_matrix column vector with compartment names as row names
 \ingroup compartment
*/

COPASIAPIEXPORT c_matrix cGetCompartments (copasi_model);

/*!
 \brief Set all compartment volumes using a vector of compartment values with row names.
            Row names MUST be provided. Order is not important because the row names are used to assign the values, not the index
 \param copasi_model model
 \param double row vector with row names corresponding to the compartment names.
 \ingroup compartment
*/
COPASIAPIEXPORT void cSetCompartmentVolumes (copasi_model, c_matrix v);

/*!
 \brief Get number of compartments. This is same as cGetCompartments(model).cols
 \param copasi_model model
 \return int
 \ingroup compartment
*/
COPASIAPIEXPORT int cGetNumberOfCompartments (copasi_model);

// -----------------------------------------------------------------------
/** \} */
/**
  * @name Assignments (forcing functions)
  */
/** \{ */

/*!
 \brief Set the assignment rule for a species (automatically assumes boundary species)
 \param copasi_model model
 \param char * species name
 \param char* formula, use 0 to remove assignment rule
 \return int 0=failed 1=success

 \code
 result = cSetAssignmentRule (m, "S1", "sin (time*k1)");
 \endcode
 \ingroup create
*/
COPASIAPIEXPORT int cSetAssignmentRule(copasi_model model, const char * species, const char * formula);

/*!
 \brief Create a new variable that is defined by a formula
 \param copasi_model model
 \param char* name of new variable
 \param char* formula
 \return int 0=failed 1=success
 \ingroup create
*/
COPASIAPIEXPORT int cCreateVariable(copasi_model model, const char * name, const char * formula);

// -----------------------------------------------------------------------
/** \} */
/**
  * @name Events
  */
/** \{ */


/*!
 \brief Add a trigger and a response, where the response is defined by a target variable and an assignment formula
 \param copasi_model model
 \param char * event name
 \param char * trigger formula
 \param char * response: name of variable or species
 \param char* response: assignment formula
 \return int 0=failed 1=success

 Example Usage. The following code will create an event where the parameter k1 is halved when time > 10.
 \code
 result = cCreateEvent (m, "myEvent", "time > 10", "k1", "k1/2");
 \endcode
 \ingroup create
*/
COPASIAPIEXPORT int cCreateEvent(copasi_model model, const char * name, const char * trigger, const char * variable, const char * formula);

// -----------------------------------------------------------------------
/** \} */
/**
  * @name Reaction group
  */
/** \{ */

/*!
 \brief Create a new reaction with a given name
 \param copasi_model model
 \param char* reaction name
 \return copasi_reaction a new reaction

 \code
 r = cCreateReaction (m, "J1")
 \endcode
 \ingroup create
*/
COPASIAPIEXPORT copasi_reaction cCreateReaction(copasi_model model, const char* name);


/*!
 \brief Add a reactant to a reaction
 \param copasi_reaction reaction
 \param char * reactant
 \param double stoichiometry

 \code
 cCreateReaction (m, "S1", 1);
 \endcode
 \ingroup create
*/
COPASIAPIEXPORT void cAddReactant(copasi_reaction reaction, const char * species, double stoichiometry);

/*!
 \brief Add a product to a reaction
 \param copasi_reaction reaction
 \param char * product
 \param double stoichiometry

 Create a reaction J1: 2 A -> B + C
 \code
 r = cCreateReaction (m, "J1");
 cAddReactant (r, "A", 2);
 cAddProduct (r, "B", 1);
 cAddProduct (r, "C", 1);
 \endcode

 \ingroup create
*/
COPASIAPIEXPORT void cAddProduct(copasi_reaction reaction, const char * species, double stoichiometry);

/*!
 \brief Set reaction rate equation
 \param copasi_reaction reaction
 \param char* custom formula
 \return int success=1 failure=0

 \code
 int result;
 result = cSetReactionRate (r, "k1*S1");
 \endcode

 \ingroup create
*/
COPASIAPIEXPORT int cSetReactionRate(copasi_reaction reaction, const char * formula);

/*!
 \brief Compute current flux through the given reactions
 \param copasi_model model
 \param string reaction name, e.g. "J1"
 \return double rate. If reaction by this name does not exist that NaN will be returned
  The names of the fluxes are included in the matrix column labels
 \ingroup state
*/
COPASIAPIEXPORT double cGetReactionRate(copasi_model, const char * name);

/*!
 \brief Returns the rates of change given an array of new species concentrations and/or parameter values
 \param copasi_model model
 \param c_matrix vector of floating concentrations. must have row names
 \return c_matrix vector of reaction rates with row names
 \ingroup reaction
*/
COPASIAPIEXPORT c_matrix cGetReactionRatesEx(copasi_model, c_matrix values);

/*!
 \brief Compute current flux through the given reactions
 \param copasi_model model
 \param string reaction name, e.g. "J1"
 \return double rate. If reaction by this name does not exist that NaN will be returned
  The names of the fluxes are included in the matrix column labels
 \ingroup state
*/
COPASIAPIEXPORT double cGetFlux(copasi_model, const char * name);

/*!
 \brief Compute current flux through the given reactions in terms of particles
 \param copasi_model model
 \param string reaction name, e.g. "J1"
 \return double rate. If reaction by this name does not exist that NaN will be returned
 \ingroup state
*/
COPASIAPIEXPORT double cGetParticleFlux(copasi_model, const char * name);

/*!
 \brief Get the list of reaction names and their current fluxes
 \param copasi_model model
 \return c_matrix row vector with column names corresponding to reaction names
 \sa c_matrix
 \ingroup reaction
*/
COPASIAPIEXPORT c_matrix cGetReactionRates(copasi_model);

/*!
 \brief Get number of reactions. This is same as cGetAllFluxes(model).rows
 \param copasi_model model
 \return int
 \ingroup compartment
*/
COPASIAPIEXPORT int cGetNumberOfReactions (copasi_model);

// -----------------------------------------------------------------------
/** \} */
/**
  * @name Species group
  */
/** \{ */

/*!
 \brief Get number of species (all) in the model
 \param copasi_model model
 \param int
 \ingroup create
*/
COPASIAPIEXPORT int cGetNumberOfSpecies(copasi_model);

/*!
 \brief Get number of floating species in the model
 \param copasi_model model
 \param int
 \ingroup create
*/
COPASIAPIEXPORT int cGetNumberOfFloatingSpecies(copasi_model);

/*!
 \brief Get number of boundary species in the model
 \param copasi_model model
 \param int
 \ingroup create
*/
COPASIAPIEXPORT int cGetNumberOfBoundarySpecies(copasi_model);

/*!
 \brief Add a species to the model. Species must belong inside a compartment.
 \param copasi_compartment compartment where the species belongs
 \param char* species name
 \param double initial value (concentration or count, depending on the model)
 \ingroup create
*/
COPASIAPIEXPORT void cCreateSpecies(copasi_compartment compartment, const char* name, double initialValue);

/*!
 \brief Set a species as boundary or floating (will remove any assignment rules)
 \param copasi_model model
  \param char * name
 \param int boundary = 1, floating = 0 (default)
 \ingroup create
*/
COPASIAPIEXPORT void cSetSpeciesType(copasi_model model, const char * species, int isBoundary);

/*!
 \brief Set a species current concentration
 \param copasi_model model
 \param char * species name
 \param double concentration
 \ingroup create
*/
COPASIAPIEXPORT void cSetSpeciesConcentration(copasi_model, const char * species, double conc);

/*!
 \brief Set a species initial concentration
 \param copasi_model model
 \param char * species name
 \param double concentration
 \ingroup create
*/
COPASIAPIEXPORT void cSetInitialConcentration(copasi_model, const char * species, double conc);

/*!
 \brief Set a species amounts
 \param copasi_model model
 \param char * species name
 \param double amount
 \ingroup create
*/
COPASIAPIEXPORT void cSetSpeciesAmount(copasi_model, const char * species, double amount);

/*!
 \brief Set multiple boundary or floating species concentration. Order is not important because the names are used to set value.
 \param copasi_model model
 \param c_matric row vector of boundary or floating species concentrations. rows must be named
 \ingroup boundary
*/
COPASIAPIEXPORT void cSetSpeciesConcentrations (copasi_model model, c_matrix d);

/*!
 \brief Get the initial floating species concentrations
 \param copasi_model model
 \return c_matrix row vector of initial floating species concentrations
 \ingroup floating
*/
COPASIAPIEXPORT c_matrix cGetFloatingSpeciesIntitialConcentrations (copasi_model model);

/*!
 \brief Set the initial floating species concentrations. Order does not matter because row names are used to assign values.
 \param copasi_model model
 \param c_matrix row vector of initial floating species concentrations
 \ingroup floating
*/
COPASIAPIEXPORT void cSetFloatingSpeciesIntitialConcentrations (copasi_model model, c_matrix sp);
/*!
 \brief Get species names and concentrations
 \param copasi_model model
 \param int index ith boundary species
 \return c_matrix column vector where row names are the species names and first column has the concentrations
 \ingroup state
*/
COPASIAPIEXPORT c_matrix cGetAllSpecies(copasi_model model);

/*!
 \brief Get the current concentrations of all floating species
 \param copasi_model model
 \return c_matrix matrix of with 1 row and n columns, where n = number of species
 The names of the species are included in the matrix column labels
 \ingroup state
*/
COPASIAPIEXPORT c_matrix cGetFloatingSpeciesConcentrations(copasi_model);

/*!
 \brief Get the current concentrations of all boundary species
 \param copasi_model model
 \return c_matrix matrix of with 1 row and n columns, where n = number of species
 The names of the species are included in the matrix column labels
 \ingroup state
*/
COPASIAPIEXPORT c_matrix cGetBoundarySpecies(copasi_model);

/*!
 \brief Get the current amounts of all species. The amounts are calculated from the concentrations and compartment volume
 \param copasi_model model
 \return c_matrix matrix of with 1 row and n columns, where n = number of species
 The names of the species are included in the matrix column labels
 \ingroup state
*/
COPASIAPIEXPORT c_matrix cGetAmounts(copasi_model);

/*!
 \brief Get the current concentration of a species
 \param copasi_model model
 \param string species name
 \return double concentration. -1 indicates that a species by this name was not found
 \ingroup state
*/
COPASIAPIEXPORT double cGetConcentration(copasi_model, const char * name);

/*!
 \brief Get the current amount of a species. The amounts are calculated from the concentrations and compartment volume
 \param copasi_model model
 \param string species name
 \return double amount. -1 indicates that a species by this name was not found
 \ingroup state
*/
COPASIAPIEXPORT double cGetAmount(copasi_model, const char * name);


// -----------------------------------------------------------------------
/** \} */
/**
  * @name Parameter group
  */
/** \{ */

/*!
 \brief Set the concentration of a species, volume of a compartment, or value of a parameter
      The function will figure out which using the name (fast lookup using hashtables).
      If the name does not exist in the model, a new global parameter will be created.
 \param copasi_model model
 \param char * name
 \param double value
 \return 0 if new variable was created. 1 if existing variable was found
 \ingroup create
*/
COPASIAPIEXPORT int cSetValue(copasi_model, const char * name, double value);

/*!
 \brief Get the concentration of a species, volume of a compartment, or value of a parameter
      The function will figure out which using the name (fast lookup using hashtables).
 \param copasi_model model
 \param char * name
 \return double value of species, parameters, or compartment
 \ingroup create
*/
COPASIAPIEXPORT double cGetValue(copasi_model, const char * names);

/*!
 \brief Set the value of an existing global parameter or create a new global parameter
 \param copasi_model model
 \param char* parameter name
 \param double value
  \return int 0=new value created 1=found existing value
 \ingroup create
*/
COPASIAPIEXPORT int cSetGlobalParameter(copasi_model model, const char * name, double value);

/*!
 \brief Get the number of of global parameter names
 \param copasi_model model
 \return int
 \ingroup parameter
*/
COPASIAPIEXPORT int cGetNumberOfGlobalParameters (copasi_model);

/*!
 \brief Get the list of global parameter names and values
 \param copasi_model model
 \return c_matrix column vector with parameter names are the row names
 \ingroup parameter
*/
COPASIAPIEXPORT c_matrix cGetGlobalParameters (copasi_model);

/*!
 \brief Set the vector of global parameters
 \param copasi_model model
 \paramn c_matrix column vector containing the values for the global parameters.
 \ingroup parameter
*/
COPASIAPIEXPORT void cSetGlobalParameterValues(copasi_model, c_matrix gp);

/*!
 \brief Set values for species, parameters, or compartments
 \param copasi_model model
 \param c_matrix column vector with names and values of species or parameters or compartments
 \ingroup floating
*/
COPASIAPIEXPORT void cSetValues(copasi_model model, c_matrix );


// -----------------------------------------------------------------------
/** \} */
/**
  * @name Time course simulation
  */
/** \{ */

/*!
 \brief Compute the current rates of change for all species
 \param copasi_model model
 \return c_matrix matrix of with 1 row and n columns, where n = number of species
 \ingroup rateOfChange
*/
COPASIAPIEXPORT c_matrix cGetRatesOfChange(copasi_model);

/*!
 \brief Compute the current rates of change for one species
 \param copasi_model model
 \param string name of species
 \return c_matrix matrix of with 1 row and n columns, where n = number of species
 \ingroup rateOfChange
*/
COPASIAPIEXPORT double cGetRateOfChange(copasi_model, const char * species);

/*!
 \brief Compute the rates of change for all species after updating species concentrations
 \param copasi_model model
 \param c_matrix new species concentrations
 \return c_matrix matrix of with 1 row and n columns, where n = number of species
 \ingroup rateOfChange
*/
COPASIAPIEXPORT c_matrix cGetRatesOfChangeEx(copasi_model, c_matrix);

/*!
 \brief Simulate using LSODA numerical integrator
 \param copasi_model model
  \param double start time
 \param double end time
 \param int number of steps in the output
 \return c_matrix matrix of concentration or particles

 \code
 result = cSimulateDeterministic (m, 0.0, 10.0, 100);
 \endcode
 \ingroup simulation
*/
COPASIAPIEXPORT c_matrix cSimulateDeterministic(copasi_model model, double startTime, double endTime, int numSteps);


/*!
 \brief Simulate the differential equation model over one time step
 \param copasi_model model
 \param double time step
 \return double new time, i.e (current time + timeStep)
 \ingroup simulation
*/
COPASIAPIEXPORT double cOneStep(copasi_model model, double timeStep);

/*!
 \brief Simulate using exact stochastic algorithm
 \param copasi_model model
 \param double start time
 \param double end time
 \param int number of steps in the output
 \return c_matrix matrix of concentration or particles
 \ingroup simulation
*/
COPASIAPIEXPORT c_matrix cSimulateStochastic(copasi_model model, double startTime, double endTime, int numSteps);

/*!
 \brief Simulate using Hybrid algorithm/deterministic algorithm
 \param copasi_model model
  \param double start time
 \param double end time
 \param int number of steps in the output
 \return c_matrix matrix of concentration or particles
 \ingroup simulation
*/
COPASIAPIEXPORT c_matrix cSimulateHybrid(copasi_model model, double startTime, double endTime, int numSteps);

/*!
 \brief Simulate using Tau Leap stochastic algorithm
 \param copasi_model model
  \param double start time
 \param double end time
 \param int number of steps in the output
 \return c_matrix matrix of concentration or particles
 \ingroup simulation
*/
COPASIAPIEXPORT c_matrix cSimulateTauLeap(copasi_model model, double startTime, double endTime, int numSteps);

/*!
 \brief set current state to initial state
 \ingroup simulation
*/
COPASIAPIEXPORT void cResetState(copasi_model);

// -----------------------------------------------------------------------
/** \} */
/**
  * @name Create filters for time-course data
  */
/** \{ */

/*!
 \brief Compute all the reaction rates, or flux, for each row of a time course data
 \param copasi_model model
  \param c_matrix original results with species as column names
 \return c_matrix
 \ingroup simulation
*/
COPASIAPIEXPORT c_matrix cGetReactionRatesFromTimeCourse(copasi_model model, c_matrix results);

/*!
 \brief Compute derivatives for each species from the time course data
 \param copasi_model model
  \param c_matrix original results with species as column names
 \return c_matrix
 \ingroup simulation
*/
COPASIAPIEXPORT c_matrix cGetDerivativesFromTimeCourse(copasi_model model, c_matrix results);

/*!
 \brief Get all the control coefficients for each row of a time course data
 \param copasi_model model
  \param c_matrix original results with species as column names
 \return c_matrix
 \ingroup simulation
*/
COPASIAPIEXPORT c_matrix cGetCCFromTimeCourse(copasi_model model, c_matrix results);

/*!
 \brief Get all the elasticities for each row of a time course data
 \param copasi_model model
  \param c_matrix original results with species as column names
 \return c_matrix
 \ingroup simulation
*/
COPASIAPIEXPORT c_matrix cGetElasticitiesFromTimeCourse(copasi_model model, c_matrix results);

/*!
 \brief Filter the results of a time-course simulation based on the list of names provided. -- NOT IMPLEMENTED
 		   The list of names can consist of species names, reaction names, control coefficients, or derivatives.
           Use species or reaction names to add a species of reaction
		   Use species' for derivatives, e.g. A' for derivative of A
		   Use cc_(x)_y for the control coefficient of x on y
		   Use elasticities_(x)_y for the scaled elasticity of x wrt y
 \param copasi_model model
  \param c_matrix original results with species as column names
  \param c_strings array of names to return
 \return c_matrix
 \ingroup simulation
*/
COPASIAPIEXPORT c_matrix cFilterTimeCourseResults(copasi_model model, c_matrix results, c_strings names);


// -----------------------------------------------------------------------
/** \} */
/**
  * @name Steady state analysis
  */
/** \{ */


/*!
 \brief Bring the system to steady state by solving for the zeros of the ODE's.
             Performs an initial simulation before solving.
 \param copasi_model model
 \return c_matrix matrix with 1 row and n columns, where n = number of species
 \ingroup steadystate
*/
COPASIAPIEXPORT c_matrix cGetSteadyState(copasi_model model);

/*!
 \brief Bring the system to steady state by doing repeated simulations.
             Use this is cGetSteadyState
 \param copasi_model model
 \param int max iterations (each iteration doubles the time duration)
 \return c_matrix matrix with 1 row and n columns, where n = number of species
 \ingroup steadystate
*/
COPASIAPIEXPORT c_matrix cGetSteadyStateUsingSimulation(copasi_model model, int iter);

/*!
 \brief Set the epsilon value (small positive number) that is used in a few functions, e.g.
            cGetJacobian, to perform small perturbations
 \param double new epsilon value, default is 1E-3
 \return double updated epsilon value (should be same as argument if >0)
 \ingroup steadystate
*/
COPASIAPIEXPORT double cSetEpsilon(double eps);

/*!
 \brief Get the full Jacobian at the current state
 \param copasi_model model
 \return c_matrix matrix with n rows and n columns, where n = number of species
 \ingroup steadystate
*/
COPASIAPIEXPORT c_matrix cGetJacobian(copasi_model model);
/*!
 \brief Get the eigenvalues of the Jacobian at the current state
 \param copasi_model model
 \return c_matrix matrix with 1 row and n columns, each containing an eigenvalue
 \ingroup steadystate
*/
COPASIAPIEXPORT c_matrix cGetEigenvalues(copasi_model model);


// -----------------------------------------------------------------------
/** \} */
/**
  * @name Metabolic control analysis (MCA)
  */
/** \{ */


/*!
 \brief Compute the unscaled flux control coefficients
 \param copasi_model model
 \return c_matrix rows consist of the fluxes that are perturbed, and columns consist
                             of the fluxes that are affected
 \ingroup mca
*/
COPASIAPIEXPORT c_matrix cGetUnscaledFluxControlCoeffs(copasi_model model);


/*!
 \brief Compute the scaled flux control coefficients
 \param copasi_model model
 \return c_matrix rows consist of the fluxes that are perturbed, and columns consist
                             of the fluxes that are affected
 \ingroup mca
*/
COPASIAPIEXPORT c_matrix cGetScaledFluxControlCoeffs(copasi_model model);


/*!
 \brief Compute the unscaled concentration control coefficients
 \param copasi_model model
 \return c_matrix rows consist of the fluxes that are perturbed, and columns consist
                             of the concentrations that are affected
 \ingroup mca
*/
COPASIAPIEXPORT c_matrix cGetUnscaledConcentrationControlCoeffs(copasi_model model);


/*!
 \brief Compute the scaled concentration control coefficients
 \param copasi_model model
 \return c_matrix rows consist of the fluxes that are perturbed, and columns consist
                             of the concentrations that are affected
 \ingroup mca
*/
COPASIAPIEXPORT c_matrix cGetScaledConcentrationConcentrationCoeffs(copasi_model model);


/*!
 \brief Compute the unscaled elasticities
 \param copasi_model model
 \return c_matrix rows consist of the species that are perturbed, and columns consist
                             of the reactions that are affected
 \ingroup mca
*/
COPASIAPIEXPORT c_matrix cGetUnscaledElasticities(copasi_model model);


/*!
 \brief Compute the scaled elasticities
 \param copasi_model model
 \return c_matrix rows consist of the species that are perturbed, and columns consist
                             of the reactions that are affected
 \ingroup mca
*/
COPASIAPIEXPORT c_matrix cGetScaledElasticities(copasi_model model);


// -----------------------------------------------------------------------
/** \} */
/**
  * @name Stoichiometry matrix and matrix analysis
  */
/** \{ */


/*!
 \brief Return the full stoichiometry matrix, N
 \param copasi_model model
 \return c_matrix rows consist of the species and columns are the reactions
 \ingroup matrix
*/
COPASIAPIEXPORT c_matrix cGetFullStoichiometryMatrix(copasi_model model);


/*!
 \brief Return the reduced stoichiometry matrix, Nr
 \param copasi_model model
 \return c_matrix rows consist of the species and columns are the reactions
 \ingroup matrix
*/
COPASIAPIEXPORT c_matrix cGetReducedStoichiometryMatrix(copasi_model model);


/*!
 \brief Compute the elementary flux modes
 \param copasi_model model
 \return c_matrix matrix with reactions as rows and flux modes as columns (no column names)
 \ingroup matrix
*/
COPASIAPIEXPORT c_matrix cGetElementaryFluxModes(copasi_model model);


/*!
 \brief Compute the Gamma matrix (i.e. conservation laws)
 \param copasi_model model
 \return c_matrix
 \ingroup matrix
*/
COPASIAPIEXPORT c_matrix cGetGammaMatrix(copasi_model model);


/*!
 \brief Compute the K matrix (right nullspace)
 \param copasi_model model
 \return c_matrix
 \ingroup matrix
*/
COPASIAPIEXPORT c_matrix cGetKMatrix(copasi_model model);


/*!
 \brief Compute the K0 matrix
 \param copasi_model model
 \return c_matrix
 \ingroup matrix
*/
COPASIAPIEXPORT c_matrix cGetK0Matrix(copasi_model model);


/*!
 \brief Compute the L matrix (link matrix, left nullspace)
 \param copasi_model model
 \return c_matrix
 \ingroup matrix
*/
COPASIAPIEXPORT c_matrix cGetLinkMatrix(copasi_model model);


/*!
 \brief Compute the L0 matrix
 \param copasi_model model
 \return c_matrix
 \ingroup matrix
*/
COPASIAPIEXPORT c_matrix cGetL0Matrix(copasi_model model);


// -----------------------------------------------------------------------
/** \} */
/**
  * @name Optimization
  */
/** \{ */


/*!
 \brief fit the model parameters to time-series data
 \param copasi_model model
 \param char * filename (tab separated)
 \param c_matrix parameters to optimize. rownames should contain parameter names, column 1 contains parameter min-values, and column 2 contains parameter max values
 \param char * pick method. Use of of the following: "GeneticAlgorithm", "LevenbergMarquardt", "SimulatedAnnealing", "NelderMead", "SRES", "ParticleSwarm", "SteepestDescent", "RandomSearch"
 \ingroup matrix
*/
//COPASIAPIEXPORT void cFitModelToData(copasi_model model, const char * filename, c_matrix params, const char * method);

/*!
 \brief use genetic algorithms to generate a distribution of parameter values that satisfy an objective function or fit a data file
 \param copasi_model model
 \param char * objective function or filename
 \param c_matrix parameter initial values and min and max values (3 columns)
 \return c_matrix optimized parameters as a column vector
 \ingroup optim
*/
COPASIAPIEXPORT c_matrix cOptimize(copasi_model model, const char * objective, c_matrix input);

/*!
 \brief set the number of iterations for the genetic algorithm based optimizer
 \param int iterations
 \ingroup optim
*/
COPASIAPIEXPORT void cSetOptimizerIterations(int);

/*!
 \brief set the number of random seeds for the genetic algorithm based optimizer
 \param int population size
 \ingroup optim
*/
COPASIAPIEXPORT void cSetOptimizerSize(int);

/*!
 \brief set the mutation rate, or step size, for the genetic algorithm based optimizer
 \param double
 \ingroup optim
*/
COPASIAPIEXPORT void cSetOptimizerMutationRate(double);

/*!
 \brief set the probability of crossover for the genetic algorithm based optimizer
 \param double must be between 0 and 1
 \ingroup optim
*/
COPASIAPIEXPORT void cSetOptimizerCrossoverRate(double);

/*!
 \brief do not modify assignment rules
             warning: disabling this may cause numerical errors in time-course simulations
 \ingroup cleanup
*/
COPASIAPIEXPORT void cDisableAssignmentRuleReordering();

/*!
 \brief Fit parameters to time-series data in a file (comma-separated or tab-separated)
 \param copasi_model model
 \param string file containing the target data
 \param c_matrix column matrix containing the names and initial values of just the parameters that need to be optimized
 \param string name of the algorithm to use. The options are:
                  geneticalgorithm,
                  simulatedannealing,
                  levenbergmarquardt,
                  neldermead,
                  sres,
                  particleswarm,
                  steepestdescent,
                  randomsearch
 \ingroup optim
*/
COPASIAPIEXPORT void cFitModelToData(copasi_model model, const char * filename, c_matrix params, const char * method);

/*!
 \brief Optimize parameters to maximize the given formula
 \param copasi_model model
 \param string formula
 \param c_matrix column matrix containing the names and initial values of just the parameters that need to be optimized
 \param string name of the algorithm to use. The options are:
            "Random Search",
				  "Random Search (PVM)",
				  "Simulated Annealing",
				  "Genetic Algorithm",
				  "Evolutionary Programming",
				  "Steepest Descent",
				  "Hybrid GA/SA",
				  "Genetic Algorithm SR",
				  "Hooke & Jeeves",
				  "Levenberg - Marquardt",
				  "Nelder - Mead",
				  "Evolution Strategy (SRES)",
				  "Particle Swarm",
				  "Praxis",
				  "Truncated Newton",
				  "Enhanced Newton"
 \return double optimized value of the formula. 0 usually indicates an error
 \ingroup optim
*/
COPASIAPIEXPORT double cMaximize(copasi_model model, const char * formula);

/*!
 \brief set the optimization method for all optimization routines
 \param string name of the algorithm to use. The options are:
            "Random Search",
				  "Random Search (PVM)",
				  "Simulated Annealing",
				  "Genetic Algorithm",
				  "Evolutionary Programming",
				  "Steepest Descent",
				  "Hybrid GA/SA",
				  "Genetic Algorithm SR",
				  "Hooke & Jeeves",
				  "Levenberg - Marquardt",
				  "Nelder - Mead",
				  "Evolution Strategy (SRES)",
				  "Particle Swarm",
				  "Praxis",
				  "Truncated Newton",
				  "Enhanced Newton"
 \ingroup optim
*/
COPASIAPIEXPORT int cSetOptimizationMethod(const char * method);

/*!
 \brief Optimize parameters to minimize the given formula
 \param copasi_model model
 \param string formula
 \param c_matrix column matrix containing the names and initial values of just the parameters that need to be optimized
 \param string name of the algorithm to use. The options are:
                  "Random Search",
				  "Random Search (PVM)",
				  "Simulated Annealing",
				  "Genetic Algorithm",
				  "Evolutionary Programming",
				  "Steepest Descent",
				  "Hybrid GA/SA",
				  "Genetic Algorithm SR",
				  "Hooke & Jeeves",
				  "Levenberg - Marquardt",
				  "Nelder - Mead",
				  "Evolution Strategy (SRES)",
				  "Particle Swarm",
				  "Praxis",
				  "Truncated Newton",
				  "Enhanced Newton"
 \return double optimized value of the formula. 0 usually indicates an error
 \ingroup optim
*/
COPASIAPIEXPORT double cMinimize(copasi_model model, const char * formula, c_matrix params, const char * method);

/*!
 \brief modify assignment rules to avoid dependencies between assignment rules (default)
 \ingroup cleanup
*/
COPASIAPIEXPORT void cEnableAssignmentRuleReordering();

/*!
 \brief repeat deterministic simulation multiple times, where a paramater is incremented during each repeated iteration
 \param const char * name of parameter to change
 \param double start value for the parameter
 \param double final value for the parameter
 \param int number of steps in-between start and end
 \param double start time for the simulation
 \param double end time for the simulation
 \param int number of steps in-between start and end
 \return c_matrix matrix with
 \ingroup optim
*/
//COPASIAPIEXPORT c_matrix cSimulationParameterScan(copasi_model model, const char * param, double start, double end, int numSteps, double startTime, double endTime, int numTimeSteps);

/*!
 \brief repeat steady state calculation multiple times, where a paramater is incremented during each repeated iteration
 \param const char * name of parameter to change
 \param double start value for the parameter
 \param double final value for the parameter
 \param int number of steps in-between start and end
 \return c_matrix first column will be the changed parameter values
              and the rest of the columns will contain the steady state values for that parameter value
 \ingroup optim
*/
//COPASIAPIEXPORT c_matrix cSteadyStateParameterScan(copasi_model model, const char * param, double start, double end, int numsteps);

COPASIAPIEXPORT double runif(double min, double max);

COPASIAPIEXPORT int main1();
extern const char * MODEL_STRING;
END_C_DECLS
#endif