Skip to content

GitLab

Commit 8381aaa8 authored by peastman's avatar peastman
Browse files

Fixed compilation errors on Windows

parent 47a5e2a4
Hide whitespace changes
Inline Side-by-side
Showing with 265 additions and 259 deletions
platforms/reference/src/ReferenceTabulatedFunction.cpp
View file @ 8381aaa8
/* -------------------------------------------------------------------------- * /* -------------------------------------------------------------------------- *
* OpenMM * * OpenMM *
* -------------------------------------------------------------------------- * * -------------------------------------------------------------------------- *
* This is part of the OpenMM molecular simulation toolkit originating from * * This is part of the OpenMM molecular simulation toolkit originating from *
* Simbios, the NIH National Center for Physics-Based Simulation of * * Simbios, the NIH National Center for Physics-Based Simulation of *
* Biological Structures at Stanford, funded under the NIH Roadmap for * * Biological Structures at Stanford, funded under the NIH Roadmap for *
* Medical Research, grant U54 GM072970. See https://simtk.org. * * Medical Research, grant U54 GM072970. See https://simtk.org. *
* * * *
* Portions copyright (c) 2014 Stanford University and the Authors. * * Portions copyright (c) 2014 Stanford University and the Authors. *
* Authors: Peter Eastman * * Authors: Peter Eastman *
* Contributors: * * Contributors: *
* * * *
* Permission is hereby granted, free of charge, to any person obtaining a * * Permission is hereby granted, free of charge, to any person obtaining a *
* copy of this software and associated documentation files (the "Software"), * * copy of this software and associated documentation files (the "Software"), *
* to deal in the Software without restriction, including without limitation * * to deal in the Software without restriction, including without limitation *
* the rights to use, copy, modify, merge, publish, distribute, sublicense, * * the rights to use, copy, modify, merge, publish, distribute, sublicense, *
* and/or sell copies of the Software, and to permit persons to whom the * * 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: * * Software is furnished to do so, subject to the following conditions: *
* * * *
* The above copyright notice and this permission notice shall be included in * * The above copyright notice and this permission notice shall be included in *
* all copies or substantial portions of the Software. * * all copies or substantial portions of the Software. *
* * * *
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *
* THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, *
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR *
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE * * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE *
* USE OR OTHER DEALINGS IN THE SOFTWARE. * * USE OR OTHER DEALINGS IN THE SOFTWARE. *
* -------------------------------------------------------------------------- */ * -------------------------------------------------------------------------- */
#include "ReferenceTabulatedFunction.h" #include "ReferenceTabulatedFunction.h"
#include "openmm/OpenMMException.h" #include "openmm/OpenMMException.h"
#include "openmm/internal/SplineFitter.h" #include "openmm/internal/SplineFitter.h"
#include <cmath>
using namespace OpenMM;
using namespace OpenMM; using namespace std;
using namespace std; using Lepton::CustomFunction;
using Lepton::CustomFunction;
/**
extern "C" CustomFunction* createReferenceTabulatedFunction(const TabulatedFunction& function) { * We need to define this ourselves, since Visual Studio is missing round() from cmath.
if (dynamic_cast<const Continuous1DFunction*>(&function) != NULL) */
return new ReferenceContinuous1DFunction(dynamic_cast<const Continuous1DFunction&>(function)); static int round(double x) {
if (dynamic_cast<const Continuous2DFunction*>(&function) != NULL) return (int) (x+0.5);
return new ReferenceContinuous2DFunction(dynamic_cast<const Continuous2DFunction&>(function)); }
if (dynamic_cast<const Continuous3DFunction*>(&function) != NULL)
return new ReferenceContinuous3DFunction(dynamic_cast<const Continuous3DFunction&>(function)); extern "C" CustomFunction* createReferenceTabulatedFunction(const TabulatedFunction& function) {
if (dynamic_cast<const Discrete1DFunction*>(&function) != NULL) if (dynamic_cast<const Continuous1DFunction*>(&function) != NULL)
return new ReferenceDiscrete1DFunction(dynamic_cast<const Discrete1DFunction&>(function)); return new ReferenceContinuous1DFunction(dynamic_cast<const Continuous1DFunction&>(function));
if (dynamic_cast<const Discrete2DFunction*>(&function) != NULL) if (dynamic_cast<const Continuous2DFunction*>(&function) != NULL)
return new ReferenceDiscrete2DFunction(dynamic_cast<const Discrete2DFunction&>(function)); return new ReferenceContinuous2DFunction(dynamic_cast<const Continuous2DFunction&>(function));
if (dynamic_cast<const Discrete3DFunction*>(&function) != NULL) if (dynamic_cast<const Continuous3DFunction*>(&function) != NULL)
return new ReferenceDiscrete3DFunction(dynamic_cast<const Discrete3DFunction&>(function)); return new ReferenceContinuous3DFunction(dynamic_cast<const Continuous3DFunction&>(function));
throw OpenMMException("createReferenceTabulatedFunction: Unknown function type"); if (dynamic_cast<const Discrete1DFunction*>(&function) != NULL)
} return new ReferenceDiscrete1DFunction(dynamic_cast<const Discrete1DFunction&>(function));
if (dynamic_cast<const Discrete2DFunction*>(&function) != NULL)
ReferenceContinuous1DFunction::ReferenceContinuous1DFunction(const Continuous1DFunction& function) : function(function) { return new ReferenceDiscrete2DFunction(dynamic_cast<const Discrete2DFunction&>(function));
function.getFunctionParameters(values, min, max); if (dynamic_cast<const Discrete3DFunction*>(&function) != NULL)
int numValues = values.size(); return new ReferenceDiscrete3DFunction(dynamic_cast<const Discrete3DFunction&>(function));
x.resize(numValues); throw OpenMMException("createReferenceTabulatedFunction: Unknown function type");
for (int i = 0; i < numValues; i++) }
x[i] = min+i*(max-min)/(numValues-1);
SplineFitter::createNaturalSpline(x, values, derivs); ReferenceContinuous1DFunction::ReferenceContinuous1DFunction(const Continuous1DFunction& function) : function(function) {
} function.getFunctionParameters(values, min, max);
int numValues = values.size();
int ReferenceContinuous1DFunction::getNumArguments() const { x.resize(numValues);
return 1; for (int i = 0; i < numValues; i++)
} x[i] = min+i*(max-min)/(numValues-1);
SplineFitter::createNaturalSpline(x, values, derivs);
double ReferenceContinuous1DFunction::evaluate(const double* arguments) const { }
double t = arguments[0];
if (t < min || t > max) int ReferenceContinuous1DFunction::getNumArguments() const {
return 0.0; return 1;
return SplineFitter::evaluateSpline(x, values, derivs, t); }
}
double ReferenceContinuous1DFunction::evaluate(const double* arguments) const {
double ReferenceContinuous1DFunction::evaluateDerivative(const double* arguments, const int* derivOrder) const { double t = arguments[0];
double t = arguments[0]; if (t < min || t > max)
if (t < min || t > max) return 0.0;
return 0.0; return SplineFitter::evaluateSpline(x, values, derivs, t);
return SplineFitter::evaluateSplineDerivative(x, values, derivs, t); }
}
double ReferenceContinuous1DFunction::evaluateDerivative(const double* arguments, const int* derivOrder) const {
CustomFunction* ReferenceContinuous1DFunction::clone() const { double t = arguments[0];
return new ReferenceContinuous1DFunction(function); if (t < min || t > max)
} return 0.0;
return SplineFitter::evaluateSplineDerivative(x, values, derivs, t);
ReferenceContinuous2DFunction::ReferenceContinuous2DFunction(const Continuous2DFunction& function) : function(function) { }
function.getFunctionParameters(xsize, ysize, values, xmin, xmax, ymin, ymax);
x.resize(xsize); CustomFunction* ReferenceContinuous1DFunction::clone() const {
y.resize(ysize); return new ReferenceContinuous1DFunction(function);
for (int i = 0; i < xsize; i++) }
x[i] = xmin+i*(xmax-xmin)/(xsize-1);
for (int i = 0; i < ysize; i++) ReferenceContinuous2DFunction::ReferenceContinuous2DFunction(const Continuous2DFunction& function) : function(function) {
y[i] = ymin+i*(ymax-ymin)/(ysize-1); function.getFunctionParameters(xsize, ysize, values, xmin, xmax, ymin, ymax);
SplineFitter::create2DNaturalSpline(x, y, values, c); x.resize(xsize);
} y.resize(ysize);
for (int i = 0; i < xsize; i++)
int ReferenceContinuous2DFunction::getNumArguments() const { x[i] = xmin+i*(xmax-xmin)/(xsize-1);
return 2; for (int i = 0; i < ysize; i++)
} y[i] = ymin+i*(ymax-ymin)/(ysize-1);
SplineFitter::create2DNaturalSpline(x, y, values, c);
double ReferenceContinuous2DFunction::evaluate(const double* arguments) const { }
double u = arguments[0];
if (u < xmin || u > xmax) int ReferenceContinuous2DFunction::getNumArguments() const {
return 0.0; return 2;
double v = arguments[1]; }
if (v < ymin || v > ymax)
return 0.0; double ReferenceContinuous2DFunction::evaluate(const double* arguments) const {
return SplineFitter::evaluate2DSpline(x, y, values, c, u, v); double u = arguments[0];
} if (u < xmin || u > xmax)
return 0.0;
double ReferenceContinuous2DFunction::evaluateDerivative(const double* arguments, const int* derivOrder) const { double v = arguments[1];
double u = arguments[0]; if (v < ymin || v > ymax)
if (u < xmin || u > xmax) return 0.0;
return 0.0; return SplineFitter::evaluate2DSpline(x, y, values, c, u, v);
double v = arguments[1]; }
if (v < ymin || v > ymax)
return 0.0; double ReferenceContinuous2DFunction::evaluateDerivative(const double* arguments, const int* derivOrder) const {
double dx, dy; double u = arguments[0];
SplineFitter::evaluate2DSplineDerivatives(x, y, values, c, u, v, dx, dy); if (u < xmin || u > xmax)
if (derivOrder[0] == 1 && derivOrder[1] == 0) return 0.0;
return dx; double v = arguments[1];
if (derivOrder[0] == 0 && derivOrder[1] == 1) if (v < ymin || v > ymax)
return dy; return 0.0;
throw OpenMMException("ReferenceContinuous2DFunction: Unsupported derivative order"); double dx, dy;
} SplineFitter::evaluate2DSplineDerivatives(x, y, values, c, u, v, dx, dy);
if (derivOrder[0] == 1 && derivOrder[1] == 0)
CustomFunction* ReferenceContinuous2DFunction::clone() const { return dx;
return new ReferenceContinuous2DFunction(function); if (derivOrder[0] == 0 && derivOrder[1] == 1)
} return dy;
throw OpenMMException("ReferenceContinuous2DFunction: Unsupported derivative order");
ReferenceContinuous3DFunction::ReferenceContinuous3DFunction(const Continuous3DFunction& function) : function(function) { }
function.getFunctionParameters(xsize, ysize, zsize, values, xmin, xmax, ymin, ymax, zmin, zmax);
x.resize(xsize); CustomFunction* ReferenceContinuous2DFunction::clone() const {
y.resize(ysize); return new ReferenceContinuous2DFunction(function);
z.resize(zsize); }
for (int i = 0; i < xsize; i++)
x[i] = xmin+i*(xmax-xmin)/(xsize-1); ReferenceContinuous3DFunction::ReferenceContinuous3DFunction(const Continuous3DFunction& function) : function(function) {
for (int i = 0; i < ysize; i++) function.getFunctionParameters(xsize, ysize, zsize, values, xmin, xmax, ymin, ymax, zmin, zmax);
y[i] = ymin+i*(ymax-ymin)/(ysize-1); x.resize(xsize);
for (int i = 0; i < zsize; i++) y.resize(ysize);
z[i] = zmin+i*(zmax-zmin)/(zsize-1); z.resize(zsize);
SplineFitter::create3DNaturalSpline(x, y, z, values, c); for (int i = 0; i < xsize; i++)
} x[i] = xmin+i*(xmax-xmin)/(xsize-1);
for (int i = 0; i < ysize; i++)
int ReferenceContinuous3DFunction::getNumArguments() const { y[i] = ymin+i*(ymax-ymin)/(ysize-1);
return 3; for (int i = 0; i < zsize; i++)
} z[i] = zmin+i*(zmax-zmin)/(zsize-1);
SplineFitter::create3DNaturalSpline(x, y, z, values, c);
double ReferenceContinuous3DFunction::evaluate(const double* arguments) const { }
double u = arguments[0];
if (u < xmin || u > xmax) int ReferenceContinuous3DFunction::getNumArguments() const {
return 0.0; return 3;
double v = arguments[1]; }
if (v < ymin || v > ymax)
return 0.0; double ReferenceContinuous3DFunction::evaluate(const double* arguments) const {
double w = arguments[2]; double u = arguments[0];
if (w < zmin || w > zmax) if (u < xmin || u > xmax)
return 0.0; return 0.0;
return SplineFitter::evaluate3DSpline(x, y, z, values, c, u, v, w); double v = arguments[1];
} if (v < ymin || v > ymax)
return 0.0;
double ReferenceContinuous3DFunction::evaluateDerivative(const double* arguments, const int* derivOrder) const { double w = arguments[2];
double u = arguments[0]; if (w < zmin || w > zmax)
if (u < xmin || u > xmax) return 0.0;
return 0.0; return SplineFitter::evaluate3DSpline(x, y, z, values, c, u, v, w);
double v = arguments[1]; }
if (v < ymin || v > ymax)
return 0.0; double ReferenceContinuous3DFunction::evaluateDerivative(const double* arguments, const int* derivOrder) const {
double w = arguments[2]; double u = arguments[0];
if (w < zmin || w > zmax) if (u < xmin || u > xmax)
return 0.0; return 0.0;
double dx, dy, dz; double v = arguments[1];
SplineFitter::evaluate3DSplineDerivatives(x, y, z, values, c, u, v, w, dx, dy, dz); if (v < ymin || v > ymax)
if (derivOrder[0] == 1 && derivOrder[1] == 0 && derivOrder[2] == 0) return 0.0;
return dx; double w = arguments[2];
if (derivOrder[0] == 0 && derivOrder[1] == 1 && derivOrder[2] == 0) if (w < zmin || w > zmax)
return dy; return 0.0;
if (derivOrder[0] == 0 && derivOrder[1] == 0 && derivOrder[2] == 1) double dx, dy, dz;
return dz; SplineFitter::evaluate3DSplineDerivatives(x, y, z, values, c, u, v, w, dx, dy, dz);
throw OpenMMException("ReferenceContinuous3DFunction: Unsupported derivative order"); if (derivOrder[0] == 1 && derivOrder[1] == 0 && derivOrder[2] == 0)
} return dx;
if (derivOrder[0] == 0 && derivOrder[1] == 1 && derivOrder[2] == 0)
CustomFunction* ReferenceContinuous3DFunction::clone() const { return dy;
return new ReferenceContinuous3DFunction(function); if (derivOrder[0] == 0 && derivOrder[1] == 0 && derivOrder[2] == 1)
} return dz;
throw OpenMMException("ReferenceContinuous3DFunction: Unsupported derivative order");
ReferenceDiscrete1DFunction::ReferenceDiscrete1DFunction(const Discrete1DFunction& function) : function(function) { }
function.getFunctionParameters(values);
} CustomFunction* ReferenceContinuous3DFunction::clone() const {
return new ReferenceContinuous3DFunction(function);
int ReferenceDiscrete1DFunction::getNumArguments() const { }
return 1;
} ReferenceDiscrete1DFunction::ReferenceDiscrete1DFunction(const Discrete1DFunction& function) : function(function) {
function.getFunctionParameters(values);
double ReferenceDiscrete1DFunction::evaluate(const double* arguments) const { }
int i = (int) round(arguments[0]);
if (i < 0 || i >= values.size()) int ReferenceDiscrete1DFunction::getNumArguments() const {
throw OpenMMException("ReferenceDiscrete1DFunction: argument out of range"); return 1;
return values[i]; }
}
double ReferenceDiscrete1DFunction::evaluate(const double* arguments) const {
double ReferenceDiscrete1DFunction::evaluateDerivative(const double* arguments, const int* derivOrder) const { int i = round(arguments[0]);
return 0.0; if (i < 0 || i >= values.size())
} throw OpenMMException("ReferenceDiscrete1DFunction: argument out of range");
return values[i];
CustomFunction* ReferenceDiscrete1DFunction::clone() const { }
return new ReferenceDiscrete1DFunction(function);
} double ReferenceDiscrete1DFunction::evaluateDerivative(const double* arguments, const int* derivOrder) const {
return 0.0;
ReferenceDiscrete2DFunction::ReferenceDiscrete2DFunction(const Discrete2DFunction& function) : function(function) { }
function.getFunctionParameters(xsize, ysize, values);
} CustomFunction* ReferenceDiscrete1DFunction::clone() const {
return new ReferenceDiscrete1DFunction(function);
int ReferenceDiscrete2DFunction::getNumArguments() const { }
return 2;
} ReferenceDiscrete2DFunction::ReferenceDiscrete2DFunction(const Discrete2DFunction& function) : function(function) {
function.getFunctionParameters(xsize, ysize, values);
double ReferenceDiscrete2DFunction::evaluate(const double* arguments) const { }
int i = (int) round(arguments[0]);
int j = (int) round(arguments[1]); int ReferenceDiscrete2DFunction::getNumArguments() const {
if (i < 0 || i >= xsize || j < 0 || j >= ysize) return 2;
throw OpenMMException("ReferenceDiscrete2DFunction: argument out of range"); }
return values[i+j*xsize];
} double ReferenceDiscrete2DFunction::evaluate(const double* arguments) const {
int i = round(arguments[0]);
double ReferenceDiscrete2DFunction::evaluateDerivative(const double* arguments, const int* derivOrder) const { int j = round(arguments[1]);
return 0.0; if (i < 0 || i >= xsize || j < 0 || j >= ysize)
} throw OpenMMException("ReferenceDiscrete2DFunction: argument out of range");
return values[i+j*xsize];
CustomFunction* ReferenceDiscrete2DFunction::clone() const { }
return new ReferenceDiscrete2DFunction(function);
} double ReferenceDiscrete2DFunction::evaluateDerivative(const double* arguments, const int* derivOrder) const {
return 0.0;
ReferenceDiscrete3DFunction::ReferenceDiscrete3DFunction(const Discrete3DFunction& function) : function(function) { }
function.getFunctionParameters(xsize, ysize, zsize, values);
} CustomFunction* ReferenceDiscrete2DFunction::clone() const {
return new ReferenceDiscrete2DFunction(function);
int ReferenceDiscrete3DFunction::getNumArguments() const { }
return 3;
} ReferenceDiscrete3DFunction::ReferenceDiscrete3DFunction(const Discrete3DFunction& function) : function(function) {
function.getFunctionParameters(xsize, ysize, zsize, values);
double ReferenceDiscrete3DFunction::evaluate(const double* arguments) const { }
int i = (int) round(arguments[0]);
int j = (int) round(arguments[1]); int ReferenceDiscrete3DFunction::getNumArguments() const {
int k = (int) round(arguments[2]); return 3;
if (i < 0 || i >= xsize || j < 0 || j >= ysize || k < 0 || k >= zsize) }
throw OpenMMException("ReferenceDiscrete3DFunction: argument out of range");
return values[i+(j+k*ysize)*xsize]; double ReferenceDiscrete3DFunction::evaluate(const double* arguments) const {
} int i = round(arguments[0]);
int j = round(arguments[1]);
double ReferenceDiscrete3DFunction::evaluateDerivative(const double* arguments, const int* derivOrder) const { int k = round(arguments[2]);
return 0.0; if (i < 0 || i >= xsize || j < 0 || j >= ysize || k < 0 || k >= zsize)
} throw OpenMMException("ReferenceDiscrete3DFunction: argument out of range");
return values[i+(j+k*ysize)*xsize];
CustomFunction* ReferenceDiscrete3DFunction::clone() const { }
return new ReferenceDiscrete3DFunction(function);
} double ReferenceDiscrete3DFunction::evaluateDerivative(const double* arguments, const int* derivOrder) const {
return 0.0;
}
CustomFunction* ReferenceDiscrete3DFunction::clone() const {
return new ReferenceDiscrete3DFunction(function);
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment