invertmotorspace.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005 by Robot Group Leipzig                             *
 *    martius@informatik.uni-leipzig.de                                    *
 *    fhesse@informatik.uni-leipzig.de                                     *
 *    der@informatik.uni-leipzig.de                                        *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 *                                                                         *
 *   $Log: invertmotorspace.h,v $
 *   Revision 1.15.6.2  2006/01/18 16:48:35  martius
 *   stored and restore
 *
 *   Revision 1.15.6.1  2005/11/14 14:54:30  martius
 *   cpp file is separate now
 *
 *   Revision 1.15  2005/10/27 15:46:38  martius
 *   inspectable interface is expanded to structural information for network visualiser
 *
 *   Revision 1.14  2005/10/06 17:08:40  martius
 *   switched to stl lists
 *   Bias noise
 *   correct error_factor for controller learning
 *
 *   Revision 1.13  2005/08/22 20:32:09  martius
 *   C- initialisation variable
 *
 *   Revision 1.12  2005/08/03 20:31:14  martius
 *   destructor added
 *
 *   Revision 1.11  2005/07/21 11:33:01  fhesse
 *   R as internal parameter instead of C
 *
 *   Revision 1.10  2005/07/21 09:40:48  martius
 *   moved squashing and g to superclass
 *
 *   Revision 1.9  2005/07/05 14:48:18  martius
 *   desens removed
 *   zeta update is continuous
 *
 *   Revision 1.8  2005/07/04 15:23:27  martius
 *   x_smooth used for controller learning
 *
 *   Revision 1.7  2005/06/29 08:30:28  martius
 *   inherited from invertmotorcontroller
 *
 *   Revision 1.6  2005/06/21 15:31:11  martius
 *   getSensorNumber and getMotorMumber added controller interface
 *
 *   Revision 1.5  2005/06/20 09:04:16  martius
 *   init function added to controller-interface
 *
 *   Revision 1.4  2005/06/16 14:23:14  martius
 *   GPL and name member added
 *
 ***************************************************************************/
#ifndef __INVERTMOTORSPACE_H
#define __INVERTMOTORSPACE_H

#include "invertmotorcontroller.h" 
#include <assert.h>
#include <math.h>

#include "matrix.h"
using namespace matrix;
#include "noisegenerator.h"

/**
 * class for robot controller that uses the georg's matrixlib for 
 *  direct matrix inversion for n channels 
 * (simple one layer networks)
 * 
 * Implements standart parameters: eps, rho, mu, stepnumber4avg, stepnumber4delay
 */
class InvertMotorSpace : public InvertMotorController {

public:
  InvertMotorSpace(int buffersize, double cInit = 0.1 , bool someInternalParams = true);
  virtual void init(int sensornumber, int motornumber);

  virtual ~InvertMotorSpace();

  /// return the name of the object (with version number) Hint: use insertCVSInfo from Configurable
  virtual paramkey getName() const { return name; }

  /// returns the number of sensors the controller was initialised with or 0 if not initialised
  virtual int getSensorNumber() const { return number_sensors; }
  /// returns the mumber of motors the controller was initialised with or 0 if not initialised
  virtual int getMotorNumber() const  { return number_motors; }

  /// performs one step (includes learning). 
  /// Calulates motor commands from sensor inputs.
  virtual void step(const sensor* , int number_sensors, motor* , int number_motors);

  /// performs one step without learning. Calulates motor commands from sensor inputs.
  virtual void stepNoLearning(const sensor* , int number_sensors, 
                              motor* , int number_motors);

  /** stores the controller values to a given file. */
  virtual bool store(const char* filename);
  /** loads the controller values from a given file. */
  virtual bool restore(const char* filename);  

  // inspectable interface
  virtual list<iparamkey> getInternalParamNames() const;
  virtual list<iparamval> getInternalParams() const;
  virtual list<ILayer> getStructuralLayers() const;
  virtual list<IConnection> getStructuralConnections() const;
  

protected:
  unsigned short number_sensors;
  unsigned short number_motors;
  
  Matrix A; // Model Matrix
  Matrix C; // Controller Matrix
  Matrix R; // C*A
  Matrix H; // Controller Bias
  Matrix B; // Model Bias
  NoiseGenerator* BNoiseGen; // Noisegenerator for noisy bias
  Matrix* x_buffer;
  Matrix* y_buffer;
  Matrix x_smooth;

  bool someInternalParams;
  double cInit;
  
  /// puts the sensors in the ringbuffer, generate controller values and put them in the 
  //  ringbuffer as well
  void fillBuffersAndControl(const sensor* x_, int number_sensors, 
                             motor* y_, int number_motors);

  /// learn h,C, delayed motors y and corresponding sensors x
  virtual void learnController(const Matrix& x, const Matrix& x_smooth, int delay);

  /// learn A, using motors y and corresponding sensors x
  virtual void learnModel( const Matrix& x, const Matrix& y);

  /// calculate delayed values
  virtual Matrix calculateDelayedValues(const Matrix* buffer, 
                                        int number_steps_of_delay_);
  virtual Matrix calculateSmoothValues(const Matrix* buffer, 
                                       int number_steps_for_averaging_);

  Matrix calculateControllerValues(const Matrix& x_smooth);
    
};

#endif

---