SigmoidModel.cpp

Go to the documentation of this file.
00001 //===========================================================================
00041 //===========================================================================
00042 
00043 
00044 #include <SharkDefs.h>
00045 #include <ReClaM/SigmoidModel.h>
00046 
00047 
00048 SigmoidModel::SigmoidModel(double A, double B)
00049 {
00050     inputDimension = 1;
00051     outputDimension = 1;
00052 
00053     parameter.resize(2, false);
00054     parameter(0) = A;
00055     parameter(1) = B;
00056 }
00057 
00058 SigmoidModel::~SigmoidModel()
00059 {
00060 }
00061 
00062 
00063 void SigmoidModel::model(const Array<double>& input, Array<double> &output)
00064 {
00065     if (input.ndim() == 1)
00066     {
00067         SIZE_CHECK(input.dim(0) == 1);
00068         output.resize(1, false);
00069         output(0) = 1.0 / (1.0 + exp(parameter(0) * input(0) + parameter(1)));
00070     }
00071     else if (input.ndim() == 2)
00072     {
00073         int j, jc = input.dim(0);
00074         SIZE_CHECK(input.dim(1) == 1);
00075         output.resize(jc, 1, false);
00076         for (j = 0; j < jc; j++)
00077         {
00078             output(j, 0) = 1.0 / (1.0 + exp(parameter(0) * input(j, 0) + parameter(1)));
00079         }
00080     }
00081     else throw SHARKEXCEPTION("[SigmoidModel::model] invalid number of dimensions.");
00082 }
00083 
00084 void SigmoidModel::modelDerivative(const Array<double>& input, Array<double>& derivative)
00085 {
00086     if (input.ndim() == 1)
00087     {
00088         SIZE_CHECK(input.dim(0) == 1);
00089         derivative.resize(1, 2, false);
00090         double e = exp(parameter(0) * input(0) + parameter(1));
00091         double f = 1.0 / (1.0 + e);
00092         double d = -f * f * e;
00093         derivative(0, 0) = d * input(0);
00094         derivative(0, 1) = d;
00095     }
00096     else throw SHARKEXCEPTION("[SigmoidModel::modelDerivative] invalid number of dimensions.");
00097 }
00098 
00099 void SigmoidModel::modelDerivative(const Array<double>& input, Array<double>& output, Array<double>& derivative)
00100 {
00101     if (input.ndim() == 1)
00102     {
00103         SIZE_CHECK(input.dim(0) == 1);
00104         derivative.resize(1, 2, false);
00105         output.resize(1, false);
00106         double e = exp(parameter(0) * input(0) + parameter(1));
00107         double f = 1.0 / (1.0 + e);
00108         double d = -f * f * e;
00109         output(0) = f;
00110         derivative(0, 0) = d * input(0);
00111         derivative(0, 1) = d;
00112     }
00113     else throw SHARKEXCEPTION("[SigmoidModel::modelDerivative] invalid number of dimensions.");
00114 }
00115 
00116 
00118 
00119 
00120 SimpleSigmoidModel::SimpleSigmoidModel(double s)
00121 {
00122     inputDimension = 1;
00123     outputDimension = 1;
00124 
00125     parameter.resize(1, false);
00126     parameter(0) = s;
00127 }
00128 
00129 SimpleSigmoidModel::~SimpleSigmoidModel()
00130 {
00131 }
00132 
00133 
00134 void SimpleSigmoidModel::model(const Array<double>& input, Array<double> &output)
00135 {
00136     if (input.ndim() == 1)
00137     {
00138         SIZE_CHECK(input.dim(0) == 1);
00139         output.resize(1, false);
00140         double x = parameter(0) * input(0);
00141         output(0) = 0.5 * x / (1.0 + fabs(x)) + 0.5;
00142     }
00143     else if (input.ndim() == 2)
00144     {
00145         int j, jc = input.dim(0);
00146         SIZE_CHECK(input.dim(1) == 1);
00147         output.resize(jc, 1, false);
00148         for (j = 0; j < jc; j++)
00149         {
00150             double x = parameter(0) * input(j, 0);
00151             output(j, 0) = 0.5 * x / (1.0 + fabs(x)) + 0.5;
00152         }
00153     }
00154     else throw SHARKEXCEPTION("[SimpleSigmoidModel::model] invalid number of dimensions.");
00155 }
00156 
00157 void SimpleSigmoidModel::modelDerivative(const Array<double>& input, Array<double>& derivative)
00158 {
00159     if (input.ndim() == 1)
00160     {
00161         SIZE_CHECK(input.dim(0) == 1);
00162         derivative.resize(1, 1, false);
00163         double N = 1.0 + fabs(parameter(0) * input(0));
00164         derivative(0, 0) = 0.5 * input(0) / (N * N);
00165     }
00166     else throw SHARKEXCEPTION("[SimpleSigmoidModel::modelDerivative] invalid number of dimensions.");
00167 }
00168 
00169 void SimpleSigmoidModel::modelDerivative(const Array<double>& input, Array<double>& output, Array<double>& derivative)
00170 {
00171     if (input.ndim() == 1)
00172     {
00173         SIZE_CHECK(input.dim(0) == 1);
00174         derivative.resize(1, 1, false);
00175         output.resize(1, false);
00176         double x = parameter(0) * input(0);
00177         double N = 1.0 + fabs(x);
00178         output(0) = 0.5 * (x / N + 1.0);
00179         derivative(0, 0) = 0.5 * input(0) / (N * N);
00180     }
00181     else throw SHARKEXCEPTION("[SimpleSigmoidModel::modelDerivative] invalid number of dimensions.");
00182 }
00183 
00184 bool SimpleSigmoidModel::isFeasible()
00185 {
00186     return (parameter(0) > 0.0);
00187 }