rdkit/Code/Numerics/Optimizer/testOptimizer.cpp

// $Id$
//
// Copyright (C)  2004-2006 Rational Discovery LLC
//
//   @@ All Rights Reserved @@
//  This file is part of the RDKit.
//  The contents are covered by the terms of the BSD license
//  which is included in the file license.txt, found at the root
//  of the RDKit source tree.
//
#include <iostream>
#include <math.h>
#include <RDGeneral/Invariant.h>

#include "BFGSOpt.h"

double circ_0_0(double *v) {
  double dx = v[0];
  double dy = v[1];

  return dx * dx + dy * dy;
}

double circ_0_0_grad(double *v, double *grad) {
  double dx = v[0];
  double dy = v[1];
  grad[0] = 2 * dx;
  grad[1] = 2 * dy;
  return 1.0;
}

double circ_1_0(double *v) {
  double dx = v[0] - 1;
  double dy = v[1];

  return dx * dx + dy * dy;
}

double circ_1_0_grad(double *v, double *grad) {
  double dx = v[0] - 1;
  double dy = v[1];
  grad[0] = 2 * dx;
  grad[1] = 2 * dy;
  return 1.0;
}

double func2(double *v) {
  double weight = .5;
  double dx = v[0] - 1;
  double dy = v[1];
  double term1 = dx * dx - dy * dy;
  double term2 = dx * dx + dy * dy;
  return term1 * term1 + weight * term2;
}

double grad2(double *v, double *grad) {
  double weight = .5;
  double dx = v[0] - 1;
  double dy = v[1];
  double term1 = dx * dx - dy * dy;
  grad[0] = 4 * dx * term1 + 2 * weight * dx;
  grad[1] = -4 * dy * term1 + 2 * weight * dy;
  return 1.0;
}

void test1() {
  std::cerr << "-------------------------------------" << std::endl;
  std::cerr << "Testing linear search." << std::endl;

  int dim = 2;
  double oLoc[2], oVal;
  double grad[2], dir[2];
  double nLoc[2], nVal;
  int resCode;
  double (*func)(double *);
  double (*gradFunc)(double *, double *);

  func = circ_0_0;
  gradFunc = circ_0_0_grad;
  oLoc[0] = 0;
  oLoc[1] = 1.0;
  oVal = func(oLoc);
  TEST_ASSERT(fabs(oVal - 1.0) < 1e-4);
  gradFunc(oLoc, grad);
  dir[0] = 0;
  dir[1] = -.5;

  BFGSOpt::linearSearch(dim, oLoc, oVal, grad, dir, nLoc, nVal, func, 0.5,
                        resCode);
  TEST_ASSERT(resCode == 0);
  TEST_ASSERT(fabs(nVal - 0.25) < 1e-4);
  TEST_ASSERT(fabs(nLoc[0]) < 1e-4);
  TEST_ASSERT(fabs(nLoc[1] - 0.5) < 1e-4);

  oLoc[0] = 1.0;
  oLoc[1] = 1.0;
  oVal = func(oLoc);
  TEST_ASSERT(fabs(oVal - 2.0) < 1e-4);
  gradFunc(oLoc, grad);
  dir[0] = -.5;
  dir[1] = -.5;

  BFGSOpt::linearSearch(dim, oLoc, oVal, grad, dir, nLoc, nVal, func, 1.0,
                        resCode);
  TEST_ASSERT(resCode == 0);
  TEST_ASSERT(fabs(nVal - 0.5) < 1e-4);
  TEST_ASSERT(fabs(nLoc[0] - 0.5) < 1e-4);
  TEST_ASSERT(fabs(nLoc[1] - 0.5) < 1e-4);

  // we go hugely too far, but the dir gets cut in half, so we
  // immediately hit the minimum
  func = circ_0_0;
  oLoc[0] = 0;
  oLoc[1] = 1.0;
  oVal = func(oLoc);
  TEST_ASSERT(fabs(oVal - 1.0) < 1e-4);
  gradFunc(oLoc, grad);
  dir[0] = 0;
  dir[1] = -2;

  BFGSOpt::linearSearch(dim, oLoc, oVal, grad, dir, nLoc, nVal, func, 2.0,
                        resCode);
  TEST_ASSERT(resCode == 0);
  TEST_ASSERT(fabs(nVal) < 1e-4);
  TEST_ASSERT(fabs(nLoc[0]) < 1e-4);
  TEST_ASSERT(fabs(nLoc[1]) < 1e-4);
  std::cerr << "  done" << std::endl;
}

void test2() {
  std::cerr << "-------------------------------------" << std::endl;
  std::cerr << "Testing BFGS optimization." << std::endl;

  unsigned int dim = 2;
  double oLoc[2], oVal;
  double nVal;
  unsigned int nIters;
  double (*func)(double *);
  double (*gradFunc)(double *, double *);

  func = circ_0_0;
  gradFunc = circ_0_0_grad;
  oLoc[0] = 0;
  oLoc[1] = 1.0;
  oVal = func(oLoc);
  TEST_ASSERT(fabs(oVal - 1.0) < 1e-4);

  BFGSOpt::minimize(dim, oLoc, 1e-4, nIters, nVal, func, gradFunc);
  TEST_ASSERT(nIters = 1);
  TEST_ASSERT(fabs(nVal) < 1e-4);
  TEST_ASSERT(fabs(oLoc[0]) < 1e-4);
  TEST_ASSERT(fabs(oLoc[1]) < 1e-4);

  func = func2;
  gradFunc = grad2;
  oLoc[0] = 2.0;
  oLoc[1] = 0.5;
  BFGSOpt::minimize(dim, oLoc, 1e-4, nIters, nVal, func, gradFunc);
  // TEST_ASSERT(nIters=1);
  TEST_ASSERT(fabs(nVal) < 1e-4);
  TEST_ASSERT(fabs(oLoc[0] - 1) < 1e-3);
  TEST_ASSERT(fabs(oLoc[1]) < 1e-3);

  // up the tolerance:
  oLoc[0] = 2.0;
  oLoc[1] = 0.5;
  BFGSOpt::minimize(dim, oLoc, 1e-4, nIters, nVal, func, gradFunc, 1e-8);
  // TEST_ASSERT(nIters=1);
  TEST_ASSERT(fabs(nVal) < 1e-4);
  TEST_ASSERT(fabs(oLoc[0] - 1) < 1e-4);
  TEST_ASSERT(fabs(oLoc[1]) < 1e-4);

  std::cerr << "  done" << std::endl;
}

int main() {
  test1();
  test2();
}