Fixed bug #9164: Refactored unit tests with assert functions 45/3545/13
Michael Baudin [Wed, 16 Mar 2011 16:12:17 +0000 (17:12 +0100)]
Add localization to assert_checkerror function

Change-Id: Id8e2cd78dc685af32bb0e38f76c947fef760e8f9

219 files changed:
scilab/CHANGES_5.4.X
scilab/modules/cacsd/tests/nonreg_tests/bug_3934.dia.ref
scilab/modules/cacsd/tests/nonreg_tests/bug_3934.tst
scilab/modules/cacsd/tests/nonreg_tests/bug_68.dia.ref
scilab/modules/cacsd/tests/nonreg_tests/bug_68.tst
scilab/modules/cacsd/tests/unit_tests/dscr.dia.ref
scilab/modules/cacsd/tests/unit_tests/dscr.tst
scilab/modules/development_tools/macros/assert/assert_checkerror.sci
scilab/modules/elementary_functions/tests/nonreg_tests/bug_8254.dia.ref
scilab/modules/elementary_functions/tests/nonreg_tests/bug_8254.tst
scilab/modules/elementary_functions/tests/unit_tests/IEEEcompatibility.dia.ref
scilab/modules/elementary_functions/tests/unit_tests/IEEEcompatibility.tst
scilab/modules/elementary_functions/tests/unit_tests/factorial.dia.ref
scilab/modules/elementary_functions/tests/unit_tests/factorial.tst
scilab/modules/elementary_functions/tests/unit_tests/gamma.dia.ref
scilab/modules/elementary_functions/tests/unit_tests/gamma.tst
scilab/modules/elementary_functions/tests/unit_tests/nearfloat.dia.ref
scilab/modules/elementary_functions/tests/unit_tests/nearfloat.tst
scilab/modules/elementary_functions/tests/unit_tests/tand.dia.ref
scilab/modules/elementary_functions/tests/unit_tests/tand.tst
scilab/modules/linear_algebra/tests/nonreg_tests/bug_2775.dia.ref
scilab/modules/linear_algebra/tests/nonreg_tests/bug_2775.tst
scilab/modules/linear_algebra/tests/unit_tests/norm.dia.ref
scilab/modules/linear_algebra/tests/unit_tests/norm.tst
scilab/modules/optimization/macros/neldermead/fminsearch.sci
scilab/modules/optimization/tests/nonreg_tests/bug_8160.dia.ref
scilab/modules/optimization/tests/nonreg_tests/bug_8160.tst
scilab/modules/optimization/tests/nonreg_tests/bug_8719.dia.ref
scilab/modules/optimization/tests/nonreg_tests/bug_8719.tst
scilab/modules/optimization/tests/nonreg_tests/bug_8720.dia.ref
scilab/modules/optimization/tests/nonreg_tests/bug_8720.tst
scilab/modules/optimization/tests/nonreg_tests/bug_8726.dia.ref
scilab/modules/optimization/tests/nonreg_tests/bug_8726.tst
scilab/modules/optimization/tests/nonreg_tests/bug_8727.dia.ref
scilab/modules/optimization/tests/nonreg_tests/bug_8727.tst
scilab/modules/optimization/tests/nonreg_tests/bug_8775.dia.ref
scilab/modules/optimization/tests/nonreg_tests/bug_8775.tst
scilab/modules/optimization/tests/unit_tests/derivative.dia.ref
scilab/modules/optimization/tests/unit_tests/derivative.linux.dia.ref
scilab/modules/optimization/tests/unit_tests/derivative.tst
scilab/modules/optimization/tests/unit_tests/karmarkar.dia.ref
scilab/modules/optimization/tests/unit_tests/karmarkar.tst
scilab/modules/optimization/tests/unit_tests/neldermead/fminsearch.linux.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/fminsearch.tst
scilab/modules/optimization/tests/unit_tests/neldermead/fminsearch.win.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/fminsearch_output.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/fminsearch_output.tst
scilab/modules/optimization/tests/unit_tests/neldermead/fminsearch_output.unix.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_configure.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_configure.linux.dia.ref [new file with mode: 0644]
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_configure.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_mckinnon.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_mckinnon.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_mymethod.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_mymethod.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_myterminate.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_myterminate.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_newdestroy.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_newdestroy.linux.dia.ref [new file with mode: 0644]
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_newdestroy.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_outputcmd.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_outputcmd.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_outputcmd2.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_outputcmd2.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_restart.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_restart.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_rosensuzuki.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_rosensuzuki.linux.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_rosensuzuki.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_search.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_search.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchaddarg.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchaddarg.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchaddarg2.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchaddarg2.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchaddarg3.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchaddarg3.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchdefault.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchdefault.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchfixed.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchfixed.linux.dia.ref [new file with mode: 0644]
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchfixed.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchfixed2.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchfixed2.linux.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchfixed2.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchvariable.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchvariable.linux.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_searchvariable.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_shapeX.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_shapeX.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_simplex0.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_simplex0.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_simplexaxes.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_simplexaxes.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_simplexregular.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_simplexregular.tst
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_tolerance.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_tolerance.tst
scilab/modules/optimization/tests/unit_tests/neldermead/nmplot_contour.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/nmplot_contour.tst
scilab/modules/optimization/tests/unit_tests/neldermead/nmplot_newdestroy.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/nmplot_newdestroy.linux.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/nmplot_newdestroy.tst
scilab/modules/optimization/tests/unit_tests/neldermead/nmplot_rosenbrock.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/nmplot_rosenbrock.tst
scilab/modules/optimization/tests/unit_tests/neldermead/optimget.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/optimget.tst
scilab/modules/optimization/tests/unit_tests/neldermead/optimset.dia.ref
scilab/modules/optimization/tests/unit_tests/neldermead/optimset.tst
scilab/modules/optimization/tests/unit_tests/optim_scilabscript.dia.ref
scilab/modules/optimization/tests/unit_tests/optim_scilabscript.tst
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_checkbounds.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_checkbounds.tst
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_checkcostfun.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_checkcostfun.tst
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_checkx0.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_checkx0.linux.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_checkx0.tst
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_function.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_function.tst
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_hasbounds.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_hasbounds.tst
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_isfeasible.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_isfeasible.linux.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_isfeasible.tst
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_isinbounds.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_isinbounds.linux.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_isinbounds.tst
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_isinnonlincons.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_isinnonlincons.tst
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_log.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_log.tst
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_newdestroy.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_newdestroy.linux.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_newdestroy.tst
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_proj2bnds.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_proj2bnds.linux.dia.ref
scilab/modules/optimization/tests/unit_tests/optimbase/optimbase_proj2bnds.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_axes.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_axes.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_center.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_center.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_check.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_check.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_computefv.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_computefv.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_deltafv.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_deltafv.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_deltafvmax.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_deltafvmax.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_dirmat.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_dirmat.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_fvmean.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_fvmean.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_fvstdev.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_fvstdev.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_fvvariance.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_fvvariance.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_getset.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_getset.linux.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_getset.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_gradientfv.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_gradientfv.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_new.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_new.linux.dia.ref [new file with mode: 0644]
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_new.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_oriented.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_oriented.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_pfeffer.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_pfeffer.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_randbounds.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_randbounds.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_reflect.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_reflect.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_shrink.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_shrink.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_size.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_size.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_sort.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_sort.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_spendley.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_spendley.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_tostring.linux.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_tostring.tst
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_tostring.win.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_xbar.dia.ref
scilab/modules/optimization/tests/unit_tests/optimsimplex/optimsimplex_xbar.tst
scilab/modules/polynomials/tests/nonreg_tests/bug_415.dia.ref
scilab/modules/polynomials/tests/nonreg_tests/bug_415.tst
scilab/modules/randlib/tests/nonreg_tests/bug_4839.dia.ref
scilab/modules/randlib/tests/nonreg_tests/bug_4839.tst
scilab/modules/randlib/tests/unit_tests/grand_generators.dia.ref
scilab/modules/randlib/tests/unit_tests/grand_generators.tst
scilab/modules/randlib/tests/unit_tests/grand_laws.dia.ref
scilab/modules/randlib/tests/unit_tests/grand_laws.tst
scilab/modules/randlib/tests/unit_tests/grand_prm.dia.ref
scilab/modules/randlib/tests/unit_tests/grand_prm.tst
scilab/modules/simulated_annealing/tests/unit_tests/optim_sa.dia.ref
scilab/modules/simulated_annealing/tests/unit_tests/optim_sa.tst
scilab/modules/sparse/tests/unit_tests/adj2sp.dia.ref
scilab/modules/sparse/tests/unit_tests/adj2sp.tst
scilab/modules/sparse/tests/unit_tests/pcg.dia.ref
scilab/modules/sparse/tests/unit_tests/pcg.tst
scilab/modules/sparse/tests/unit_tests/sp2adj.dia.ref
scilab/modules/sparse/tests/unit_tests/sp2adj.tst
scilab/modules/sparse/tests/unit_tests/sprand.dia.ref
scilab/modules/sparse/tests/unit_tests/sprand.tst
scilab/modules/statistics/tests/nonreg_tests/bug_7377.dia.ref
scilab/modules/statistics/tests/nonreg_tests/bug_7377.tst
scilab/modules/statistics/tests/nonreg_tests/bug_8032.dia.ref
scilab/modules/statistics/tests/nonreg_tests/bug_8032.tst
scilab/modules/statistics/tests/unit_tests/cdfgam.dia.ref
scilab/modules/statistics/tests/unit_tests/cdfgam.tst
scilab/modules/statistics/tests/unit_tests/cdfnor.dia.ref
scilab/modules/statistics/tests/unit_tests/cdfnor.tst
scilab/modules/statistics/tests/unit_tests/cdfpoi.dia.ref
scilab/modules/statistics/tests/unit_tests/cdfpoi.tst
scilab/modules/statistics/tests/unit_tests/thrownan.dia.ref
scilab/modules/statistics/tests/unit_tests/thrownan.tst

index 806b9f9..8eed551 100644 (file)
@@ -26,12 +26,12 @@ Bug Fixes:
 * bug 4833 fixed - msprintf() interpreted "\n" as a carriage return even if "\n"
                    is supplied by the 2nd input argument.
 
-* bug 8608 fixed - dec2hex, hex2dec, dec2oct and oct2dec code have been simplified
-                   and optimized.
+* bug 8608 - dec2hex, hex2dec, dec2oct and oct2dec code have been simplified
+             and optimized.
 
-* bug 8608 fixed - dec2hex, hex2dec, dec2oct, oct2dec, code have been simplified and optimized.
+* bug 8608 - dec2hex, hex2dec, dec2oct, oct2dec, code have been simplified and optimized.
 
-* bug 9249 fixed - The assert_checkerror did not localize the message.
+* bug 9164 - The unit tests now use the new assert functions.
 
 Removed functions (previously declared as obsolete):
 ====================================================
index cbbb231..7935e44 100644 (file)
@@ -1,7 +1,7 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2009 - DIGITEO - Vincent COUVERT
-// Copyright (C) 2009 - DIGITEO - Michael Baudin
+// Copyright (C) 2009 - 2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 //
 // <-- Short Description -->
 //   Online Help of ricc() function crashes Scilab
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
 //Standard formulas to compute Riccati solutions
 A=rand(3,3);
 B=rand(3,2);
@@ -42,22 +21,18 @@ R=rand(2,2);
 R=R*R'+eye();
 B=B*inv(R)*B';
 X=ricc(A,B,C,'cont');
-computed = norm(A'*X+X*A-X*B*X+C,1);
-expected = 0.0;
-assert_close ( computed, expected, 1.e4 * %eps );
+computed = A'*X+X*A-X*B*X+C;
+expected = zeros(3,3);
+assert_checkalmostequal ( computed, expected, [] , 1.e4 * %eps );
 H=[A -B;-C -A'];
 [T,d]=schur(eye(H),H,'cont');
 T=T(:,1:d);
 X1=T(4:6,:)/T(1:3,:);
-norm(X1-X,1);
-expected = 0.0;
-assert_close ( computed, expected, 1.e4 * %eps );
+assert_checkalmostequal ( X1, X, 1.e4 * %eps );
 [T,d]=schur(H,'cont');
 T=T(:,1:d);
 X2=T(4:6,:)/T(1:3,:);
-computed = norm(X2-X,1);
-expected = 0.0;
-assert_close ( computed, expected, 1.e4 * %eps );
+assert_checkalmostequal ( X2, X, 1.e4 * %eps );
 // Discrete time case
 F=A;
 B=rand(3,2);
@@ -71,4 +46,4 @@ expected =  [
     1.3494625    1.4794503    1.6987296  
     1.3988904    1.6987296    2.3494632  
     ];
-assert_close ( computed, expected, 1.e7 );
+assert_checkalmostequal ( computed, expected, 1.e7 );
index b15cdc6..90d0d21 100644 (file)
@@ -1,7 +1,7 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2009 - DIGITEO - Vincent COUVERT
-// Copyright (C) 2009 - DIGITEO - Michael Baudin
+// Copyright (C) 2009 - 2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // <-- Short Description -->
 //   Online Help of ricc() function crashes Scilab
 
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
-
 //Standard formulas to compute Riccati solutions
 A=rand(3,3);
 B=rand(3,2);
@@ -45,24 +23,20 @@ R=rand(2,2);
 R=R*R'+eye();
 B=B*inv(R)*B';
 X=ricc(A,B,C,'cont');
-computed = norm(A'*X+X*A-X*B*X+C,1);
-expected = 0.0;
-assert_close ( computed, expected, 1.e4 * %eps );
+computed = A'*X+X*A-X*B*X+C;
+expected = zeros(3,3);
+assert_checkalmostequal ( computed, expected, [] , 1.e4 * %eps );
 
 H=[A -B;-C -A'];
 [T,d]=schur(eye(H),H,'cont');
 T=T(:,1:d);
 X1=T(4:6,:)/T(1:3,:);
-norm(X1-X,1);
-expected = 0.0;
-assert_close ( computed, expected, 1.e4 * %eps );
+assert_checkalmostequal ( X1, X, 1.e4 * %eps );
 
 [T,d]=schur(H,'cont');
 T=T(:,1:d);
 X2=T(4:6,:)/T(1:3,:);
-computed = norm(X2-X,1);
-expected = 0.0;
-assert_close ( computed, expected, 1.e4 * %eps );
+assert_checkalmostequal ( X2, X, 1.e4 * %eps );
 
 // Discrete time case
 F=A;
@@ -77,6 +51,6 @@ expected =  [
     1.3494625    1.4794503    1.6987296  
     1.3988904    1.6987296    2.3494632  
     ];
-assert_close ( computed, expected, 1.e7 );
+assert_checkalmostequal ( computed, expected, 1.e7 );
 
                     
index dc4fe0f..5f2681b 100644 (file)
@@ -1,7 +1,7 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2005-2008 - INRIA -Serge Steer
-// Copyright (C) 2009 - DIGITEO - Michael Baudin
+// Copyright (C) 2009-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // <-- Short Description -->
 //Precision problem with the trzeros function, 
 //
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
-//
 // sort_merge --
 //   Returns the sorted array x.
 // Arguments
@@ -41,7 +20,7 @@ endfunction
 //   compfun : the comparison function
 //   data : an optionnal data to pass to the comparison function
 // Bruno Pincon
-// "quelques tests de rapidit�e entre diff�erents logiciels matriciels"
+// "quelques tests de rapidit´e entre diff´erents logiciels matriciels"
 // Modified by Michael Baudin to manage a comparison function
 //
 function [x] = sort_merge ( varargin )
@@ -116,39 +95,8 @@ function order = sort_merge_comparison ( x , y )
     order = 1
   end
 endfunction
-// 
-// compare_complexrealimag --
-//   Returns -1 if a < b, 
-//   returns 0 if a==b,
-//   returns +1 if a > b
-// Compare first by real parts, then by imaginary parts.
-// Arguments
-//   a, b : the values to be compared
-//   precision : a list made of the absolute precision (element #1),
-//      and the relative precision (element #2)
-//
-function order = compare_complexrealimag ( a , b , precision )
-  ar = real(a)
-  br = real(b)
-  areequal = ( abs ( ar - br ) <= precision(1) + precision(2) * max ( abs(ar) , abs(br) ) )
-  if ( areequal ) then
-    // Tie on the real part: compare imaginary parts
-    ai = imag(a)
-    bi = imag(b)
-    areequal = ( abs ( ai - bi ) <= precision(1) + precision(2) * max ( abs(ai) , abs(bi) ) )
-    if ( areequal ) then
-      // Tie on imaginary parts too: two numbers are "equal"
-      order = 0
-    elseif ( ai < bi ) then
-      order = -1
-    else
-      order = 1
-    end
-  elseif ( ar < br ) then
-    order = -1
-  else
-    order = 1
-  end
+function order = mycomparison ( x , y , data )
+  order = assert_comparecomplex(x,y,data(1),data(2))
 endfunction
 s=poly(0,'s'); 
 A=[-113.63636,-2840909.1,113.63636,2840909.1,0,0;
@@ -170,8 +118,6 @@ ClosedZeros1=trzeros(closed1);
 Hrond2=System*PID;
 closed2=(1/.(Hrond2));
 ClosedZeros2=trzeros(closed2);
-computed1 = sort_merge ( ClosedZeros1 , compare_complexrealimag , [ 0.0 , 10 * %eps ] );
-computed2 = sort_merge ( ClosedZeros2 , compare_complexrealimag , [ 0.0 , 10 * %eps ] );
-computed = norm ( computed1 - computed2 );
-expected = 0.0;
-assert_close ( computed, expected, 1.e-7 );
+computed1 = sort_merge ( ClosedZeros1 , mycomparison , [ 10 * %eps , 0.0 ] );
+computed2 = sort_merge ( ClosedZeros2 , mycomparison , [ 10 * %eps , 0.0 ] );
+assert_checkalmostequal ( computed1 , computed2, [] , 1.e-7 );
index 4bc1244..767e65d 100644 (file)
@@ -1,7 +1,7 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2005-2008 - INRIA -Serge Steer
-// Copyright (C) 2009 - DIGITEO - Michael Baudin
+// Copyright (C) 2009-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // <-- Short Description -->
 //Precision problem with the trzeros function, 
 
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
 
 //
 // sort_merge --
@@ -121,41 +100,11 @@ function order = sort_merge_comparison ( x , y )
   end
 endfunction
 
-// 
-// compare_complexrealimag --
-//   Returns -1 if a < b, 
-//   returns 0 if a==b,
-//   returns +1 if a > b
-// Compare first by real parts, then by imaginary parts.
-// Arguments
-//   a, b : the values to be compared
-//   precision : a list made of the absolute precision (element #1),
-//      and the relative precision (element #2)
-//
-function order = compare_complexrealimag ( a , b , precision )
-  ar = real(a)
-  br = real(b)
-  areequal = ( abs ( ar - br ) <= precision(1) + precision(2) * max ( abs(ar) , abs(br) ) )
-  if ( areequal ) then
-    // Tie on the real part: compare imaginary parts
-    ai = imag(a)
-    bi = imag(b)
-    areequal = ( abs ( ai - bi ) <= precision(1) + precision(2) * max ( abs(ai) , abs(bi) ) )
-    if ( areequal ) then
-      // Tie on imaginary parts too: two numbers are "equal"
-      order = 0
-    elseif ( ai < bi ) then
-      order = -1
-    else
-      order = 1
-    end
-  elseif ( ar < br ) then
-    order = -1
-  else
-    order = 1
-  end
+function order = mycomparison ( x , y , data )
+  order = assert_comparecomplex(x,y,data(1),data(2))
 endfunction
 
+
 s=poly(0,'s'); 
 A=[-113.63636,-2840909.1,113.63636,2840909.1,0,0;
    1,0,0,0,0,0;
@@ -181,10 +130,8 @@ Hrond2=System*PID;
 closed2=(1/.(Hrond2));
 ClosedZeros2=trzeros(closed2);
 
-computed1 = sort_merge ( ClosedZeros1 , compare_complexrealimag , [ 0.0 , 10 * %eps ] );
-computed2 = sort_merge ( ClosedZeros2 , compare_complexrealimag , [ 0.0 , 10 * %eps ] );
+computed1 = sort_merge ( ClosedZeros1 , mycomparison , [ 10 * %eps , 0.0 ] );
+computed2 = sort_merge ( ClosedZeros2 , mycomparison , [ 10 * %eps , 0.0 ] );
 
-computed = norm ( computed1 - computed2 );
-expected = 0.0;
-assert_close ( computed, expected, 1.e-7 );
+assert_checkalmostequal ( computed1 , computed2, [] , 1.e-7 );
 
index ff3e789..b45a23d 100644 (file)
@@ -1,43 +1,23 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) ????-2008 - INRIA - Serge Steer
+// Copyright (C) 2008 - INRIA - Serge Steer
+// Copyright (C) 2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
 // Case #1
 a=-1/3;
 b=1;
 c=1;
 sl=syslin('c',a,b,c);
 sld=dscr(sl,0.1);
-assert_close ( sld.dt , 0.1 , %eps );
+assert_checkalmostequal ( sld.dt , 0.1 , %eps );
 computed = sld.A;
 expected = exp(sl.A*0.1);
-assert_close ( computed , expected , %eps );
+assert_checkalmostequal ( computed , expected , %eps );
 computed = sld.B;
 expected = sl.A\(sld.A-eye())*sl.B;
-assert_close ( computed , expected , %eps );
+assert_checkalmostequal ( computed , expected , %eps );
 // Case #2
 a=[0.9,0,0.6,-1.4,-4.2;
    0.2,0.1,-0.2,0.5,0.6;
@@ -55,10 +35,10 @@ d=[1,0,0
    0,0,0];
 sl=syslin('c',a,b,c,d);
 sld=dscr(sl,0.1);
-assert_close ( sld.dt , 0.1 , %eps );
+assert_checkalmostequal ( sld.dt , 0.1 , %eps );
 computed = sld.A;
 expected = expm(sl.A*0.1);
-assert_close ( computed , expected , %eps );
+assert_checkalmostequal ( computed , expected , %eps );
 computed = sld.B;
 expected = sl.A\(sld.A-eye())*sl.B;
-assert_close ( computed , expected , 1.e3 * %eps );
+assert_checkalmostequal ( computed , expected , 1.e3 * %eps );
index b877348..835b239 100644 (file)
@@ -1,31 +1,12 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) ????-2008 - INRIA - Serge Steer
+// Copyright (C) 2008 - INRIA - Serge Steer
+// Copyright (C) 2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
+
 
 // Case #1
 a=-1/3;
@@ -33,13 +14,13 @@ b=1;
 c=1;
 sl=syslin('c',a,b,c);
 sld=dscr(sl,0.1);
-assert_close ( sld.dt , 0.1 , %eps );
+assert_checkalmostequal ( sld.dt , 0.1 , %eps );
 computed = sld.A;
 expected = exp(sl.A*0.1);
-assert_close ( computed , expected , %eps );
+assert_checkalmostequal ( computed , expected , %eps );
 computed = sld.B;
 expected = sl.A\(sld.A-eye())*sl.B;
-assert_close ( computed , expected , %eps );
+assert_checkalmostequal ( computed , expected , %eps );
 
 // Case #2
 a=[0.9,0,0.6,-1.4,-4.2;
@@ -61,11 +42,11 @@ d=[1,0,0
 
 sl=syslin('c',a,b,c,d);
 sld=dscr(sl,0.1);
-assert_close ( sld.dt , 0.1 , %eps );
+assert_checkalmostequal ( sld.dt , 0.1 , %eps );
 computed = sld.A;
 expected = expm(sl.A*0.1);
-assert_close ( computed , expected , %eps );
+assert_checkalmostequal ( computed , expected , %eps );
 computed = sld.B;
 expected = sl.A\(sld.A-eye())*sl.B;
-assert_close ( computed , expected , 1.e3 * %eps );
+assert_checkalmostequal ( computed , expected , 1.e3 * %eps );
 
index 9f8bf90..8ff39f7 100644 (file)
@@ -74,18 +74,18 @@ function [flag,errmsg] = assert_checkerror ( varargin )
     // Initialize output arguments
     flag = %t
     errmsg = ""
-       //
-       // Localize the message, if necessary.
-       if ( rhs >= 4 ) then
-           localmsg = gettext(expectedmsg)
-           instr = "expectedmsg = msprintf(localmsg, varargin(4:$))"
-               ierr = execstr(instr,"errcatch")
-               if ( ierr <> 0 ) then
-                   fmterrmsg = lasterror()
-                       localstr = gettext ( "%s: Error while formatting the error message: ""%s""")
-                       errmsg = sprintf ( localstr , "assert_checkerror" , fmterrmsg )
-                       error(errmsg)                   
-               end
+    //
+    // Localize the message, if necessary.
+    if ( rhs >= 4 ) then
+      localmsg = gettext(expectedmsg)
+      instr = "expectedmsg = msprintf(localmsg, varargin(4:$))"
+      ierr = execstr(instr,"errcatch")
+      if ( ierr <> 0 ) then
+        fmterrmsg = lasterror()
+        localstr = gettext ( "%s: Error while formatting the error message: ""%s""")
+        errmsg = sprintf ( localstr , "assert_checkerror" , fmterrmsg )
+        error(errmsg)
+      end
     end
     //
     // Check the error message
index 06448d4..07ba9e4 100644 (file)
@@ -1,6 +1,6 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // The nearfloat function does not work properly for near denormalized numbers.
 // <-- JVM NOT MANDATORY -->
 //
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if ( and ( computed == expected ) ) then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
-//
 // Test at vmin, the smallest normal
 // x = 2.2250738585072013D-308;
 x = 1 * 2^-1022; 
 computed = nearfloat("succ",x);
-assert_equal ( computed , 1.0000000000000002 * 2^-1022 );
+assert_checkequal ( computed , 1.0000000000000002 * 2^-1022 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , 1.9999999999999995 * 2^-1023 );
+assert_checkequal ( computed , 1.9999999999999995 * 2^-1023 );
index f8bbc39..80fc30d 100644 (file)
@@ -1,6 +1,6 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 
 // <-- JVM NOT MANDATORY -->
 
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if ( and ( computed == expected ) ) then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
 
 //
 // Test at vmin, the smallest normal
 // x = 2.2250738585072013D-308;
 x = 1 * 2^-1022; 
 computed = nearfloat("succ",x);
-assert_equal ( computed , 1.0000000000000002 * 2^-1022 );
+assert_checkequal ( computed , 1.0000000000000002 * 2^-1022 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , 1.9999999999999995 * 2^-1023 );
+assert_checkequal ( computed , 1.9999999999999995 * 2^-1023 );
 
index a64fa77..c3ec2d6 100644 (file)
@@ -2,7 +2,7 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008 - INRIA - Allan CORNET
 // Copyright (C) 2009 - INRIA - Michael Baudin, Antoine Elias
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // <-- JVM NOT MANDATORY -->
 // <-- Bugzilla URL -->
 //
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if ( type(computed) == 1 & type(expected) == 1 ) then
-    csize = size (computed,"*")
-    esize = size (expected,"*")
-    cnonan = find(~isnan(computed))
-    enonan = find(~isnan(computed))
-    if ( and(cnonan == enonan) & and(computed(enonan) == expected(cnonan)) ) then
-      flag = 1;
-    else
-      flag = 0;
-    end
-  else
-    if computed==expected then
-      flag = 1;
-    else
-      flag = 0;
-    end
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
 // Bibliography :
 // "IEEE Standard for Floating-Point Arithmetic"
 // IEEE Std 754-2008
@@ -67,24 +19,24 @@ endfunction
 // are the one which are expected.
 // Strict equality is required here.
 radix = number_properties("radix");
-assert_equal ( radix , 2 );
+assert_checkequal ( radix , 2 );
 p = number_properties("digits");
-assert_equal ( p , 53 );
+assert_checkequal ( p , 53 );
 eps = number_properties("eps");
-assert_equal ( eps , 1.11022302462515650e-016 );
-assert_equal ( %eps , 2.22044604925031310e-016 );
+assert_checkequal ( eps , 1.11022302462515650e-016 );
+assert_checkequal ( %eps , 2.22044604925031310e-016 );
 huge = number_properties("huge");
-assert_equal ( huge , 1.797693134862315708e+308 );
+assert_checkequal ( huge , 1.797693134862315708e+308 );
 tiny = number_properties("tiny");
-assert_equal ( tiny , 2.22507385850720140e-308 );
+assert_checkequal ( tiny , 2.22507385850720140e-308 );
 denorm = number_properties("denorm");
-assert_equal ( denorm , %t );
+assert_checkequal ( denorm , %t );
 tiniest = number_properties("tiniest");
-assert_equal ( tiniest , 4.94065645841246540e-324 );
+assert_checkequal ( tiniest , 4.94065645841246540e-324 );
 minexp = number_properties("minexp");
-assert_equal ( minexp , -1021 );
+assert_checkequal ( minexp , -1021 );
 maxexp = number_properties("maxexp");
-assert_equal ( maxexp , 1024 );
+assert_checkequal ( maxexp , 1024 );
 // Check that elementary operators +,-,*,/,sqrt and modulo
 // satisfy basic IEEE requirements.
 expectedadd = [
@@ -162,9 +114,9 @@ for i=1:n
     computedmodulo (i,j) = modulo(l , r);
   end
 end
-assert_equal ( computedadd    , expectedadd );
-assert_equal ( computedminus  , expectedminus );
-assert_equal ( computedmult   , expectedmult );
-assert_equal ( computeddiv    , expecteddiv );
-assert_equal ( computedsqrt   , expectedsqrt );
-assert_equal ( computedmodulo , expectedmodulo );
+assert_checkequal ( computedadd    , expectedadd );
+assert_checkequal ( computedminus  , expectedminus );
+assert_checkequal ( computedmult   , expectedmult );
+assert_checkequal ( computeddiv    , expecteddiv );
+assert_checkequal ( computedsqrt   , expectedsqrt );
+assert_checkequal ( computedmodulo , expectedmodulo );
index 778fc00..9520707 100644 (file)
@@ -2,7 +2,7 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008 - INRIA - Allan CORNET
 // Copyright (C) 2009 - INRIA - Michael Baudin, Antoine Elias
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // <-- Bugzilla URL -->
 //
 
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
-
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if ( type(computed) == 1 & type(expected) == 1 ) then
-    csize = size (computed,"*")
-    esize = size (expected,"*")
-    cnonan = find(~isnan(computed))
-    enonan = find(~isnan(computed))
-    if ( and(cnonan == enonan) & and(computed(enonan) == expected(cnonan)) ) then
-      flag = 1;
-    else
-      flag = 0;
-    end
-  else
-    if computed==expected then
-      flag = 1;
-    else
-      flag = 0;
-    end
-  end
-  if flag <> 1 then pause,end
-endfunction
 
 // Bibliography :
 // "IEEE Standard for Floating-Point Arithmetic"
@@ -72,24 +23,24 @@ endfunction
 // are the one which are expected.
 // Strict equality is required here.
 radix = number_properties("radix");
-assert_equal ( radix , 2 );
+assert_checkequal ( radix , 2 );
 p = number_properties("digits");
-assert_equal ( p , 53 );
+assert_checkequal ( p , 53 );
 eps = number_properties("eps");
-assert_equal ( eps , 1.11022302462515650e-016 );
-assert_equal ( %eps , 2.22044604925031310e-016 );
+assert_checkequal ( eps , 1.11022302462515650e-016 );
+assert_checkequal ( %eps , 2.22044604925031310e-016 );
 huge = number_properties("huge");
-assert_equal ( huge , 1.797693134862315708e+308 );
+assert_checkequal ( huge , 1.797693134862315708e+308 );
 tiny = number_properties("tiny");
-assert_equal ( tiny , 2.22507385850720140e-308 );
+assert_checkequal ( tiny , 2.22507385850720140e-308 );
 denorm = number_properties("denorm");
-assert_equal ( denorm , %t );
+assert_checkequal ( denorm , %t );
 tiniest = number_properties("tiniest");
-assert_equal ( tiniest , 4.94065645841246540e-324 );
+assert_checkequal ( tiniest , 4.94065645841246540e-324 );
 minexp = number_properties("minexp");
-assert_equal ( minexp , -1021 );
+assert_checkequal ( minexp , -1021 );
 maxexp = number_properties("maxexp");
-assert_equal ( maxexp , 1024 );
+assert_checkequal ( maxexp , 1024 );
 
 // Check that elementary operators +,-,*,/,sqrt and modulo
 // satisfy basic IEEE requirements.
@@ -177,11 +128,11 @@ for i=1:n
   end
 end
 
-assert_equal ( computedadd    , expectedadd );
-assert_equal ( computedminus  , expectedminus );
-assert_equal ( computedmult   , expectedmult );
-assert_equal ( computeddiv    , expecteddiv );
-assert_equal ( computedsqrt   , expectedsqrt );
-assert_equal ( computedmodulo , expectedmodulo );
+assert_checkequal ( computedadd    , expectedadd );
+assert_checkequal ( computedminus  , expectedminus );
+assert_checkequal ( computedmult   , expectedmult );
+assert_checkequal ( computeddiv    , expecteddiv );
+assert_checkequal ( computedsqrt   , expectedsqrt );
+assert_checkequal ( computedmodulo , expectedmodulo );
 
 
index dfb46cb..0c39db0 100644 (file)
@@ -1,5 +1,5 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 // This file must be used under the terms of the CeCILL.
 // This source file is licensed as described in the file COPYING, which
@@ -7,50 +7,14 @@
 // are also available at
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 // <-- JVM NOT MANDATORY -->
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if ( and ( computed == expected ) ) then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
 x = factorial ( 1 );
-assert_equal ( x , 1 );
+assert_checkequal ( x , 1 );
 x = factorial ( 2 );
-assert_equal ( x , 2 );
+assert_checkequal ( x , 2 );
 x = factorial ( [1 2 3 4] );
-assert_equal ( x , [1 2 6 24] );
+assert_checkequal ( x , [1 2 6 24] );
 x = factorial ( 170 );
-assert_close ( x , 7.25741561530799896739e306 , 10 * %eps );
+assert_checkalmostequal ( x , 7.25741561530799896739e306 , 10 * %eps );
 // Test with a matrix
 n = [
 1 2 3
@@ -63,13 +27,13 @@ e = [
     24.      120.      720.     
     5040.    40320.    362880.  
 ];
-assert_equal ( x , e );
+assert_checkequal ( x , e );
 // Test with an hypermatrix
 clear n;
 clear e;
 n(1,1,1,1:2)=[1 2];
 x = factorial ( n );
 e(1,1,1,1:2)=[1 2];
-assert_equal ( x , e );
+assert_checkequal ( x , e );
 clear n;
 clear e;
index e271815..e9c3606 100644 (file)
@@ -1,5 +1,5 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 // This file must be used under the terms of the CeCILL.
 // This source file is licensed as described in the file COPYING, which
@@ -9,51 +9,15 @@
 
 // <-- JVM NOT MANDATORY -->
 
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if ( and ( computed == expected ) ) then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
 
 x = factorial ( 1 );
-assert_equal ( x , 1 );
+assert_checkequal ( x , 1 );
 x = factorial ( 2 );
-assert_equal ( x , 2 );
+assert_checkequal ( x , 2 );
 x = factorial ( [1 2 3 4] );
-assert_equal ( x , [1 2 6 24] );
+assert_checkequal ( x , [1 2 6 24] );
 x = factorial ( 170 );
-assert_close ( x , 7.25741561530799896739e306 , 10 * %eps );
+assert_checkalmostequal ( x , 7.25741561530799896739e306 , 10 * %eps );
 // Test with a matrix
 n = [
 1 2 3
@@ -66,14 +30,14 @@ e = [
     24.      120.      720.     
     5040.    40320.    362880.  
 ];
-assert_equal ( x , e );
+assert_checkequal ( x , e );
 // Test with an hypermatrix
 clear n;
 clear e;
 n(1,1,1,1:2)=[1 2];
 x = factorial ( n );
 e(1,1,1,1:2)=[1 2];
-assert_equal ( x , e );
+assert_checkequal ( x , e );
 clear n;
 clear e;
 
index cee1d38..733e3a8 100644 (file)
@@ -1,67 +1,32 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008 - INRIA - Pierre MARECHAL <pierre.marechal@inria.fr>
+// Copyright (C) 2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // <-- JVM NOT MANDATORY -->
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
 // unit tests for gamma() function
 // =============================================================================
-assert_equal ( isnan(gamma(-1.e308)) , %T );
-assert_close ( gamma(-170.6) ,  -2.082900836150297478e-308 , 1.e2 * %eps );
-assert_close ( gamma(-1.5) , 2.36327180120735480529 , %eps );
-assert_equal ( isnan(gamma(-2.)) , %T );
-assert_equal ( isnan(gamma(-1.)) , %T );
-assert_close ( gamma(-0.5) , -3.5449077018110317638389 , %eps );
-assert_equal ( gamma(0.0) , %inf );
-assert_close ( gamma(1.e-307) , 1.e307 , %eps );
-assert_close ( gamma(1.e-100) , 1.e100 , %eps );
-assert_close ( gamma(1.e-30) , 1.e30 , %eps );
-assert_close ( gamma(0.5) , 1.7724538509055161039640 , %eps );
-assert_equal ( gamma(1.0) , 1.0 );
-assert_equal ( gamma(2.0) , 1.0 );
-assert_equal ( gamma(3.0) , 2.0 );
-assert_equal ( gamma(4.0) , 6.0 );
-assert_equal ( gamma(5.0) , 24.0 );
-assert_equal ( gamma(10.0) , 362880.0 );
-assert_close ( gamma(13.0) , 479001600.0 , 1000 * %eps );
-assert_close ( gamma(171) , 7.257415615308056415e+306 , 1.e3 * %eps );
-assert_equal ( gamma(172) , %inf );
-assert_equal ( gamma(%inf) , %inf );
-assert_equal ( gamma(-%inf) , %inf );
+assert_checkequal ( isnan(gamma(-1.e308)) , %T );
+assert_checkalmostequal ( gamma(-170.6) ,  -2.082900836150297478e-308 , 1.e2 * %eps );
+assert_checkalmostequal ( gamma(-1.5) , 2.36327180120735480529 , %eps );
+assert_checkequal ( isnan(gamma(-2.)) , %T );
+assert_checkequal ( isnan(gamma(-1.)) , %T );
+assert_checkalmostequal ( gamma(-0.5) , -3.5449077018110317638389 , %eps );
+assert_checkequal ( gamma(0.0) , %inf );
+assert_checkalmostequal ( gamma(1.e-307) , 1.e307 , %eps );
+assert_checkalmostequal ( gamma(1.e-100) , 1.e100 , %eps );
+assert_checkalmostequal ( gamma(1.e-30) , 1.e30 , %eps );
+assert_checkalmostequal ( gamma(0.5) , 1.7724538509055161039640 , %eps );
+assert_checkequal ( gamma(1.0) , 1.0 );
+assert_checkequal ( gamma(2.0) , 1.0 );
+assert_checkequal ( gamma(3.0) , 2.0 );
+assert_checkequal ( gamma(4.0) , 6.0 );
+assert_checkequal ( gamma(5.0) , 24.0 );
+assert_checkequal ( gamma(10.0) , 362880.0 );
+assert_checkalmostequal ( gamma(13.0) , 479001600.0 , 1000 * %eps );
+assert_checkalmostequal ( gamma(171) , 7.257415615308056415e+306 , 1.e3 * %eps );
+assert_checkequal ( gamma(172) , %inf );
+assert_checkequal ( gamma(%inf) , %inf );
+assert_checkequal ( gamma(-%inf) , %inf );
index bc70676..2024590 100644 (file)
@@ -1,72 +1,37 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008 - INRIA - Pierre MARECHAL <pierre.marechal@inria.fr>
+// Copyright (C) 2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 
 // <-- JVM NOT MANDATORY -->
 
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
 
 // unit tests for gamma() function
 // =============================================================================
 
-assert_equal ( isnan(gamma(-1.e308)) , %T );
-assert_close ( gamma(-170.6) ,  -2.082900836150297478e-308 , 1.e2 * %eps );
-assert_close ( gamma(-1.5) , 2.36327180120735480529 , %eps );
-assert_equal ( isnan(gamma(-2.)) , %T );
-assert_equal ( isnan(gamma(-1.)) , %T );
-assert_close ( gamma(-0.5) , -3.5449077018110317638389 , %eps );
-assert_equal ( gamma(0.0) , %inf );
-assert_close ( gamma(1.e-307) , 1.e307 , %eps );
-assert_close ( gamma(1.e-100) , 1.e100 , %eps );
-assert_close ( gamma(1.e-30) , 1.e30 , %eps );
-assert_close ( gamma(0.5) , 1.7724538509055161039640 , %eps );
-assert_equal ( gamma(1.0) , 1.0 );
-assert_equal ( gamma(2.0) , 1.0 );
-assert_equal ( gamma(3.0) , 2.0 );
-assert_equal ( gamma(4.0) , 6.0 );
-assert_equal ( gamma(5.0) , 24.0 );
-assert_equal ( gamma(10.0) , 362880.0 );
-assert_close ( gamma(13.0) , 479001600.0 , 1000 * %eps );
-assert_close ( gamma(171) , 7.257415615308056415e+306 , 1.e3 * %eps );
-assert_equal ( gamma(172) , %inf );
-assert_equal ( gamma(%inf) , %inf );
-assert_equal ( gamma(-%inf) , %inf );
+assert_checkequal ( isnan(gamma(-1.e308)) , %T );
+assert_checkalmostequal ( gamma(-170.6) ,  -2.082900836150297478e-308 , 1.e2 * %eps );
+assert_checkalmostequal ( gamma(-1.5) , 2.36327180120735480529 , %eps );
+assert_checkequal ( isnan(gamma(-2.)) , %T );
+assert_checkequal ( isnan(gamma(-1.)) , %T );
+assert_checkalmostequal ( gamma(-0.5) , -3.5449077018110317638389 , %eps );
+assert_checkequal ( gamma(0.0) , %inf );
+assert_checkalmostequal ( gamma(1.e-307) , 1.e307 , %eps );
+assert_checkalmostequal ( gamma(1.e-100) , 1.e100 , %eps );
+assert_checkalmostequal ( gamma(1.e-30) , 1.e30 , %eps );
+assert_checkalmostequal ( gamma(0.5) , 1.7724538509055161039640 , %eps );
+assert_checkequal ( gamma(1.0) , 1.0 );
+assert_checkequal ( gamma(2.0) , 1.0 );
+assert_checkequal ( gamma(3.0) , 2.0 );
+assert_checkequal ( gamma(4.0) , 6.0 );
+assert_checkequal ( gamma(5.0) , 24.0 );
+assert_checkequal ( gamma(10.0) , 362880.0 );
+assert_checkalmostequal ( gamma(13.0) , 479001600.0 , 1000 * %eps );
+assert_checkalmostequal ( gamma(171) , 7.257415615308056415e+306 , 1.e3 * %eps );
+assert_checkequal ( gamma(172) , %inf );
+assert_checkequal ( gamma(%inf) , %inf );
+assert_checkequal ( gamma(-%inf) , %inf );
 
index 20344a7..2a86da6 100644 (file)
@@ -1,32 +1,17 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // <-- JVM NOT MANDATORY -->
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if ( and ( computed == expected ) ) then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
 // Test typical case: integral significand M in the middle of the min-max range.
 // x = 1.5
 x = 6755399441055744 * 2^(0-53+1); 
 computed = nearfloat("succ",x);
-assert_equal ( computed , 6755399441055745 * 2^(0-53+1) );
+assert_checkequal ( computed , 6755399441055745 * 2^(0-53+1) );
 computed = nearfloat("pred",x);
-assert_equal ( computed , 6755399441055743 * 2^(0-53+1) );
+assert_checkequal ( computed , 6755399441055743 * 2^(0-53+1) );
 //
 // Test at largest M, for "typical case"
 p = 53;
@@ -35,9 +20,9 @@ largestNormalM = 2^p-1;
 // x = 1.9999999999999997
 x = largestNormalM * 2^(0-53+1); 
 computed = nearfloat("succ",x);
-assert_equal ( computed , 2 );
+assert_checkequal ( computed , 2 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , 1.9999999999999995 );
+assert_checkequal ( computed , 1.9999999999999995 );
 //
 // Test at minimum M, for "typical case"
 p = 53;
@@ -46,101 +31,101 @@ smallestNormalM = 2^(p-1);
 // x = 1
 x = smallestNormalM * 2^(0-53+1); 
 computed = nearfloat("succ",x);
-assert_equal ( computed , 1.0000000000000002 );
+assert_checkequal ( computed , 1.0000000000000002 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , .99999999999999988 );
+assert_checkequal ( computed , .99999999999999988 );
 //
 // Test at signed zero
 x = +0; 
 computed = nearfloat("succ",x);
-assert_equal ( computed , 4.940656458412465D-324 );
+assert_checkequal ( computed , 4.940656458412465D-324 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , -4.94065645841246544D-324 );
+assert_checkequal ( computed , -4.94065645841246544D-324 );
 //
 // Test at signed zero
 x = -0; 
 computed = nearfloat("succ",x);
-assert_equal ( computed , 4.940656458412465D-324 );
+assert_checkequal ( computed , 4.940656458412465D-324 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , -4.94065645841246544D-324 );
+assert_checkequal ( computed , -4.94065645841246544D-324 );
 //
 // Test at +%inf
 x = %inf;
 computed = nearfloat("succ",x);
-assert_equal ( computed , %inf );
+assert_checkequal ( computed , %inf );
 computed = nearfloat("pred",x);
-assert_equal ( computed , 1.7976931348623157D+308 );
+assert_checkequal ( computed , 1.7976931348623157D+308 );
 //
 // Test at -%inf
 x = -%inf;
 computed = nearfloat("succ",x);
-assert_equal ( computed , -1.7976931348623157D+308 );
+assert_checkequal ( computed , -1.7976931348623157D+308 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , -%inf );
+assert_checkequal ( computed , -%inf );
 //
 // Test at nan
 x = %nan;
 computed = nearfloat("succ",x);
-assert_equal ( isnan(computed) , %t );
+assert_checkequal ( isnan(computed) , %t );
 computed = nearfloat("pred",x);
-assert_equal ( isnan(computed) , %t );
+assert_checkequal ( isnan(computed) , %t );
 //
 // Test at vmax, the largest normal before overflow
 x = 1.7976931348623157D+308;
 computed = nearfloat("succ",x);
-assert_equal ( computed , %inf );
+assert_checkequal ( computed , %inf );
 computed = nearfloat("pred",x);
-assert_equal ( computed , 1.7976931348623155D+308 );
+assert_checkequal ( computed , 1.7976931348623155D+308 );
 //
 // Test at -vmax
 x = -1.7976931348623157D+308;
 computed = nearfloat("succ",x);
-assert_equal ( computed , -1.7976931348623155D+308 );
+assert_checkequal ( computed , -1.7976931348623155D+308 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , -%inf );
+assert_checkequal ( computed , -%inf );
 //
 // Test at vmin, the smallest normal
 // x = 2.2250738585072013D-308;
 x = 1 * 2^-1022; 
 computed = nearfloat("succ",x);
-assert_equal ( computed , 1.0000000000000002 * 2^-1022 );
+assert_checkequal ( computed , 1.0000000000000002 * 2^-1022 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , 1.9999999999999995 * 2^-1023 );
+assert_checkequal ( computed , 1.9999999999999995 * 2^-1023 );
 //
 // Test at vmin, the smallest negative normal
 // x = -2.2250738585072013D-308;
 x = -1 * 2^-1022; 
 computed = nearfloat("succ",x);
-assert_equal ( computed , -1.9999999999999995 * 2^-1023 );
+assert_checkequal ( computed , -1.9999999999999995 * 2^-1023 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , -1.0000000000000002 * 2^-1022 );
+assert_checkequal ( computed , -1.0000000000000002 * 2^-1022 );
 //
 // Test at alpha, the smallest subnormal before underflow
 // x = 4.940656458412465D-324; 
 x = 0.0000000000000004440892 * 2^-1023; 
 computed = nearfloat("succ",x);
-assert_equal ( computed , 0.0000000000000008881784 * 2^-1023 );
+assert_checkequal ( computed , 0.0000000000000008881784 * 2^-1023 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , +0 );
+assert_checkequal ( computed , +0 );
 //
 // Test at -alpha, the smallest negative subnormal before underflow
 // x = 4.940656458412465D-324; 
 x = -0.0000000000000004440892 * 2^-1023; 
 computed = nearfloat("succ",x);
-assert_equal ( computed , 0 );
+assert_checkequal ( computed , 0 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , -0.0000000000000008881784 * 2^-1023 );
+assert_checkequal ( computed , -0.0000000000000008881784 * 2^-1023 );
 //
 // Test at an "average" subnormal
 x = 1.9999D-320; 
 computed = nearfloat("succ",x);
-assert_equal ( computed , 2.0004D-320 );
+assert_checkequal ( computed , 2.0004D-320 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , 1.9997e-320 );
+assert_checkequal ( computed , 1.9997e-320 );
 //
 // Test at an "average" negative subnormal
 x = -1.9999D-320; 
 computed = nearfloat("succ",x);
-assert_equal ( computed , -1.9997e-320 );
+assert_checkequal ( computed , -1.9997e-320 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , -2.0004D-320 );
+assert_checkequal ( computed , -2.0004D-320 );
index 2a95305..1bd335d 100644 (file)
@@ -1,35 +1,20 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 
 // <-- JVM NOT MANDATORY -->
 
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if ( and ( computed == expected ) ) then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
 
 // Test typical case: integral significand M in the middle of the min-max range.
 // x = 1.5
 x = 6755399441055744 * 2^(0-53+1); 
 computed = nearfloat("succ",x);
-assert_equal ( computed , 6755399441055745 * 2^(0-53+1) );
+assert_checkequal ( computed , 6755399441055745 * 2^(0-53+1) );
 computed = nearfloat("pred",x);
-assert_equal ( computed , 6755399441055743 * 2^(0-53+1) );
+assert_checkequal ( computed , 6755399441055743 * 2^(0-53+1) );
 //
 // Test at largest M, for "typical case"
 p = 53;
@@ -38,9 +23,9 @@ largestNormalM = 2^p-1;
 // x = 1.9999999999999997
 x = largestNormalM * 2^(0-53+1); 
 computed = nearfloat("succ",x);
-assert_equal ( computed , 2 );
+assert_checkequal ( computed , 2 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , 1.9999999999999995 );
+assert_checkequal ( computed , 1.9999999999999995 );
 //
 // Test at minimum M, for "typical case"
 p = 53;
@@ -49,102 +34,102 @@ smallestNormalM = 2^(p-1);
 // x = 1
 x = smallestNormalM * 2^(0-53+1); 
 computed = nearfloat("succ",x);
-assert_equal ( computed , 1.0000000000000002 );
+assert_checkequal ( computed , 1.0000000000000002 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , .99999999999999988 );
+assert_checkequal ( computed , .99999999999999988 );
 //
 // Test at signed zero
 x = +0; 
 computed = nearfloat("succ",x);
-assert_equal ( computed , 4.940656458412465D-324 );
+assert_checkequal ( computed , 4.940656458412465D-324 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , -4.94065645841246544D-324 );
+assert_checkequal ( computed , -4.94065645841246544D-324 );
 //
 // Test at signed zero
 x = -0; 
 computed = nearfloat("succ",x);
-assert_equal ( computed , 4.940656458412465D-324 );
+assert_checkequal ( computed , 4.940656458412465D-324 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , -4.94065645841246544D-324 );
+assert_checkequal ( computed , -4.94065645841246544D-324 );
 //
 // Test at +%inf
 x = %inf;
 computed = nearfloat("succ",x);
-assert_equal ( computed , %inf );
+assert_checkequal ( computed , %inf );
 computed = nearfloat("pred",x);
-assert_equal ( computed , 1.7976931348623157D+308 );
+assert_checkequal ( computed , 1.7976931348623157D+308 );
 //
 // Test at -%inf
 x = -%inf;
 computed = nearfloat("succ",x);
-assert_equal ( computed , -1.7976931348623157D+308 );
+assert_checkequal ( computed , -1.7976931348623157D+308 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , -%inf );
+assert_checkequal ( computed , -%inf );
 //
 // Test at nan
 x = %nan;
 computed = nearfloat("succ",x);
-assert_equal ( isnan(computed) , %t );
+assert_checkequal ( isnan(computed) , %t );
 computed = nearfloat("pred",x);
-assert_equal ( isnan(computed) , %t );
+assert_checkequal ( isnan(computed) , %t );
 //
 // Test at vmax, the largest normal before overflow
 x = 1.7976931348623157D+308;
 computed = nearfloat("succ",x);
-assert_equal ( computed , %inf );
+assert_checkequal ( computed , %inf );
 computed = nearfloat("pred",x);
-assert_equal ( computed , 1.7976931348623155D+308 );
+assert_checkequal ( computed , 1.7976931348623155D+308 );
 //
 // Test at -vmax
 x = -1.7976931348623157D+308;
 computed = nearfloat("succ",x);
-assert_equal ( computed , -1.7976931348623155D+308 );
+assert_checkequal ( computed , -1.7976931348623155D+308 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , -%inf );
+assert_checkequal ( computed , -%inf );
 //
 // Test at vmin, the smallest normal
 // x = 2.2250738585072013D-308;
 x = 1 * 2^-1022; 
 computed = nearfloat("succ",x);
-assert_equal ( computed , 1.0000000000000002 * 2^-1022 );
+assert_checkequal ( computed , 1.0000000000000002 * 2^-1022 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , 1.9999999999999995 * 2^-1023 );
+assert_checkequal ( computed , 1.9999999999999995 * 2^-1023 );
 //
 // Test at vmin, the smallest negative normal
 // x = -2.2250738585072013D-308;
 x = -1 * 2^-1022; 
 computed = nearfloat("succ",x);
-assert_equal ( computed , -1.9999999999999995 * 2^-1023 );
+assert_checkequal ( computed , -1.9999999999999995 * 2^-1023 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , -1.0000000000000002 * 2^-1022 );
+assert_checkequal ( computed , -1.0000000000000002 * 2^-1022 );
 //
 // Test at alpha, the smallest subnormal before underflow
 // x = 4.940656458412465D-324; 
 x = 0.0000000000000004440892 * 2^-1023; 
 computed = nearfloat("succ",x);
-assert_equal ( computed , 0.0000000000000008881784 * 2^-1023 );
+assert_checkequal ( computed , 0.0000000000000008881784 * 2^-1023 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , +0 );
+assert_checkequal ( computed , +0 );
 //
 // Test at -alpha, the smallest negative subnormal before underflow
 // x = 4.940656458412465D-324; 
 x = -0.0000000000000004440892 * 2^-1023; 
 computed = nearfloat("succ",x);
-assert_equal ( computed , 0 );
+assert_checkequal ( computed , 0 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , -0.0000000000000008881784 * 2^-1023 );
+assert_checkequal ( computed , -0.0000000000000008881784 * 2^-1023 );
 //
 // Test at an "average" subnormal
 x = 1.9999D-320; 
 computed = nearfloat("succ",x);
-assert_equal ( computed , 2.0004D-320 );
+assert_checkequal ( computed , 2.0004D-320 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , 1.9997e-320 );
+assert_checkequal ( computed , 1.9997e-320 );
 //
 // Test at an "average" negative subnormal
 x = -1.9999D-320; 
 computed = nearfloat("succ",x);
-assert_equal ( computed , -1.9997e-320 );
+assert_checkequal ( computed , -1.9997e-320 );
 computed = nearfloat("pred",x);
-assert_equal ( computed , -2.0004D-320 );
+assert_checkequal ( computed , -2.0004D-320 );
 
index 2144325..3e71660 100644 (file)
@@ -1,47 +1,11 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008 - INRIA - Serge Steer
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // <-- JVM NOT MANDATORY -->
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
 // Maple code used to create reference
 // Digits := 40; 
 // writeto("tand.ref"); interface(prettyprint = 0); 
@@ -420,33 +384,33 @@ e=[
 0.
 ];
 c = tand(x);
-assert_close ( c , e , 40 * %eps );
+assert_checkalmostequal ( c , e , 40 * %eps );
 // Turn a lot around the circle
 x1 = x + 2^6*360; 
 c = tand(x1);
-assert_close ( c , e , 40 * %eps );
+assert_checkalmostequal ( c , e , 40 * %eps );
 // Turn a lot around the circle, the other side
 x2 = x - 2^6*360; 
 c = tand(x2);
-assert_close ( c , e , 40 * %eps );
-assert_equal ( tand(0) , 0 );
-assert_equal ( tand(360) , 0 );
-assert_equal ( tand(-360) , 0 );
-assert_equal ( tand(180) , 0 );
-assert_equal ( tand(-180) , 0 );
-assert_close ( tand(30) , 1/sqrt(3) , %eps );
-assert_close ( tand(45) , 1         , 2 * %eps );
-assert_close ( tand(60) , sqrt(3)   , 2*%eps );
-assert_equal ( isnan(tand(90))  , %t );
-assert_equal ( isnan(tand(-90)) , %t );
-assert_equal ( isnan(tand(270)) , %t );
-assert_equal ( isnan(tand(-270)) , %t );
-assert_equal ( isnan(tand(-%inf)) , %t );
-assert_equal ( isnan(tand(%inf))  , %t );
-assert_equal ( isnan(tand(%nan))  , %t );
-assert_equal ( tand([])  , [] );
+assert_checkalmostequal ( c , e , 40 * %eps );
+assert_checkequal ( tand(0) , 0 );
+assert_checkequal ( tand(360) , 0 );
+assert_checkequal ( tand(-360) , 0 );
+assert_checkequal ( tand(180) , 0 );
+assert_checkequal ( tand(-180) , 0 );
+assert_checkalmostequal ( tand(30) , 1/sqrt(3) , %eps );
+assert_checkalmostequal ( tand(45) , 1         , 2 * %eps );
+assert_checkalmostequal ( tand(60) , sqrt(3)   , 2*%eps );
+assert_checkequal ( isnan(tand(90))  , %t );
+assert_checkequal ( isnan(tand(-90)) , %t );
+assert_checkequal ( isnan(tand(270)) , %t );
+assert_checkequal ( isnan(tand(-270)) , %t );
+assert_checkequal ( isnan(tand(-%inf)) , %t );
+assert_checkequal ( isnan(tand(%inf))  , %t );
+assert_checkequal ( isnan(tand(%nan))  , %t );
+assert_checkequal ( tand([])  , [] );
 ieee(0)
-assert_equal ( tand(0) , 0 );
-assert_close ( tand(30) , 1/sqrt(3) , %eps );
-assert_close ( tand(45) , 1         , 2 * %eps );
-assert_close ( tand(60) , sqrt(3)   , 2*%eps );
+assert_checkequal ( tand(0) , 0 );
+assert_checkalmostequal ( tand(30) , 1/sqrt(3) , %eps );
+assert_checkalmostequal ( tand(45) , 1         , 2 * %eps );
+assert_checkalmostequal ( tand(60) , sqrt(3)   , 2*%eps );
index 1b88df3..8b661b1 100644 (file)
@@ -1,49 +1,13 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008 - INRIA - Serge Steer
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 
 // <-- JVM NOT MANDATORY -->
 
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
 
 // Maple code used to create reference
 // Digits := 40; 
@@ -425,43 +389,43 @@ e=[
 0.
 ];
 c = tand(x);
-assert_close ( c , e , 40 * %eps );
+assert_checkalmostequal ( c , e , 40 * %eps );
 
 // Turn a lot around the circle
 x1 = x + 2^6*360; 
 c = tand(x1);
-assert_close ( c , e , 40 * %eps );
+assert_checkalmostequal ( c , e , 40 * %eps );
 // Turn a lot around the circle, the other side
 x2 = x - 2^6*360; 
 c = tand(x2);
-assert_close ( c , e , 40 * %eps );
+assert_checkalmostequal ( c , e , 40 * %eps );
 
-assert_equal ( tand(0) , 0 );
-assert_equal ( tand(360) , 0 );
-assert_equal ( tand(-360) , 0 );
+assert_checkequal ( tand(0) , 0 );
+assert_checkequal ( tand(360) , 0 );
+assert_checkequal ( tand(-360) , 0 );
 
-assert_equal ( tand(180) , 0 );
-assert_equal ( tand(-180) , 0 );
+assert_checkequal ( tand(180) , 0 );
+assert_checkequal ( tand(-180) , 0 );
 
-assert_close ( tand(30) , 1/sqrt(3) , %eps );
-assert_close ( tand(45) , 1         , 2 * %eps );
-assert_close ( tand(60) , sqrt(3)   , 2*%eps );
+assert_checkalmostequal ( tand(30) , 1/sqrt(3) , %eps );
+assert_checkalmostequal ( tand(45) , 1         , 2 * %eps );
+assert_checkalmostequal ( tand(60) , sqrt(3)   , 2*%eps );
 
-assert_equal ( isnan(tand(90))  , %t );
-assert_equal ( isnan(tand(-90)) , %t );
-assert_equal ( isnan(tand(270)) , %t );
-assert_equal ( isnan(tand(-270)) , %t );
+assert_checkequal ( isnan(tand(90))  , %t );
+assert_checkequal ( isnan(tand(-90)) , %t );
+assert_checkequal ( isnan(tand(270)) , %t );
+assert_checkequal ( isnan(tand(-270)) , %t );
 
-assert_equal ( isnan(tand(-%inf)) , %t );
-assert_equal ( isnan(tand(%inf))  , %t );
-assert_equal ( isnan(tand(%nan))  , %t );
+assert_checkequal ( isnan(tand(-%inf)) , %t );
+assert_checkequal ( isnan(tand(%inf))  , %t );
+assert_checkequal ( isnan(tand(%nan))  , %t );
 
-assert_equal ( tand([])  , [] );
+assert_checkequal ( tand([])  , [] );
 
 ieee(0)
-assert_equal ( tand(0) , 0 );
-assert_close ( tand(30) , 1/sqrt(3) , %eps );
-assert_close ( tand(45) , 1         , 2 * %eps );
-assert_close ( tand(60) , sqrt(3)   , 2*%eps );
+assert_checkequal ( tand(0) , 0 );
+assert_checkalmostequal ( tand(30) , 1/sqrt(3) , %eps );
+assert_checkalmostequal ( tand(45) , 1         , 2 * %eps );
+assert_checkalmostequal ( tand(60) , sqrt(3)   , 2*%eps );
 
 
index 902d9fd..b0bc952 100644 (file)
@@ -2,7 +2,7 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008 - INRIA - Allan CORNET
 // Copyright (C) 2009 - INRIA - Michael Baudin, Antoine Elias
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // <-- Bugzilla URL -->
 // http://bugzilla.scilab.org/show_bug.cgi?id=2775
 //
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if ( type(computed) == 1 & type(expected) == 1 ) then
-    csize = size (computed,"*")
-    esize = size (expected,"*")
-    [cnonan , cnumb] = thrownan(computed)
-    [enonan , enumb] = thrownan(expected)
-    if ( and(enonan == cnonan) & and(enumb == cnumb) ) then
-      flag = 1;
-    else
-      flag = 0;
-    end
-  else
-    if computed==expected then
-      flag = 1;
-    else
-      flag = 0;
-    end
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
 // Bibliography :
 // "IEEE Standard for Floating-Point Arithmetic"
 // IEEE Std 754-2008
@@ -46,5 +19,5 @@ endfunction
 // (Revision of IEEE Std 754-1985)
 res_1 = 0.0 * %nan;
 res_2 = %nan * 0.0;
-assert_equal ( res_1 , %nan );
-assert_equal ( res_2 , %nan );
+assert_checkequal ( res_1 , %nan );
+assert_checkequal ( res_2 , %nan );
index 38fd20b..65ff4a5 100644 (file)
@@ -2,7 +2,7 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008 - INRIA - Allan CORNET
 // Copyright (C) 2009 - INRIA - Michael Baudin, Antoine Elias
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 //
 
 
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if ( type(computed) == 1 & type(expected) == 1 ) then
-    csize = size (computed,"*")
-    esize = size (expected,"*")
-    [cnonan , cnumb] = thrownan(computed)
-    [enonan , enumb] = thrownan(expected)
-    if ( and(enonan == cnonan) & and(enumb == cnumb) ) then
-      flag = 1;
-    else
-      flag = 0;
-    end
-  else
-    if computed==expected then
-      flag = 1;
-    else
-      flag = 0;
-    end
-  end
-  if flag <> 1 then pause,end
-endfunction
 
 // Bibliography :
 // "IEEE Standard for Floating-Point Arithmetic"
@@ -51,7 +24,7 @@ endfunction
 res_1 = 0.0 * %nan;
 res_2 = %nan * 0.0;
 
-assert_equal ( res_1 , %nan );
-assert_equal ( res_2 , %nan );
+assert_checkequal ( res_1 , %nan );
+assert_checkequal ( res_2 , %nan );
 
 
index 9038ed9..5b31001 100644 (file)
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) ????-2008 - INRIA Michael Baudin
+// Copyright (C) 2008 - INRIA Michael Baudin
+// Copyright (C) 2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // TODO : use relative error criteria instead of absolute error
 eps=100*%eps;
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed , expected , epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
-// inf
-if norm([1,2,3,-1,-2,-3],0)<>%inf then bugmes();quit;end
-if ~isnan(norm([1,2,3,-1,-2,-3],%nan)) then bugmes();quit;end
-if norm([])<>0 then bugmes();quit;end
+// inf 
+assert_checkequal ( norm([1,2,3,-1,-2,-3],0) , %inf );
+assert_checkequal ( norm([1,2,3,-1,-2,-3],%nan) , %nan );
+assert_checkequal ( norm([]) , 0 );
 // vector
 x=[1,2,3,-4];
-if abs(norm(x,1) - sum(abs(x))) > eps then bugmes();quit;end
-if abs(norm(x,2) - sqrt(sum(abs(x).*abs(x)))) > eps then bugmes();quit;end
-if abs(norm(x,2) - norm(x)) > eps then bugmes();quit;end
+assert_checkalmostequal ( norm(x,1) , sum(abs(x))               , eps );
+assert_checkalmostequal ( norm(x,2) , sqrt(sum(abs(x).*abs(x))) , eps );
+assert_checkalmostequal ( norm(x,2) , norm(x)                   , eps );
 p=0.5;
-if abs(norm(x,p) - sum(abs(x)^p)^(1/p)) > eps then bugmes();quit;end
+assert_checkalmostequal ( norm(x,p) , sum(abs(x)^p)^(1/p)       , eps );
 p=2.5;
-if abs(norm(x,p) - sum(abs(x)^p)^(1/p)) > eps then bugmes();quit;end
-if abs(norm(x,'inf') -max(abs(x))) > eps then bugmes();quit;end
-if abs(norm(x,'inf') -norm(x,%inf)) > eps then bugmes();quit;end
-if abs(norm(x,'fro') -norm(x,2)) > eps then bugmes();quit;end
-// complex
+assert_checkalmostequal ( norm(x,p) ,     sum(abs(x)^p)^(1/p)   , eps );
+assert_checkalmostequal ( norm(x,'inf') , max(abs(x))           , eps );
+assert_checkalmostequal ( norm(x,'inf') , norm(x,%inf)          , eps );
+assert_checkalmostequal ( norm(x,'fro') , norm(x,2)             , eps );
+// complex 
 x=x+%i*x;
-if abs(norm(x,1) - sum(abs(x))) > eps then bugmes();quit;end
-if abs(norm(x,2) - sqrt(sum(abs(x).*abs(x)))) > eps then bugmes();quit;end
-if abs(norm(x,2) - norm(x)) > eps then bugmes();quit;end
+assert_checkalmostequal ( norm(x,1) , sum(abs(x))               , eps );
+assert_checkalmostequal ( norm(x,2) , sqrt(sum(abs(x).*abs(x))) , eps );
+assert_checkalmostequal ( norm(x,2) , norm(x)                   , eps );
 p=0.5;
-// 100*%eps is needed for linux
-if abs(norm(x,p) - max(abs(x))*sum((abs(x)/max(abs(x)))^p)^(1/p))> 100*%eps then bugmes();quit;end
+// 100*%eps is needed for linux 
+assert_checkalmostequal ( norm(x,p) , max(abs(x))*sum((abs(x)/max(abs(x)))^p)^(1/p) , 100*%eps );
 p=2.5;
-if abs(norm(x,p) - max(abs(x))*sum((abs(x)/max(abs(x)))^p)^(1/p))> 100*%eps then bugmes();quit;end
-if abs(norm(x,'inf') -max(abs(x)))> eps then bugmes();quit;end
-if abs(norm(x,'inf') -norm(x,%inf)) > eps then bugmes();quit;end
-if abs(norm(x,'fro') -norm(x,2))> eps then bugmes();quit;end
-// scalar
+assert_checkalmostequal ( norm(x,p) , max(abs(x))*sum((abs(x)/max(abs(x)))^p)^(1/p) , 100*%eps );
+assert_checkalmostequal ( norm(x,'inf') , max(abs(x))   , 100*%eps);
+assert_checkalmostequal ( norm(x,'inf') , norm(x,%inf)  , 100*%eps);
+// The Frobenius norm of this complex input x can be numerically complex,
+// e.g. 7.7459667 - 1.147D-16i
+// see http://bugzilla.scilab.org/show_bug.cgi?id=9204
+// assert_checkalmostequal ( norm(x,'fro') , norm(x,2)     , 100*%eps  , %eps );
+// scalar 
 x=[1.23];
-if abs(norm(x,1) - sum(abs(x))) > eps then bugmes();quit;end
-if abs(norm(x,2) - sqrt(sum(abs(x).*abs(x)))) > eps then bugmes();quit;end
-if abs(norm(x,2) - norm(x)) > eps then bugmes();quit;end
+assert_checkalmostequal ( norm(x,1) , sum(abs(x))               , 100*%eps );
+assert_checkalmostequal ( norm(x,2) , sqrt(sum(abs(x).*abs(x))) , 100*%eps );
+assert_checkalmostequal ( norm(x,2) , norm(x)                   , 100*%eps ); 
 p=0.5;
-if abs(norm(x,p) - sum(abs(x)^p)^(1/p)) > eps then bugmes();quit;end
+assert_checkalmostequal ( norm(x,p) , sum(abs(x)^p)^(1/p) ,  100*%eps );
 p=2.5;
-if abs(norm(x,p) - sum(abs(x)^p)^(1/p)) > eps then bugmes();quit;end
-if abs(norm(x,'inf') -max(abs(x))) > eps then bugmes();quit;end
-if abs(norm(x,'inf') -norm(x,%inf)) > eps then bugmes();quit;end
-if abs(norm(x,'fro') -norm(x,2)) > eps then bugmes();quit;end
-// Matrices
+assert_checkalmostequal ( norm(x,p) ,     sum(abs(x)^p)^(1/p) , 100*%eps );
+assert_checkalmostequal ( norm(x,'inf') , max(abs(x))         , 100*%eps);
+assert_checkalmostequal ( norm(x,'inf') , norm(x,%inf)        , 100*%eps );
+assert_checkalmostequal ( norm(x,'fro') , norm(x,2)           , 100*%eps );
+// Matrices 
 a=rand(10,10,'g');
-if abs(norm(a,1) - max(sum(abs(a),'r'))) > eps then bugmes();quit;end
-if abs(norm(a,'inf') - max(sum(abs(a),'c'))) > eps then bugmes();quit;end
-if abs(norm(a,%inf) - max(sum(abs(a),'c'))) > eps then bugmes();quit;end
-if abs(norm(a,2) - max(svd(a))) > eps then bugmes();quit;end
-if abs(norm(a,'fro') - norm(matrix(a,1,size(a,'*')),2)) > eps then bugmes();quit;end
+assert_checkalmostequal ( norm(a,1) , max(sum(abs(a),'r')),                100*%eps );
+assert_checkalmostequal ( norm(a,'inf') , max(sum(abs(a),'c')),            100*%eps );
+assert_checkalmostequal ( norm(a,%inf) , max(sum(abs(a),'c')),             100*%eps );
+assert_checkalmostequal ( norm(a,2) , max(svd(a)),                         100*%eps );
+assert_checkalmostequal ( norm(a,'fro') , norm(matrix(a,1,size(a,'*')),2), 100*%eps );
 a=a+%i*a;
-if abs(norm(a,1) - max(sum(abs(a),'r'))) > eps then bugmes();quit;end
-if abs(norm(a,'inf') - max(sum(abs(a),'c'))) > eps then bugmes();quit;end
-if abs(norm(a,%inf) - max(sum(abs(a),'c'))) > eps then bugmes();quit;end
-if abs(norm(a,2) - max(svd(a))) > eps then bugmes();quit;end
-if abs(norm(a,'fro') - norm(matrix(a,1,size(a,'*')),2)) > eps then bugmes();quit;end
+assert_checkalmostequal ( norm(a,1) , max(sum(abs(a),'r')),                100*%eps );
+assert_checkalmostequal ( norm(a,'inf') , max(sum(abs(a),'c')),            100*%eps );
+assert_checkalmostequal ( norm(a,%inf) , max(sum(abs(a),'c')),             100*%eps );
+assert_checkalmostequal ( norm(a,2) , max(svd(a)),                         100*%eps );
+// see http://bugzilla.scilab.org/show_bug.cgi?id=9204
+// assert_checkalmostequal ( norm(a,'fro') , norm(matrix(a,1,size(a,'*')),2), 100*%eps );
 //
 // Difficult cases for large/small vectors
 //
 //norm 2
 x = 1.e307 * [1 1];
-assert_close ( norm(x) , sqrt(2) * 1.e307 , %eps );
+assert_checkequal ( norm(x) , sqrt(2) * 1.e307 );
 x = 1.e-307 * [1 1];
-assert_close ( norm(x) , sqrt(2) * 1.e-307 , %eps );
+assert_checkequal ( norm(x) , sqrt(2) * 1.e-307 );
 // norm f
 x = 1.e307 * [1 1];
-assert_close ( norm(x,"f") , sqrt(2) * 1.e307 , %eps );
+assert_checkequal ( norm(x,"f") , sqrt(2) * 1.e307 );
 x = 1.e-307 * [1 1];
-assert_close ( norm(x,"f") , sqrt(2) * 1.e-307 , %eps );
+assert_checkequal ( norm(x,"f") , sqrt(2) * 1.e-307 );
 //
 // Difficult cases for large/small matrices
 //
 // norm f - case 1 : n < m
 x = 1.e307 * ones(10,20);
-assert_close ( norm(x,"f") , sqrt(200) * 1.e307 , %eps );
+assert_checkequal ( norm(x,"f") , sqrt(200) * 1.e307 );
 x = 1.e-307 * ones(10,20);
-assert_close ( norm(x,"f") , sqrt(200) * 1.e-307 , %eps );
+assert_checkequal ( norm(x,"f") , sqrt(200) * 1.e-307 );
 // norm f - case 2 : n > m
 x = 1.e307 * ones(20,10);
-assert_close ( norm(x,"f") , sqrt(200) * 1.e307 , %eps );
+assert_checkequal ( norm(x,"f") , sqrt(200) * 1.e307 );
 x = 1.e-307 * ones(20,10);
-assert_close ( norm(x,"f") , sqrt(200) * 1.e-307 , %eps );
+assert_checkequal ( norm(x,"f") , sqrt(200) * 1.e-307 );
 //
 // Special cases for zero vectors
 //
 // 2-norm of a zero vector
 x=[0 0 0];
-assert_close ( norm(x,2) , 0.0 , %eps );
+assert_checkequal ( norm(x,2) , 0.0 );
 // f-norm of a zero vector
 x=zeros(4,1);
-assert_close ( norm(x,"f") , 0.0 , %eps );
+assert_checkequal ( norm(x,"f") , 0.0 );
 // f-norm of a zero matrix, case 1 n>m
 x=zeros(4,2);
-assert_close ( norm(x,"f") , 0.0 , %eps );
+assert_checkequal ( norm(x,"f") , 0.0 );
 // f-norm of a zero matrix, case 2 m>n
 x=zeros(2,4);
-assert_close ( norm(x,"f") , 0.0 , %eps );
+assert_checkequal ( norm(x,"f") , 0.0 );
index d338341..cc9a70f 100644 (file)
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) ????-2008 - INRIA Michael Baudin
+// Copyright (C) 2008 - INRIA Michael Baudin
+// Copyright (C) 2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // TODO : use relative error criteria instead of absolute error
 eps=100*%eps;
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed , expected , epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
+
 
 // inf 
-if norm([1,2,3,-1,-2,-3],0)<>%inf then pause,end 
-if ~isnan(norm([1,2,3,-1,-2,-3],%nan)) then pause,end 
-if norm([])<>0 then pause,end
+assert_checkequal ( norm([1,2,3,-1,-2,-3],0) , %inf );
+assert_checkequal ( norm([1,2,3,-1,-2,-3],%nan) , %nan );
+assert_checkequal ( norm([]) , 0 );
 // vector
 x=[1,2,3,-4];
-if abs(norm(x,1) - sum(abs(x))) > eps then pause,end
-if abs(norm(x,2) - sqrt(sum(abs(x).*abs(x)))) > eps then pause,end
-if abs(norm(x,2) - norm(x)) > eps then pause,end
+assert_checkalmostequal ( norm(x,1) , sum(abs(x))               , eps );
+assert_checkalmostequal ( norm(x,2) , sqrt(sum(abs(x).*abs(x))) , eps );
+assert_checkalmostequal ( norm(x,2) , norm(x)                   , eps );
 p=0.5;
-if abs(norm(x,p) - sum(abs(x)^p)^(1/p)) > eps then pause,end
+assert_checkalmostequal ( norm(x,p) , sum(abs(x)^p)^(1/p)       , eps );
 p=2.5;
-if abs(norm(x,p) - sum(abs(x)^p)^(1/p)) > eps then pause,end
-if abs(norm(x,'inf') -max(abs(x))) > eps then pause,end
-if abs(norm(x,'inf') -norm(x,%inf)) > eps then pause,end
-if abs(norm(x,'fro') -norm(x,2)) > eps then pause,end
+assert_checkalmostequal ( norm(x,p) ,     sum(abs(x)^p)^(1/p)   , eps );
+assert_checkalmostequal ( norm(x,'inf') , max(abs(x))           , eps );
+assert_checkalmostequal ( norm(x,'inf') , norm(x,%inf)          , eps );
+assert_checkalmostequal ( norm(x,'fro') , norm(x,2)             , eps );
 // complex 
 x=x+%i*x;
-if abs(norm(x,1) - sum(abs(x))) > eps then pause,end
-if abs(norm(x,2) - sqrt(sum(abs(x).*abs(x)))) > eps then pause,end
-if abs(norm(x,2) - norm(x)) > eps then pause,end
+assert_checkalmostequal ( norm(x,1) , sum(abs(x))               , eps );
+assert_checkalmostequal ( norm(x,2) , sqrt(sum(abs(x).*abs(x))) , eps );
+assert_checkalmostequal ( norm(x,2) , norm(x)                   , eps );
 p=0.5;
 // 100*%eps is needed for linux 
-if abs(norm(x,p) - max(abs(x))*sum((abs(x)/max(abs(x)))^p)^(1/p))> 100*%eps then pause,end
+assert_checkalmostequal ( norm(x,p) , max(abs(x))*sum((abs(x)/max(abs(x)))^p)^(1/p) , 100*%eps );
 p=2.5;
-if abs(norm(x,p) - max(abs(x))*sum((abs(x)/max(abs(x)))^p)^(1/p))> 100*%eps then pause,end
-if abs(norm(x,'inf') -max(abs(x)))> eps then pause,end
-if abs(norm(x,'inf') -norm(x,%inf)) > eps then pause,end
-if abs(norm(x,'fro') -norm(x,2))> eps then pause,end
+assert_checkalmostequal ( norm(x,p) , max(abs(x))*sum((abs(x)/max(abs(x)))^p)^(1/p) , 100*%eps );
+assert_checkalmostequal ( norm(x,'inf') , max(abs(x))   , 100*%eps);
+assert_checkalmostequal ( norm(x,'inf') , norm(x,%inf)  , 100*%eps);
+// The Frobenius norm of this complex input x can be numerically complex,
+// e.g. 7.7459667 - 1.147D-16i
+// see http://bugzilla.scilab.org/show_bug.cgi?id=9204
+// assert_checkalmostequal ( norm(x,'fro') , norm(x,2)     , 100*%eps  , %eps );
 
 // scalar 
 
 x=[1.23];
-if abs(norm(x,1) - sum(abs(x))) > eps then pause,end
-if abs(norm(x,2) - sqrt(sum(abs(x).*abs(x)))) > eps then pause,end
-if abs(norm(x,2) - norm(x)) > eps then pause,end
+assert_checkalmostequal ( norm(x,1) , sum(abs(x))               , 100*%eps );
+assert_checkalmostequal ( norm(x,2) , sqrt(sum(abs(x).*abs(x))) , 100*%eps );
+assert_checkalmostequal ( norm(x,2) , norm(x)                   , 100*%eps ); 
 p=0.5;
-if abs(norm(x,p) - sum(abs(x)^p)^(1/p)) > eps then pause,end
+assert_checkalmostequal ( norm(x,p) , sum(abs(x)^p)^(1/p) ,  100*%eps );
 p=2.5;
-if abs(norm(x,p) - sum(abs(x)^p)^(1/p)) > eps then pause,end
-if abs(norm(x,'inf') -max(abs(x))) > eps then pause,end
-if abs(norm(x,'inf') -norm(x,%inf)) > eps then pause,end
-if abs(norm(x,'fro') -norm(x,2)) > eps then pause,end
+assert_checkalmostequal ( norm(x,p) ,     sum(abs(x)^p)^(1/p) , 100*%eps );
+assert_checkalmostequal ( norm(x,'inf') , max(abs(x))         , 100*%eps);
+assert_checkalmostequal ( norm(x,'inf') , norm(x,%inf)        , 100*%eps );
+assert_checkalmostequal ( norm(x,'fro') , norm(x,2)           , 100*%eps );
 
 // Matrices 
 a=rand(10,10,'g');
-if abs(norm(a,1) - max(sum(abs(a),'r'))) > eps then pause,end
-if abs(norm(a,'inf') - max(sum(abs(a),'c'))) > eps then pause,end
-if abs(norm(a,%inf) - max(sum(abs(a),'c'))) > eps then pause,end
-if abs(norm(a,2) - max(svd(a))) > eps then pause,end
-if abs(norm(a,'fro') - norm(matrix(a,1,size(a,'*')),2)) > eps then pause,end
+assert_checkalmostequal ( norm(a,1) , max(sum(abs(a),'r')),                100*%eps );
+assert_checkalmostequal ( norm(a,'inf') , max(sum(abs(a),'c')),            100*%eps );
+assert_checkalmostequal ( norm(a,%inf) , max(sum(abs(a),'c')),             100*%eps );
+assert_checkalmostequal ( norm(a,2) , max(svd(a)),                         100*%eps );
+assert_checkalmostequal ( norm(a,'fro') , norm(matrix(a,1,size(a,'*')),2), 100*%eps );
 
 a=a+%i*a;
-if abs(norm(a,1) - max(sum(abs(a),'r'))) > eps then pause,end
-if abs(norm(a,'inf') - max(sum(abs(a),'c'))) > eps then pause,end
-if abs(norm(a,%inf) - max(sum(abs(a),'c'))) > eps then pause,end
-if abs(norm(a,2) - max(svd(a))) > eps then pause,end
-if abs(norm(a,'fro') - norm(matrix(a,1,size(a,'*')),2)) > eps then pause,end
+assert_checkalmostequal ( norm(a,1) , max(sum(abs(a),'r')),                100*%eps );
+assert_checkalmostequal ( norm(a,'inf') , max(sum(abs(a),'c')),            100*%eps );
+assert_checkalmostequal ( norm(a,%inf) , max(sum(abs(a),'c')),             100*%eps );
+assert_checkalmostequal ( norm(a,2) , max(svd(a)),                         100*%eps );
+// see http://bugzilla.scilab.org/show_bug.cgi?id=9204
+// assert_checkalmostequal ( norm(a,'fro') , norm(matrix(a,1,size(a,'*')),2), 100*%eps );
 
 //
 // Difficult cases for large/small vectors
 //
 //norm 2
 x = 1.e307 * [1 1];
-assert_close ( norm(x) , sqrt(2) * 1.e307 , %eps );
+assert_checkequal ( norm(x) , sqrt(2) * 1.e307 );
 x = 1.e-307 * [1 1];
-assert_close ( norm(x) , sqrt(2) * 1.e-307 , %eps );
+assert_checkequal ( norm(x) , sqrt(2) * 1.e-307 );
 // norm f
 x = 1.e307 * [1 1];
-assert_close ( norm(x,"f") , sqrt(2) * 1.e307 , %eps );
+assert_checkequal ( norm(x,"f") , sqrt(2) * 1.e307 );
 x = 1.e-307 * [1 1];
-assert_close ( norm(x,"f") , sqrt(2) * 1.e-307 , %eps );
+assert_checkequal ( norm(x,"f") , sqrt(2) * 1.e-307 );
 //
 // Difficult cases for large/small matrices
 //
 // norm f - case 1 : n < m
 x = 1.e307 * ones(10,20);
-assert_close ( norm(x,"f") , sqrt(200) * 1.e307 , %eps );
+assert_checkequal ( norm(x,"f") , sqrt(200) * 1.e307 );
 x = 1.e-307 * ones(10,20);
-assert_close ( norm(x,"f") , sqrt(200) * 1.e-307 , %eps );
+assert_checkequal ( norm(x,"f") , sqrt(200) * 1.e-307 );
 // norm f - case 2 : n > m
 x = 1.e307 * ones(20,10);
-assert_close ( norm(x,"f") , sqrt(200) * 1.e307 , %eps );
+assert_checkequal ( norm(x,"f") , sqrt(200) * 1.e307 );
 x = 1.e-307 * ones(20,10);
-assert_close ( norm(x,"f") , sqrt(200) * 1.e-307 , %eps );
+assert_checkequal ( norm(x,"f") , sqrt(200) * 1.e-307 );
 //
 // Special cases for zero vectors
 //
 // 2-norm of a zero vector
 x=[0 0 0];
-assert_close ( norm(x,2) , 0.0 , %eps );
+assert_checkequal ( norm(x,2) , 0.0 );
 // f-norm of a zero vector
 x=zeros(4,1);
-assert_close ( norm(x,"f") , 0.0 , %eps );
+assert_checkequal ( norm(x,"f") , 0.0 );
 // f-norm of a zero matrix, case 1 n>m
 x=zeros(4,2);
-assert_close ( norm(x,"f") , 0.0 , %eps );
+assert_checkequal ( norm(x,"f") , 0.0 );
 // f-norm of a zero matrix, case 2 m>n
 x=zeros(2,4);
-assert_close ( norm(x,"f") , 0.0 , %eps );
+assert_checkequal ( norm(x,"f") , 0.0 );
 
index baca5d3..591e5ab 100644 (file)
@@ -1,6 +1,6 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008-2009 - INRIA - Michael Baudin
-// Copyright (C) 2009-2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2009-2011 - DIGITEO - Michael Baudin
 //
 // This file must be used under the terms of the CeCILL.
 // This source file is licensed as described in the file COPYING, which
@@ -23,7 +23,7 @@
 function [x,fval,exitflag,output] = fminsearch ( varargin )
   [lhs,rhs]=argn();
   if rhs<>2 & rhs<>3 then
-    errmsg = msprintf(gettext("%s: Unexpected number of input arguments : %d provided while 2 or 3 are expected."), "fminsearch", rhs);
+    errmsg = msprintf(gettext("%s: Wrong number of input arguments: %d or %d expected.\n"), "fminsearch", 2,3);
     error(errmsg)
   end
   fun = varargin(1);
index 7a797f5..fdd7bcc 100644 (file)
@@ -1,6 +1,6 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // <-- Short Description -->
 // The derivative function did not check for input argument #1, if it is a list.
 //
-function flag = MY_assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
 x=[1;2;3];
 instr="[J,H]=derivative(list(),x)";
-ierr=execstr(instr,"errcatch");
-laserr = lasterror();
-MY_assert_equal ( ierr , 10000 );
-MY_assert_equal ( laserr , "derivative: Wrong number of elements in input argument #1: At least 2 elements expected, but current number is 0." );
+assert_checkerror ( instr , "derivative: Wrong number of elements in input argument #1: At least 2 elements expected, but current number is 0.", 10000 );
 //
 x=[1;2;3];
 instr="[J,H]=derivative(list(""foo""),x)";
-err=execstr(instr,"errcatch");
-laserr = lasterror();
-MY_assert_equal ( ierr , 10000 );
-MY_assert_equal ( laserr , "derivative: Wrong number of elements in input argument #1: At least 2 elements expected, but current number is 1." );
+assert_checkerror ( instr , "derivative: Wrong number of elements in input argument #1: At least 2 elements expected, but current number is 1." , 10000 );
 //
 x=[1;2;3];
 instr="[J,H]=derivative(list(""foo"",""aa""),x)";
-err=execstr(instr,"errcatch");
-laserr = lasterror();
-MY_assert_equal ( ierr , 10000 );
-MY_assert_equal ( laserr , "derivative: Wrong type for element #1 in input argument #1: A function is expected, but current type is string." );
+assert_checkerror ( instr , "derivative: Wrong type for element #1 in input argument #1: A function is expected, but current type is string." , 10000 );
index d73bede..0db9bf7 100644 (file)
@@ -1,6 +1,6 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // The derivative function did not check for input argument #1, if it is a list.
 //
 
-function flag = MY_assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
 
 
 x=[1;2;3];
 instr="[J,H]=derivative(list(),x)";
-ierr=execstr(instr,"errcatch");
-laserr = lasterror();
-MY_assert_equal ( ierr , 10000 );
-MY_assert_equal ( laserr , "derivative: Wrong number of elements in input argument #1: At least 2 elements expected, but current number is 0." );
+assert_checkerror ( instr , "derivative: Wrong number of elements in input argument #1: At least 2 elements expected, but current number is 0.", 10000 );
 //
 x=[1;2;3];
 instr="[J,H]=derivative(list(""foo""),x)";
-err=execstr(instr,"errcatch");
-laserr = lasterror();
-MY_assert_equal ( ierr , 10000 );
-MY_assert_equal ( laserr , "derivative: Wrong number of elements in input argument #1: At least 2 elements expected, but current number is 1." );
+assert_checkerror ( instr , "derivative: Wrong number of elements in input argument #1: At least 2 elements expected, but current number is 1." , 10000 );
 //
 x=[1;2;3];
 instr="[J,H]=derivative(list(""foo"",""aa""),x)";
-err=execstr(instr,"errcatch");
-laserr = lasterror();
-MY_assert_equal ( ierr , 10000 );
-MY_assert_equal ( laserr , "derivative: Wrong type for element #1 in input argument #1: A function is expected, but current type is string." );
+assert_checkerror ( instr , "derivative: Wrong type for element #1 in input argument #1: A function is expected, but current type is string." , 10000 );
 
 
 
index ed80d6d..e03728d 100644 (file)
 // <-- Short Description -->
 // The karmarkar function prints unwanted messages.
 //
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
 c = [-20 -24 0 0]';
 a = [
 3 6 1 0
@@ -41,4 +28,4 @@ x0 = [
 0.0820513
 ];
 xopt=karmarkar(a,b,c,x0);
-assert_close ( xopt , expected , 1.e-3 );
+assert_checkalmostequal ( xopt , expected , 1.e-3 );
index 1cd14eb..b654596 100644 (file)
@@ -1,6 +1,6 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // The karmarkar function prints unwanted messages.
 //
 
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
 
 c = [-20 -24 0 0]';
 a = [
@@ -43,5 +30,5 @@ x0 = [
 0.0820513
 ];
 xopt=karmarkar(a,b,c,x0);
-assert_close ( xopt , expected , 1.e-3 );
+assert_checkalmostequal ( xopt , expected , 1.e-3 );
 
index 510d98e..03d1a56 100644 (file)
@@ -1,6 +1,6 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // <-- Short Description -->
 // The karmarkar function may stop too early in the iterations.
 //
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
 c = 1.e-20 * [-20 -24 0 0]';
 a = [
 3 6 1 0
@@ -36,4 +23,4 @@ b = [60 32]';
 x0 = [4.1128205  7.7333333  1.2615385  0.0820513]';
 expected = [4 8 0 0]';
 xopt = karmarkar(a,b,c,x0);
-assert_close ( xopt , expected , 1.e-4 );
+assert_checkalmostequal ( xopt , expected , 1.e-4 );
index 02276bf..b642bcd 100644 (file)
@@ -1,6 +1,6 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // The karmarkar function may stop too early in the iterations.
 //
 
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
 
 c = 1.e-20 * [-20 -24 0 0]';
 a = [
@@ -38,5 +25,5 @@ b = [60 32]';
 x0 = [4.1128205  7.7333333  1.2615385  0.0820513]';
 expected = [4 8 0 0]';
 xopt = karmarkar(a,b,c,x0);
-assert_close ( xopt , expected , 1.e-4 );
+assert_checkalmostequal ( xopt , expected , 1.e-4 );
 
index 2fc6bac..eb2a881 100644 (file)
@@ -1,6 +1,6 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // <-- Short Description -->
 // The karmarkar function may produce a division-by-zero error.
 //
-function flag = MY_assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
 Aeq = [
 1 -1 0
 1  1 1
@@ -31,4 +23,4 @@ c = [-1;-1;0];
 x0 = [1;1;0];
 xopt=karmarkar(Aeq,beq,c,x0);
 xexpected = [1;1;0];
-MY_assert_equal ( xopt , xexpected );
+assert_checkequal ( xopt , xexpected );
index e1e15ab..f6a1b11 100644 (file)
@@ -1,6 +1,6 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // The karmarkar function may produce a division-by-zero error.
 //
 
-function flag = MY_assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
 
 
 Aeq = [
@@ -34,6 +26,6 @@ c = [-1;-1;0];
 x0 = [1;1;0];
 xopt=karmarkar(Aeq,beq,c,x0);
 xexpected = [1;1;0];
-MY_assert_equal ( xopt , xexpected );
+assert_checkequal ( xopt , xexpected );
 
 
index a087b86..ef096a9 100644 (file)
@@ -1,6 +1,6 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // <-- Short Description -->
 // The karmarkar function requires the initial guess x0.
 //
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-    if ( expected == computed ) then
-      flag = 1
-      return
-    end
-    if ( expected==0.0 ) then
-        shift = norm(computed-expected);
-    else
-        shift = norm(computed-expected)/norm(expected);
-    end
-    if shift < epsilon then
-        flag = 1;
-    else
-        flag = 0;
-    end
-    if flag <> 1 then bugmes();quit;end
-endfunction
 n=11;
 Aeq = zeros(n,n+2);
 Aeq(:,1) = 2*linspace(0,1,n)';
@@ -62,4 +37,4 @@ xstar  = [
     0.1566571  
     0.2458183  
 ];
-assert_close ( xopt , xstar , 1.e-6 );
+assert_checkalmostequal ( xopt , xstar , 1.e-6 );
index cececd5..d7892b4 100644 (file)
@@ -1,6 +1,6 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // The karmarkar function requires the initial guess x0.
 //
 
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-    if ( expected == computed ) then
-      flag = 1
-      return
-    end
-    if ( expected==0.0 ) then
-        shift = norm(computed-expected);
-    else
-        shift = norm(computed-expected)/norm(expected);
-    end
-    if shift < epsilon then
-        flag = 1;
-    else
-        flag = 0;
-    end
-    if flag <> 1 then pause,end
-endfunction
+
 
 
 n=11;
@@ -66,5 +42,5 @@ xstar  = [
     0.1566571  
     0.2458183  
 ];
-assert_close ( xopt , xstar , 1.e-6 );
+assert_checkalmostequal ( xopt , xstar , 1.e-6 );
 
index 77299fb..b239ea1 100644 (file)
@@ -1,6 +1,6 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // <-- Short Description -->
 // The karmarkar function might diverge toward a non-optimal point.
 //
-function flag = MY_assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
 // An unbounded problem.
 Aeq = [
  2 -2 -1 1 0
@@ -31,4 +23,4 @@ beq = [-1;-1];
 c = [2;9;3;0;0];
 x0 = [0.2;0.7;1;1;1];
 [xopt,fopt,exitflag]=karmarkar(Aeq,beq,c,x0,0,0.999);
-MY_assert_equal ( exitflag , -2 );
+assert_checkequal ( exitflag , -2 );
index 81b86c8..9e3b780 100644 (file)
@@ -1,6 +1,6 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // The karmarkar function might diverge toward a non-optimal point.
 //
 
-function flag = MY_assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
+
 
 // An unbounded problem.
 Aeq = [
@@ -33,5 +26,5 @@ beq = [-1;-1];
 c = [2;9;3;0;0];
 x0 = [0.2;0.7;1;1;1];
 [xopt,fopt,exitflag]=karmarkar(Aeq,beq,c,x0,0,0.999);
-MY_assert_equal ( exitflag , -2 );
+assert_checkequal ( exitflag , -2 );
 
index 0e8c2ba..c1bc436 100644 (file)
@@ -1,46 +1,11 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008-2009 - INRIA - Michael Baudin
+// Copyright (C) 2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // <-- JVM NOT MANDATORY -->
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
 // 1. Test with a scalar function
 function y = myfunction (x)
   y = x*x;
@@ -49,34 +14,34 @@ x = 1.0;
 expected = 2.0;
 // 1.1 With default parameters
 computed = derivative(myfunction,x);
-assert_close ( computed , expected , 1.e-11 );
+assert_checkalmostequal ( computed , expected , 1.e-11 );
 // 1.2 Test order 1
 computed = derivative(myfunction,x,order=1);
-assert_close ( computed , expected , 1.e-8 );
+assert_checkalmostequal ( computed , expected , 1.e-8 );
 // 1.3 Test order 2
 computed = derivative(myfunction,x,order=2);
-assert_close ( computed , expected , 1.e-11 );
+assert_checkalmostequal ( computed , expected , 1.e-11 );
 // 1.4 Test order 4
 computed = derivative(myfunction,x,order=4);
-assert_close ( computed , expected , %eps );
+assert_checkalmostequal ( computed , expected , %eps );
 // 1.5 Compute second derivative at the same time
 Jexpected = 2.0;
 Hexpected = 2.0;
 [Jcomputed , Hcomputed] = derivative(myfunction,x);
-assert_close ( Jcomputed , Jexpected , 1.e-11 );
-assert_close ( Hcomputed , Hexpected , %eps );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-11 );
+assert_checkalmostequal ( Hcomputed , Hexpected , %eps );
 // 1.6 Test order 1
 [Jcomputed , Hcomputed] = derivative(myfunction,x,order=1);
-assert_close ( Jcomputed , Jexpected , 1.e-8 );
-assert_close ( Hcomputed , Hexpected , 1.e-6 );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-8 );
+assert_checkalmostequal ( Hcomputed , Hexpected , 1.e-6 );
 // 1.7 Test order 2
 [Jcomputed , Hcomputed] = derivative(myfunction,x,order=2);
-assert_close ( Jcomputed , Jexpected , 1.e-11 );
-assert_close ( Hcomputed , Hexpected , %eps );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-11 );
+assert_checkalmostequal ( Hcomputed , Hexpected , %eps );
 // 1.8 Test order 4
 [Jcomputed , Hcomputed] = derivative(myfunction,x,order=4);
-assert_close ( Jcomputed , Jexpected , %eps );
-assert_close ( Hcomputed , Hexpected , 1.e-11 );
+assert_checkalmostequal ( Jcomputed , Jexpected , %eps );
+assert_checkalmostequal ( Hcomputed , Hexpected , 1.e-11 );
 // 2. Test with a vector function
 function y = myfunction2 (x)
   y = x(1)*x(1) + x(2)+ x(1)*x(2);
@@ -86,65 +51,61 @@ x = [1.0
 expected = [4.0 2.0];
 // 2.1 With default parameters
 computed = derivative(myfunction2,x);
-assert_close ( computed , expected , 1.e-10 );
+assert_checkalmostequal ( computed , expected , 1.e-10 );
 // 2.2 Test order 1
 computed = derivative(myfunction2,x,order=1);
-assert_close ( computed , expected , 1.e-8 );
+assert_checkalmostequal ( computed , expected , 1.e-8 );
 // 2.3 Test order 2
 computed = derivative(myfunction2,x,order=2);
-assert_close ( computed , expected , 1.e-10 );
+assert_checkalmostequal ( computed , expected , 1.e-10 );
 // 2.4 Test order 4
 computed = derivative(myfunction2,x,order=4);
-assert_close ( computed , expected , %eps );
+assert_checkalmostequal ( computed , expected , %eps );
 // 2.5 Compute second derivative at the same time
 Jexpected = [4.0 2.0];
 Hexpected = [2.0 1.0 1.0 0];
 [Jcomputed , Hcomputed] = derivative(myfunction2,x);
-assert_close ( Jcomputed , Jexpected , 1.e-10 );
-assert_close ( Hcomputed , Hexpected , %eps );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-10 );
+assert_checkalmostequal ( Hcomputed , Hexpected , %eps );
 // 2.6 Test order 1
 [Jcomputed , Hcomputed] = derivative(myfunction2,x,order=1);
-assert_close ( Jcomputed , Jexpected , 1.e-8 );
-assert_close ( Hcomputed , Hexpected , 1.e-5 );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-8 );
+assert_checkalmostequal ( Hcomputed , Hexpected , 1.e-5 );
 // 2.7 Test order 2
 [Jcomputed , Hcomputed] = derivative(myfunction2,x,order=2);
-assert_close ( Jcomputed , Jexpected , 1.e-10 );
-assert_close ( Hcomputed , Hexpected , %eps );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-10 );
+assert_checkalmostequal ( Hcomputed , Hexpected , %eps );
 // 2.8 Test order 4
 [Jcomputed , Hcomputed] = derivative(myfunction2,x,order=4);
-assert_close ( Jcomputed , Jexpected , %eps );
-assert_close ( Hcomputed , Hexpected , 1.e-10 );
+assert_checkalmostequal ( Jcomputed , Jexpected , %eps );
+assert_checkalmostequal ( Hcomputed , Hexpected , 1.e-10 );
 // 3. Test H_form
 // 3.1 Test H_form="default"
 Jexpected = [4.0 2.0];
 Hexpected = [2.0 1.0 1.0 0.0];
 [Jcomputed , Hcomputed] = derivative(myfunction2 , x , H_form="default");
-assert_close ( Jcomputed , Jexpected , 1.e-10 );
-assert_close ( Hcomputed , Hexpected , %eps );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-10 );
+assert_checkalmostequal ( Hcomputed , Hexpected , %eps );
 // 3.2 Test H_form='hypermat'
 Jexpected = [4.0 2.0];
 Hexpected = [2.0 1.0
 1.0 0.0];
 [Jcomputed , Hcomputed] = derivative(myfunction2 , x , H_form='hypermat');
-assert_close ( Jcomputed , Jexpected , 1.e-10 );
-assert_close ( Hcomputed , Hexpected , %eps );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-10 );
+assert_checkalmostequal ( Hcomputed , Hexpected , %eps );
 // 3.3 Test H_form='hypermat'
 Jexpected = [4.0 2.0];
 Hexpected = [2.0 1.0 
 1.0 0.0];
 [Jcomputed , Hcomputed] = derivative(myfunction2 , x , H_form='hypermat');
-assert_close ( Jcomputed , Jexpected , 1.e-10 );
-assert_close ( Hcomputed , Hexpected , %eps );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-10 );
+assert_checkalmostequal ( Hcomputed , Hexpected , %eps );
 // 4. Test verbose
 [Jcomputed , Hcomputed] = derivative(myfunction2 , x , verbose = 1);
 h = 6.055454e-006
-
 order = 2
-
 H_form = default
-
 Q = 
-
  
     1.    0.  
     0.    1.  
@@ -166,7 +127,7 @@ h = 6.055454e-006
 Jexpected = (2/myn) * x^(2/myn-1);
 Hexpected = (2/myn) * (2/myn-1) * x^(2/myn-2);
 [Jcomputed , Hcomputed] = derivative(myfunction3 , x , h = 1.e-4 , order = 1 );
-assert_close ( Jcomputed , Jexpected , 1.e-4 );
-assert_close ( Hcomputed , Hexpected , 1.e-3 );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-4 );
+assert_checkalmostequal ( Hcomputed , Hexpected , 1.e-3 );
 // 6. Test Q parameter
 // TODO !
index 35703dc..48d968f 100644 (file)
@@ -1,46 +1,11 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008-2009 - INRIA - Michael Baudin
+// Copyright (C) 2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // <-- JVM NOT MANDATORY -->
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
 // 1. Test with a scalar function
 function y = myfunction (x)
   y = x*x;
@@ -49,34 +14,34 @@ x = 1.0;
 expected = 2.0;
 // 1.1 With default parameters
 computed = derivative(myfunction,x);
-assert_close ( computed , expected , 1.e-11 );
+assert_checkalmostequal ( computed , expected , 1.e-11 );
 // 1.2 Test order 1
 computed = derivative(myfunction,x,order=1);
-assert_close ( computed , expected , 1.e-8 );
+assert_checkalmostequal ( computed , expected , 1.e-8 );
 // 1.3 Test order 2
 computed = derivative(myfunction,x,order=2);
-assert_close ( computed , expected , 1.e-11 );
+assert_checkalmostequal ( computed , expected , 1.e-11 );
 // 1.4 Test order 4
 computed = derivative(myfunction,x,order=4);
-assert_close ( computed , expected , %eps );
+assert_checkalmostequal ( computed , expected , %eps );
 // 1.5 Compute second derivative at the same time
 Jexpected = 2.0;
 Hexpected = 2.0;
 [Jcomputed , Hcomputed] = derivative(myfunction,x);
-assert_close ( Jcomputed , Jexpected , 1.e-11 );
-assert_close ( Hcomputed , Hexpected , %eps );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-11 );
+assert_checkalmostequal ( Hcomputed , Hexpected , %eps );
 // 1.6 Test order 1
 [Jcomputed , Hcomputed] = derivative(myfunction,x,order=1);
-assert_close ( Jcomputed , Jexpected , 1.e-8 );
-assert_close ( Hcomputed , Hexpected , 1.e-6 );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-8 );
+assert_checkalmostequal ( Hcomputed , Hexpected , 1.e-6 );
 // 1.7 Test order 2
 [Jcomputed , Hcomputed] = derivative(myfunction,x,order=2);
-assert_close ( Jcomputed , Jexpected , 1.e-11 );
-assert_close ( Hcomputed , Hexpected , %eps );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-11 );
+assert_checkalmostequal ( Hcomputed , Hexpected , %eps );
 // 1.8 Test order 4
 [Jcomputed , Hcomputed] = derivative(myfunction,x,order=4);
-assert_close ( Jcomputed , Jexpected , %eps );
-assert_close ( Hcomputed , Hexpected , 1.e-11 );
+assert_checkalmostequal ( Jcomputed , Jexpected , %eps );
+assert_checkalmostequal ( Hcomputed , Hexpected , 1.e-11 );
 // 2. Test with a vector function
 function y = myfunction2 (x)
   y = x(1)*x(1) + x(2)+ x(1)*x(2);
@@ -86,55 +51,55 @@ x = [1.0
 expected = [4.0 2.0];
 // 2.1 With default parameters
 computed = derivative(myfunction2,x);
-assert_close ( computed , expected , 1.e-10 );
+assert_checkalmostequal ( computed , expected , 1.e-10 );
 // 2.2 Test order 1
 computed = derivative(myfunction2,x,order=1);
-assert_close ( computed , expected , 1.e-8 );
+assert_checkalmostequal ( computed , expected , 1.e-8 );
 // 2.3 Test order 2
 computed = derivative(myfunction2,x,order=2);
-assert_close ( computed , expected , 1.e-10 );
+assert_checkalmostequal ( computed , expected , 1.e-10 );
 // 2.4 Test order 4
 computed = derivative(myfunction2,x,order=4);
-assert_close ( computed , expected , %eps );
+assert_checkalmostequal ( computed , expected , %eps );
 // 2.5 Compute second derivative at the same time
 Jexpected = [4.0 2.0];
 Hexpected = [2.0 1.0 1.0 0];
 [Jcomputed , Hcomputed] = derivative(myfunction2,x);
-assert_close ( Jcomputed , Jexpected , 1.e-10 );
-assert_close ( Hcomputed , Hexpected , %eps );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-10 );
+assert_checkalmostequal ( Hcomputed , Hexpected , %eps );
 // 2.6 Test order 1
 [Jcomputed , Hcomputed] = derivative(myfunction2,x,order=1);
-assert_close ( Jcomputed , Jexpected , 1.e-8 );
-assert_close ( Hcomputed , Hexpected , 1.e-5 );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-8 );
+assert_checkalmostequal ( Hcomputed , Hexpected , 1.e-5 );
 // 2.7 Test order 2
 [Jcomputed , Hcomputed] = derivative(myfunction2,x,order=2);
-assert_close ( Jcomputed , Jexpected , 1.e-10 );
-assert_close ( Hcomputed , Hexpected , %eps );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-10 );
+assert_checkalmostequal ( Hcomputed , Hexpected , %eps );
 // 2.8 Test order 4
 [Jcomputed , Hcomputed] = derivative(myfunction2,x,order=4);
-assert_close ( Jcomputed , Jexpected , %eps );
-assert_close ( Hcomputed , Hexpected , 1.e-10 );
+assert_checkalmostequal ( Jcomputed , Jexpected , %eps );
+assert_checkalmostequal ( Hcomputed , Hexpected , 1.e-10 );
 // 3. Test H_form
 // 3.1 Test H_form="default"
 Jexpected = [4.0 2.0];
 Hexpected = [2.0 1.0 1.0 0.0];
 [Jcomputed , Hcomputed] = derivative(myfunction2 , x , H_form="default");
-assert_close ( Jcomputed , Jexpected , 1.e-10 );
-assert_close ( Hcomputed , Hexpected , %eps );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-10 );
+assert_checkalmostequal ( Hcomputed , Hexpected , %eps );
 // 3.2 Test H_form='hypermat'
 Jexpected = [4.0 2.0];
 Hexpected = [2.0 1.0
 1.0 0.0];
 [Jcomputed , Hcomputed] = derivative(myfunction2 , x , H_form='hypermat');
-assert_close ( Jcomputed , Jexpected , 1.e-10 );
-assert_close ( Hcomputed , Hexpected , %eps );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-10 );
+assert_checkalmostequal ( Hcomputed , Hexpected , %eps );
 // 3.3 Test H_form='hypermat'
 Jexpected = [4.0 2.0];
 Hexpected = [2.0 1.0 
 1.0 0.0];
 [Jcomputed , Hcomputed] = derivative(myfunction2 , x , H_form='hypermat');
-assert_close ( Jcomputed , Jexpected , 1.e-10 );
-assert_close ( Hcomputed , Hexpected , %eps );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-10 );
+assert_checkalmostequal ( Hcomputed , Hexpected , %eps );
 // 4. Test verbose
 [Jcomputed , Hcomputed] = derivative(myfunction2 , x , verbose = 1);
 h = 6.055454e-06
@@ -162,7 +127,7 @@ h = 6.055454e-006
 Jexpected = (2/myn) * x^(2/myn-1);
 Hexpected = (2/myn) * (2/myn-1) * x^(2/myn-2);
 [Jcomputed , Hcomputed] = derivative(myfunction3 , x , h = 1.e-4 , order = 1 );
-assert_close ( Jcomputed , Jexpected , 1.e-4 );
-assert_close ( Hcomputed , Hexpected , 1.e-3 );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-4 );
+assert_checkalmostequal ( Hcomputed , Hexpected , 1.e-3 );
 // 6. Test Q parameter
 // TODO !
index bde7627..0565955 100644 (file)
@@ -1,48 +1,13 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008-2009 - INRIA - Michael Baudin
+// Copyright (C) 2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 
 // <-- JVM NOT MANDATORY -->
 
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
 
 // 1. Test with a scalar function
 function y = myfunction (x)
@@ -53,35 +18,35 @@ x = 1.0;
 expected = 2.0;
 // 1.1 With default parameters
 computed = derivative(myfunction,x);
-assert_close ( computed , expected , 1.e-11 );
+assert_checkalmostequal ( computed , expected , 1.e-11 );
 // 1.2 Test order 1
 computed = derivative(myfunction,x,order=1);
-assert_close ( computed , expected , 1.e-8 );
+assert_checkalmostequal ( computed , expected , 1.e-8 );
 // 1.3 Test order 2
 computed = derivative(myfunction,x,order=2);
-assert_close ( computed , expected , 1.e-11 );
+assert_checkalmostequal ( computed , expected , 1.e-11 );
 // 1.4 Test order 4
 computed = derivative(myfunction,x,order=4);
-assert_close ( computed , expected , %eps );
+assert_checkalmostequal ( computed , expected , %eps );
 
 // 1.5 Compute second derivative at the same time
 Jexpected = 2.0;
 Hexpected = 2.0;
 [Jcomputed , Hcomputed] = derivative(myfunction,x);
-assert_close ( Jcomputed , Jexpected , 1.e-11 );
-assert_close ( Hcomputed , Hexpected , %eps );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-11 );
+assert_checkalmostequal ( Hcomputed , Hexpected , %eps );
 // 1.6 Test order 1
 [Jcomputed , Hcomputed] = derivative(myfunction,x,order=1);
-assert_close ( Jcomputed , Jexpected , 1.e-8 );
-assert_close ( Hcomputed , Hexpected , 1.e-6 );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-8 );
+assert_checkalmostequal ( Hcomputed , Hexpected , 1.e-6 );
 // 1.7 Test order 2
 [Jcomputed , Hcomputed] = derivative(myfunction,x,order=2);
-assert_close ( Jcomputed , Jexpected , 1.e-11 );
-assert_close ( Hcomputed , Hexpected , %eps );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-11 );
+assert_checkalmostequal ( Hcomputed , Hexpected , %eps );
 // 1.8 Test order 4
 [Jcomputed , Hcomputed] = derivative(myfunction,x,order=4);
-assert_close ( Jcomputed , Jexpected , %eps );
-assert_close ( Hcomputed , Hexpected , 1.e-11 );
+assert_checkalmostequal ( Jcomputed , Jexpected , %eps );
+assert_checkalmostequal ( Hcomputed , Hexpected , 1.e-11 );
 
 // 2. Test with a vector function
 function y = myfunction2 (x)
@@ -92,57 +57,57 @@ x = [1.0
 expected = [4.0 2.0];
 // 2.1 With default parameters
 computed = derivative(myfunction2,x);
-assert_close ( computed , expected , 1.e-10 );
+assert_checkalmostequal ( computed , expected , 1.e-10 );
 // 2.2 Test order 1
 computed = derivative(myfunction2,x,order=1);
-assert_close ( computed , expected , 1.e-8 );
+assert_checkalmostequal ( computed , expected , 1.e-8 );
 // 2.3 Test order 2
 computed = derivative(myfunction2,x,order=2);
-assert_close ( computed , expected , 1.e-10 );
+assert_checkalmostequal ( computed , expected , 1.e-10 );
 // 2.4 Test order 4
 computed = derivative(myfunction2,x,order=4);
-assert_close ( computed , expected , %eps );
+assert_checkalmostequal ( computed , expected , %eps );
 
 // 2.5 Compute second derivative at the same time
 Jexpected = [4.0 2.0];
 Hexpected = [2.0 1.0 1.0 0];
 [Jcomputed , Hcomputed] = derivative(myfunction2,x);
-assert_close ( Jcomputed , Jexpected , 1.e-10 );
-assert_close ( Hcomputed , Hexpected , %eps );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-10 );
+assert_checkalmostequal ( Hcomputed , Hexpected , %eps );
 // 2.6 Test order 1
 [Jcomputed , Hcomputed] = derivative(myfunction2,x,order=1);
-assert_close ( Jcomputed , Jexpected , 1.e-8 );
-assert_close ( Hcomputed , Hexpected , 1.e-5 );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-8 );
+assert_checkalmostequal ( Hcomputed , Hexpected , 1.e-5 );
 // 2.7 Test order 2
 [Jcomputed , Hcomputed] = derivative(myfunction2,x,order=2);
-assert_close ( Jcomputed , Jexpected , 1.e-10 );
-assert_close ( Hcomputed , Hexpected , %eps );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-10 );
+assert_checkalmostequal ( Hcomputed , Hexpected , %eps );
 // 2.8 Test order 4
 [Jcomputed , Hcomputed] = derivative(myfunction2,x,order=4);
-assert_close ( Jcomputed , Jexpected , %eps );
-assert_close ( Hcomputed , Hexpected , 1.e-10 );
+assert_checkalmostequal ( Jcomputed , Jexpected , %eps );
+assert_checkalmostequal ( Hcomputed , Hexpected , 1.e-10 );
 
 // 3. Test H_form
 // 3.1 Test H_form="default"
 Jexpected = [4.0 2.0];
 Hexpected = [2.0 1.0 1.0 0.0];
 [Jcomputed , Hcomputed] = derivative(myfunction2 , x , H_form="default");
-assert_close ( Jcomputed , Jexpected , 1.e-10 );
-assert_close ( Hcomputed , Hexpected , %eps );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-10 );
+assert_checkalmostequal ( Hcomputed , Hexpected , %eps );
 // 3.2 Test H_form='hypermat'
 Jexpected = [4.0 2.0];
 Hexpected = [2.0 1.0
 1.0 0.0];
 [Jcomputed , Hcomputed] = derivative(myfunction2 , x , H_form='hypermat');
-assert_close ( Jcomputed , Jexpected , 1.e-10 );
-assert_close ( Hcomputed , Hexpected , %eps );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-10 );
+assert_checkalmostequal ( Hcomputed , Hexpected , %eps );
 // 3.3 Test H_form='hypermat'
 Jexpected = [4.0 2.0];
 Hexpected = [2.0 1.0 
 1.0 0.0];
 [Jcomputed , Hcomputed] = derivative(myfunction2 , x , H_form='hypermat');
-assert_close ( Jcomputed , Jexpected , 1.e-10 );
-assert_close ( Hcomputed , Hexpected , %eps );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-10 );
+assert_checkalmostequal ( Hcomputed , Hexpected , %eps );
 
 // 4. Test verbose
 [Jcomputed , Hcomputed] = derivative(myfunction2 , x , verbose = 1);
@@ -162,8 +127,8 @@ h = 6.055454e-006
 Jexpected = (2/myn) * x^(2/myn-1);
 Hexpected = (2/myn) * (2/myn-1) * x^(2/myn-2);
 [Jcomputed , Hcomputed] = derivative(myfunction3 , x , h = 1.e-4 , order = 1 );
-assert_close ( Jcomputed , Jexpected , 1.e-4 );
-assert_close ( Hcomputed , Hexpected , 1.e-3 );
+assert_checkalmostequal ( Jcomputed , Jexpected , 1.e-4 );
+assert_checkalmostequal ( Hcomputed , Hexpected , 1.e-3 );
 
 // 6. Test Q parameter
 // TODO !
index f5f42dd..78365bb 100644 (file)
@@ -1,50 +1,10 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // <-- JVM NOT MANDATORY -->
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-    if ( expected == computed ) then
-      flag = 1
-      return
-    end
-    if ( expected==0.0 ) then
-        shift = norm(computed-expected);
-    else
-        shift = norm(computed-expected)/norm(expected);
-    end
-    if shift < epsilon then
-        flag = 1;
-    else
-        flag = 0;
-    end
-    if flag <> 1 then bugmes();quit;end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-    if computed==expected then
-        flag = 1;
-    else
-        flag = 0;
-    end
-    if flag <> 1 then bugmes();quit;end
-endfunction
 // With slack variables:
 //
 // Minimize -20.x1 - 24.x2 such as:
@@ -66,36 +26,36 @@ x0 = [
 0.0820513
 ];
 [xopt,fopt]=karmarkar(Aeq,beq,c,x0);
-assert_close ( xopt , xexpected , 1.e-3 );
-assert_close ( fopt , fexpected , 1.e-4 );
+assert_checkalmostequal ( xopt , xexpected , 1.e-3 );
+assert_checkalmostequal ( fopt , fexpected , 1.e-4 );
 //
 // Configure the relative tolerance
 rtolf=1.e-6;
 [xopt,fopt]=karmarkar(Aeq,beq,c,x0,rtolf);
-assert_close ( xopt , xexpected , 1.e-4 );
-assert_close ( fopt , fexpected , 1.e-5 );
+assert_checkalmostequal ( xopt , xexpected , 1.e-4 );
+assert_checkalmostequal ( fopt , fexpected , 1.e-5 );
 //
 // Configure the gamma
 gam = 0.1;
 [xopt,fopt]=karmarkar(Aeq,beq,c,x0,[],gam);
-assert_close ( xopt , xexpected , 1.e-3 );
-assert_close ( fopt , fexpected , 1.e-4 );
+assert_checkalmostequal ( xopt , xexpected , 1.e-3 );
+assert_checkalmostequal ( fopt , fexpected , 1.e-4 );
 ////////////////////////////////////////////////////////////
 //
 // Check new API (from Scilab v5.3.x).
 //
 // Check exit flag
 [xopt,fopt,exitflag]=karmarkar(Aeq,beq,c,x0);
-assert_close ( xopt , xexpected , 1.e-3 );
-assert_close ( fopt , fexpected , 1.e-4 );
-assert_equal ( exitflag , 1 );
+assert_checkalmostequal ( xopt , xexpected , 1.e-3 );
+assert_checkalmostequal ( fopt , fexpected , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
 //
 // Check number of iterations
 [xopt,fopt,exitflag,iter]=karmarkar(Aeq,beq,c,x0);
-assert_close ( xopt , xexpected , 1.e-3 );
-assert_close ( fopt , fexpected , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter>10 , %t );
+assert_checkalmostequal ( xopt , xexpected , 1.e-3 );
+assert_checkalmostequal ( fopt , fexpected , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter>10 , %t );
 //
 // Check dual solution
 [xopt,fopt,exitflag,iter,yopt]=karmarkar(Aeq,beq,c,x0);
@@ -103,19 +63,19 @@ lambda.ineqlin = [];
 lambda.eqlin = [28/9;8/3];
 lambda.upper = [0;0;0;0];
 lambda.lower = [0;0;28/9;8/3];
-assert_close ( xopt , xexpected , 1.e-3 );
-assert_close ( fopt , fexpected , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter>10 , %t );
-assert_equal ( yopt.ineqlin , lambda.ineqlin );
-assert_close ( yopt.eqlin , lambda.eqlin , 1.e-8 );
-assert_close ( yopt.lower , lambda.lower , 1.e-8 );
-assert_equal ( yopt.upper , lambda.upper );
+assert_checkalmostequal ( xopt , xexpected , 1.e-3 );
+assert_checkalmostequal ( fopt , fexpected , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter>10 , %t );
+assert_checkequal ( yopt.ineqlin , lambda.ineqlin );
+assert_checkalmostequal ( yopt.eqlin , lambda.eqlin , 1.e-8 );
+assert_checkalmostequal ( yopt.lower , lambda.lower , 1.e-8 );
+assert_checkequal ( yopt.upper , lambda.upper );
 //
 // Check number of iterations, with default options
 [xopt,fopt,exitflag,iter]=karmarkar(Aeq,beq,c,x0,[],[],10);
-assert_equal ( exitflag , 0 );
-assert_equal ( iter , 10 );
+assert_checkequal ( exitflag , 0 );
+assert_checkequal ( iter , 10 );
 //
 // Check output function
 function stop = myoutputfunction ( xopt , optimValues , state )
@@ -125,21 +85,21 @@ function stop = myoutputfunction ( xopt , optimValues , state )
     stop = %f
 endfunction
 xopt=karmarkar(Aeq,beq,c,x0,[],[],[],myoutputfunction);
-assert_close ( xopt , xexpected , 1.e-3 );
+assert_checkalmostequal ( xopt , xexpected , 1.e-3 );
 //
 // Check output function, without initial guess
 xopt=karmarkar(Aeq,beq,c,[],[],[],[],myoutputfunction);
-assert_close ( xopt , xexpected , 1.e-3 );
+assert_checkalmostequal ( xopt , xexpected , 1.e-3 );
 //
 // Check that the output function can stop the algorithm
 function stop = myoutputfunctionStop ( xopt , optimValues , state )
     stop = (iter >= 7)
 endfunction
 [xopt,fopt,exitflag,iter]=karmarkar(Aeq,beq,c,x0,[],[],[],myoutputfunctionStop);
-assert_close ( xopt , xexpected , 1.e-2 );
-assert_close ( fopt , fexpected , 1.e-3 );
-assert_equal ( exitflag , -4 );
-assert_equal ( iter , 7 );
+assert_checkalmostequal ( xopt , xexpected , 1.e-2 );
+assert_checkalmostequal ( fopt , fexpected , 1.e-3 );
+assert_checkequal ( exitflag , -4 );
+assert_checkequal ( iter , 7 );
 //
 // Check output function with additionnal arguments
 function stop = myoutputfunction2 ( xopt , optimValues , state , myAeq , mybeq , myc )
@@ -148,7 +108,7 @@ function stop = myoutputfunction2 ( xopt , optimValues , state , myAeq , mybeq ,
     stop = %f
 endfunction
 xopt=karmarkar(Aeq,beq,c,x0,[],[],[],list(myoutputfunction2,Aeq,beq,c));
-assert_close ( xopt , xexpected , 1.e-3 );
+assert_checkalmostequal ( xopt , xexpected , 1.e-3 );
 //
 // References
 // "Practical Optimization", Antoniou, Lu, 2007
@@ -177,14 +137,14 @@ lambda.ineqlin = [];
 lambda.eqlin = [-3.5;-0.5];
 lambda.upper = [0;0;0;0;0];
 lambda.lower = [8.5;0;0;3.5;0.5];
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter , 4 );
-assert_equal ( yopt.ineqlin , lambda.ineqlin );
-assert_close ( yopt.eqlin , lambda.eqlin , 1.e-6 );
-assert_close ( yopt.lower , lambda.lower , 1.e-6 );
-assert_equal ( yopt.upper , lambda.upper );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter , 4 );
+assert_checkequal ( yopt.ineqlin , lambda.ineqlin );
+assert_checkalmostequal ( yopt.eqlin , lambda.eqlin , 1.e-6 );
+assert_checkalmostequal ( yopt.lower , lambda.lower , 1.e-6 );
+assert_checkequal ( yopt.upper , lambda.upper );
 //
 // Minimize -x1 -x2
 // x1 - x2      = 0
@@ -205,14 +165,14 @@ lambda.ineqlin = [];
 lambda.eqlin = [0;1];
 lambda.upper = [0;0;0];
 lambda.lower = [0;0;1];
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter > 0 , %t );
-assert_equal ( yopt.ineqlin , lambda.ineqlin );
-assert_close ( yopt.eqlin , lambda.eqlin , 1.e-6 );
-assert_close ( yopt.lower , lambda.lower , 1.e-6 );
-assert_equal ( yopt.upper , lambda.upper );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter > 0 , %t );
+assert_checkequal ( yopt.ineqlin , lambda.ineqlin );
+assert_checkalmostequal ( yopt.eqlin , lambda.eqlin , 1.e-6 );
+assert_checkalmostequal ( yopt.lower , lambda.lower , 1.e-6 );
+assert_checkequal ( yopt.upper , lambda.upper );
 //
 // Give a linear inequality A*x <= b.
 //
@@ -236,14 +196,14 @@ lambda.ineqlin = 1;
 lambda.eqlin = 0;
 lambda.upper = [0;0];
 lambda.lower = [0;0];
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter > 0 , %t );
-assert_close ( yopt.ineqlin , lambda.ineqlin , 1.e-6 );
-assert_close ( yopt.eqlin , lambda.eqlin , 1.e-6 );
-assert_equal ( yopt.lower , lambda.lower );
-assert_equal ( yopt.upper , lambda.upper );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter > 0 , %t );
+assert_checkalmostequal ( yopt.ineqlin , lambda.ineqlin , 1.e-6 );
+assert_checkalmostequal ( yopt.eqlin , lambda.eqlin , [] , 1.e-6 );
+assert_checkequal ( yopt.lower , lambda.lower );
+assert_checkequal ( yopt.upper , lambda.upper );
 //
 // Give a linear inequality A*x <= b
 //
@@ -259,29 +219,27 @@ beq = 0;
 c = [-1;-1];
 A = [1 1];
 b = 2;
-function stop = myoutputfunction2 ( xopt , optimValues , state )
-    assert_equal ( size(xopt) , [2 1] );
-    assert_equal ( or(state==["init","iter","done"]) , %t );
-    assert_equal ( or(optimValues.procedure==["x0","x*"]) , %t );
+function stop = myoutputfunction3 ( xopt , optimValues , state )
+    assert_checkequal ( size(xopt) , [2 1] );
+    assert_checkequal ( or(state==["init","iter","done"]) , %t );
+    assert_checkequal ( or(optimValues.procedure==["x0","x*"]) , %t );
     stop = %f
 endfunction
-Attention: redéfinition de la fonction: myoutputfunction2       . Utilisez funcprot(0) pour éviter ce message
-
-[xopt,fopt,exitflag,iter,yopt]=karmarkar(Aeq,beq,c,[],[],[],[],myoutputfunction2,A,b);
+[xopt,fopt,exitflag,iter,yopt]=karmarkar(Aeq,beq,c,[],[],[],[],myoutputfunction3,A,b);
 xstar=[1 1]';
 fstar = c'*xstar;
 lambda.ineqlin = 1;
 lambda.eqlin = 0;
 lambda.upper = [0;0];
 lambda.lower = [0;0];
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter > 0 , %t );
-assert_close ( yopt.ineqlin , lambda.ineqlin , 1.e-6 );
-assert_close ( yopt.eqlin , lambda.eqlin , 1.e-6 );
-assert_equal ( yopt.lower , lambda.lower );
-assert_equal ( yopt.upper , lambda.upper );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter > 0 , %t );
+assert_checkalmostequal ( yopt.ineqlin , lambda.ineqlin , 1.e-6 );
+assert_checkalmostequal ( yopt.eqlin , lambda.eqlin , [] , 1.e-6 );
+assert_checkequal ( yopt.lower , lambda.lower );
+assert_checkequal ( yopt.upper , lambda.upper );
 //
 // Minimize -20.x1 - 24.x2 such as:
 // 3.x1 + 6.x2 >= 60
@@ -301,14 +259,14 @@ lambda.ineqlin = [28/9;8/3];
 lambda.eqlin = [];
 lambda.upper = [0;0];
 lambda.lower = [0;0];
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter > 0 , %t );
-assert_close ( yopt.ineqlin , lambda.ineqlin , 1.e-6 );
-assert_close ( yopt.eqlin , lambda.eqlin , 1.e-6 );
-assert_equal ( yopt.lower , lambda.lower );
-assert_equal ( yopt.upper , lambda.upper );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter > 0 , %t );
+assert_checkalmostequal ( yopt.ineqlin , lambda.ineqlin , 1.e-6 );
+assert_checkequal ( yopt.eqlin , lambda.eqlin );
+assert_checkequal ( yopt.lower , lambda.lower );
+assert_checkequal ( yopt.upper , lambda.upper );
 //
 // References
 // "Practical Optimization", Antoniou, Lu, 2007
@@ -338,19 +296,19 @@ x0 = [0.2;0.7;1];
 [xopt,fopt,exitflag,iter]=karmarkar(Aeq,beq,c,x0,[],[],[],[],A,b);
 xstar = [0 1/3 1/3]';
 fstar = c'*xstar;
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter > 0 , %t );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter > 0 , %t );
 //
 // Let x0 be found by the algorithm.
 [xopt,fopt,exitflag,iter]=karmarkar(Aeq,beq,c,[],[],[],[],[],A,b);
 xstar = [0 1/3 1/3]';
 fstar = c'*xstar;
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter > 0 , %t );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter > 0 , %t );
 /////////////////////////////////////////////////////
 // References
 // "Lipsol toolbox", Yin Zhang, Scilab port by Rubio Scola, example0.sce.
@@ -391,14 +349,14 @@ lambda.eqlin = [];
 lambda.upper = [0;0;0];
 lambda.lower = [0;0;0];
 [xopt,fopt,exitflag,iter,yopt]=karmarkar(Aeq,beq,c,[],[],[],[],[],A,b);
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter > 0 , %t );
-assert_close ( yopt.ineqlin , lambda.ineqlin , 1.e-9 );
-assert_equal ( yopt.eqlin , lambda.eqlin );
-assert_equal ( yopt.lower , lambda.lower );
-assert_equal ( yopt.upper , lambda.upper );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter > 0 , %t );
+assert_checkalmostequal ( yopt.ineqlin , lambda.ineqlin , 1.e-9 );
+assert_checkequal ( yopt.eqlin , lambda.eqlin );
+assert_checkequal ( yopt.lower , lambda.lower );
+assert_checkequal ( yopt.upper , lambda.upper );
 //
 // Minimize 2.x1 + 9.x2 + 3.x3
 //  2 x1 - 2 x2 - x3 <= -1
@@ -425,14 +383,14 @@ lambda.ineqlin = [3.5;0.5;8.5;0;0];
 lambda.eqlin = [];
 lambda.upper = [0;0;0];
 lambda.lower = [0;0;0];
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter > 0 , %t );
-assert_close ( yopt.ineqlin , lambda.ineqlin , 1.e-9 );
-assert_equal ( yopt.eqlin , lambda.eqlin );
-assert_equal ( yopt.lower , lambda.lower );
-assert_equal ( yopt.upper , lambda.upper );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter > 0 , %t );
+assert_checkalmostequal ( yopt.ineqlin , lambda.ineqlin , 1.e-9 );
+assert_checkequal ( yopt.eqlin , lambda.eqlin );
+assert_checkequal ( yopt.lower , lambda.lower );
+assert_checkequal ( yopt.upper , lambda.upper );
 //////////////////////////////////////////////////////////////////////////
 //
 // Set lower bound and do not give x0.
@@ -452,14 +410,14 @@ lambda.ineqlin = [3.5;0.5];
 lambda.eqlin = [];
 lambda.upper = [0;0;0];
 lambda.lower = [8.5;0;0];
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter > 0 , %t );
-assert_close ( yopt.ineqlin , lambda.ineqlin , 1.e-9 );
-assert_equal ( yopt.eqlin , lambda.eqlin );
-assert_close ( yopt.lower , lambda.lower , 1.e-9 );
-assert_equal ( yopt.upper , lambda.upper );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter > 0 , %t );
+assert_checkalmostequal ( yopt.ineqlin , lambda.ineqlin , 1.e-9 );
+assert_checkequal ( yopt.eqlin , lambda.eqlin );
+assert_checkalmostequal ( yopt.lower , lambda.lower , 1.e-9 );
+assert_checkequal ( yopt.upper , lambda.upper );
 //
 // Set lower bound and give x0.
 Aeq=[];
@@ -479,14 +437,14 @@ lambda.ineqlin = [3.5;0.5];
 lambda.eqlin = [];
 lambda.upper = [0;0;0];
 lambda.lower = [8.5;0;0];
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter > 0 , %t );
-assert_close ( yopt.ineqlin , lambda.ineqlin , 1.e-9 );
-assert_close ( yopt.eqlin , lambda.eqlin , %eps );
-assert_close ( yopt.lower , lambda.lower , 1.e-9 );
-assert_close ( yopt.upper , lambda.upper , 1.e-9 );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter > 0 , %t );
+assert_checkalmostequal ( yopt.ineqlin , lambda.ineqlin , 1.e-9 );
+assert_checkalmostequal ( yopt.eqlin , lambda.eqlin , %eps );
+assert_checkalmostequal ( yopt.lower , lambda.lower , 1.e-9 );
+assert_checkalmostequal ( yopt.upper , lambda.upper , 1.e-9 );
 // References
 // LIPSOL is a set of Linear-programming Interior-Point SOLvers written 
 // by Yin Zhang. 
@@ -523,14 +481,14 @@ lambda.ineqlin = [0;0];
 lambda.eqlin = [];
 lambda.upper = [0;0;2.5];
 lambda.lower = [2;5;0];
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter > 0 , %t );
-assert_close ( yopt.ineqlin , lambda.ineqlin , 1.e-9 );
-assert_close ( yopt.eqlin , lambda.eqlin , %eps );
-assert_close ( yopt.lower , lambda.lower , 1.e-9 );
-assert_close ( yopt.upper , lambda.upper , 1.e-9 );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter > 0 , %t );
+assert_checkalmostequal ( yopt.ineqlin , lambda.ineqlin , [] , 1.e-9 );
+assert_checkequal ( yopt.eqlin , lambda.eqlin );
+assert_checkalmostequal ( yopt.lower , lambda.lower , 1.e-9 );
+assert_checkalmostequal ( yopt.upper , lambda.upper , 1.e-9 );
 //
 // An unbounded problem.
 c = [-20 -24]';
@@ -540,7 +498,7 @@ A = [
 ];
 b = [-60 -32]';
 [xopt,fopt,exitflag,iter,yopt]=karmarkar([],[],c,[],[],[],[],[],A,b);
-assert_equal ( exitflag , -2 );
+assert_checkequal ( exitflag , -2 );
 //
 // "Linear Programming in Matlab"
 // Ferris, Mangasarian, Wright
@@ -562,14 +520,14 @@ b=[-2;10];
 b=-b;
 lb=[0;0];
 [xopt,fopt,exitflag,iter,yopt]=karmarkar([],[],c,[],[],[],[],[],A,b,lb);
-assert_equal ( xopt , [] );
-assert_equal ( fopt , [] );
-assert_equal ( exitflag , -1 );
-assert_equal ( iter > 0 , %t );
-assert_equal ( yopt.ineqlin , [] );
-assert_equal ( yopt.eqlin , [] );
-assert_equal ( yopt.lower , [] );
-assert_equal ( yopt.upper , [] );
+assert_checkequal ( xopt , [] );
+assert_checkequal ( fopt , [] );
+assert_checkequal ( exitflag , -1 );
+assert_checkequal ( iter > 0 , %t );
+assert_checkequal ( yopt.ineqlin , [] );
+assert_checkequal ( yopt.eqlin , [] );
+assert_checkequal ( yopt.lower , [] );
+assert_checkequal ( yopt.upper , [] );
 //
 // "Linear Programming in Matlab"
 // Ferris, Mangasarian, Wright
@@ -591,7 +549,7 @@ b=[1;2];
 b=-b;
 lb=[0;0];
 [xopt,fopt,exitflag,iter,yopt]=karmarkar([],[],c,[],[],[],[],[],A,b,lb);
-assert_equal ( exitflag , -2 );
+assert_checkequal ( exitflag , -2 );
 //
 // "Linear and Nonlinear Optimization"
 // Griva, Nash, Sofer
@@ -611,7 +569,7 @@ A=[
 b=[2;1];
 lb=[0;0];
 [xopt,fopt,exitflag,iter,yopt]=karmarkar([],[],c,[],[],[],[],[],A,b,lb);
-assert_equal ( exitflag , -2 );
+assert_checkequal ( exitflag , -2 );
 //
 // "Linear and Nonlinear Optimization"
 // Griva, Nash, Sofer
@@ -631,18 +589,18 @@ A=[
 b=[-6;4];
 lb=[0;0];
 [xopt,fopt,exitflag,iter,yopt]=karmarkar([],[],c,[],[],[],[],[],A,b,lb);
-assert_equal ( exitflag , -1 );
+assert_checkequal ( exitflag , -1 );
 //
 // Example from the help page
 // Check that the output points remain feasible
-function stop = myoutputfunction3 ( xopt , optimValues , state , A , b )
-    assert_equal ( and(A*xopt<=b) , %t );
+function stop = myoutputfunction4 ( xopt , optimValues , state , A , b )
+    assert_checkequal ( and(A*xopt<=b) , %t );
     stop = %f
 endfunction
 n=11;
 A = [2*linspace(0,1,n)',ones(n,1)];
 b = 1 + linspace(0,1,n)'.^2;
 c=[-1;-1];
-xopt=karmarkar([],[],c,[],[],[],[],list(myoutputfunction3,A,b),A,b);
+xopt=karmarkar([],[],c,[],[],[],[],list(myoutputfunction4,A,b),A,b);
 xstar = [0.5005127;0.7494803];
-assert_close ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
index 327caa5..aee86c3 100644 (file)
@@ -1,52 +1,13 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2010 - DIGITEO - Michael Baudin
+// Copyright (C) 2010-2011 - DIGITEO - Michael Baudin
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 
 // <-- JVM NOT MANDATORY -->
 
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-    if ( expected == computed ) then
-      flag = 1
-      return
-    end
-    if ( expected==0.0 ) then
-        shift = norm(computed-expected);
-    else
-        shift = norm(computed-expected)/norm(expected);
-    end
-    if shift < epsilon then
-        flag = 1;
-    else
-        flag = 0;
-    end
-    if flag <> 1 then pause,end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-    if computed==expected then
-        flag = 1;
-    else
-        flag = 0;
-    end
-    if flag <> 1 then pause,end
-endfunction
+
 
 
 // With slack variables:
@@ -70,36 +31,36 @@ x0 = [
 0.0820513
 ];
 [xopt,fopt]=karmarkar(Aeq,beq,c,x0);
-assert_close ( xopt , xexpected , 1.e-3 );
-assert_close ( fopt , fexpected , 1.e-4 );
+assert_checkalmostequal ( xopt , xexpected , 1.e-3 );
+assert_checkalmostequal ( fopt , fexpected , 1.e-4 );
 //
 // Configure the relative tolerance
 rtolf=1.e-6;
 [xopt,fopt]=karmarkar(Aeq,beq,c,x0,rtolf);
-assert_close ( xopt , xexpected , 1.e-4 );
-assert_close ( fopt , fexpected , 1.e-5 );
+assert_checkalmostequal ( xopt , xexpected , 1.e-4 );
+assert_checkalmostequal ( fopt , fexpected , 1.e-5 );
 //
 // Configure the gamma
 gam = 0.1;
 [xopt,fopt]=karmarkar(Aeq,beq,c,x0,[],gam);
-assert_close ( xopt , xexpected , 1.e-3 );
-assert_close ( fopt , fexpected , 1.e-4 );
+assert_checkalmostequal ( xopt , xexpected , 1.e-3 );
+assert_checkalmostequal ( fopt , fexpected , 1.e-4 );
 ////////////////////////////////////////////////////////////
 //
 // Check new API (from Scilab v5.3.x).
 //
 // Check exit flag
 [xopt,fopt,exitflag]=karmarkar(Aeq,beq,c,x0);
-assert_close ( xopt , xexpected , 1.e-3 );
-assert_close ( fopt , fexpected , 1.e-4 );
-assert_equal ( exitflag , 1 );
+assert_checkalmostequal ( xopt , xexpected , 1.e-3 );
+assert_checkalmostequal ( fopt , fexpected , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
 //
 // Check number of iterations
 [xopt,fopt,exitflag,iter]=karmarkar(Aeq,beq,c,x0);
-assert_close ( xopt , xexpected , 1.e-3 );
-assert_close ( fopt , fexpected , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter>10 , %t );
+assert_checkalmostequal ( xopt , xexpected , 1.e-3 );
+assert_checkalmostequal ( fopt , fexpected , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter>10 , %t );
 //
 // Check dual solution
 [xopt,fopt,exitflag,iter,yopt]=karmarkar(Aeq,beq,c,x0);
@@ -107,19 +68,19 @@ lambda.ineqlin = [];
 lambda.eqlin = [28/9;8/3];
 lambda.upper = [0;0;0;0];
 lambda.lower = [0;0;28/9;8/3];
-assert_close ( xopt , xexpected , 1.e-3 );
-assert_close ( fopt , fexpected , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter>10 , %t );
-assert_equal ( yopt.ineqlin , lambda.ineqlin );
-assert_close ( yopt.eqlin , lambda.eqlin , 1.e-8 );
-assert_close ( yopt.lower , lambda.lower , 1.e-8 );
-assert_equal ( yopt.upper , lambda.upper );
+assert_checkalmostequal ( xopt , xexpected , 1.e-3 );
+assert_checkalmostequal ( fopt , fexpected , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter>10 , %t );
+assert_checkequal ( yopt.ineqlin , lambda.ineqlin );
+assert_checkalmostequal ( yopt.eqlin , lambda.eqlin , 1.e-8 );
+assert_checkalmostequal ( yopt.lower , lambda.lower , 1.e-8 );
+assert_checkequal ( yopt.upper , lambda.upper );
 //
 // Check number of iterations, with default options
 [xopt,fopt,exitflag,iter]=karmarkar(Aeq,beq,c,x0,[],[],10);
-assert_equal ( exitflag , 0 );
-assert_equal ( iter , 10 );
+assert_checkequal ( exitflag , 0 );
+assert_checkequal ( iter , 10 );
 //
 // Check output function
 function stop = myoutputfunction ( xopt , optimValues , state )
@@ -129,21 +90,21 @@ function stop = myoutputfunction ( xopt , optimValues , state )
     stop = %f
 endfunction
 xopt=karmarkar(Aeq,beq,c,x0,[],[],[],myoutputfunction);
-assert_close ( xopt , xexpected , 1.e-3 );
+assert_checkalmostequal ( xopt , xexpected , 1.e-3 );
 //
 // Check output function, without initial guess
 xopt=karmarkar(Aeq,beq,c,[],[],[],[],myoutputfunction);
-assert_close ( xopt , xexpected , 1.e-3 );
+assert_checkalmostequal ( xopt , xexpected , 1.e-3 );
 //
 // Check that the output function can stop the algorithm
 function stop = myoutputfunctionStop ( xopt , optimValues , state )
     stop = (iter >= 7)
 endfunction
 [xopt,fopt,exitflag,iter]=karmarkar(Aeq,beq,c,x0,[],[],[],myoutputfunctionStop);
-assert_close ( xopt , xexpected , 1.e-2 );
-assert_close ( fopt , fexpected , 1.e-3 );
-assert_equal ( exitflag , -4 );
-assert_equal ( iter , 7 );
+assert_checkalmostequal ( xopt , xexpected , 1.e-2 );
+assert_checkalmostequal ( fopt , fexpected , 1.e-3 );
+assert_checkequal ( exitflag , -4 );
+assert_checkequal ( iter , 7 );
 //
 // Check output function with additionnal arguments
 function stop = myoutputfunction2 ( xopt , optimValues , state , myAeq , mybeq , myc )
@@ -152,7 +113,7 @@ function stop = myoutputfunction2 ( xopt , optimValues , state , myAeq , mybeq ,
     stop = %f
 endfunction
 xopt=karmarkar(Aeq,beq,c,x0,[],[],[],list(myoutputfunction2,Aeq,beq,c));
-assert_close ( xopt , xexpected , 1.e-3 );
+assert_checkalmostequal ( xopt , xexpected , 1.e-3 );
 //
 // References
 // "Practical Optimization", Antoniou, Lu, 2007
@@ -181,14 +142,14 @@ lambda.ineqlin = [];
 lambda.eqlin = [-3.5;-0.5];
 lambda.upper = [0;0;0;0;0];
 lambda.lower = [8.5;0;0;3.5;0.5];
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter , 4 );
-assert_equal ( yopt.ineqlin , lambda.ineqlin );
-assert_close ( yopt.eqlin , lambda.eqlin , 1.e-6 );
-assert_close ( yopt.lower , lambda.lower , 1.e-6 );
-assert_equal ( yopt.upper , lambda.upper );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter , 4 );
+assert_checkequal ( yopt.ineqlin , lambda.ineqlin );
+assert_checkalmostequal ( yopt.eqlin , lambda.eqlin , 1.e-6 );
+assert_checkalmostequal ( yopt.lower , lambda.lower , 1.e-6 );
+assert_checkequal ( yopt.upper , lambda.upper );
 //
 // Minimize -x1 -x2
 // x1 - x2      = 0
@@ -209,14 +170,14 @@ lambda.ineqlin = [];
 lambda.eqlin = [0;1];
 lambda.upper = [0;0;0];
 lambda.lower = [0;0;1];
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter > 0 , %t );
-assert_equal ( yopt.ineqlin , lambda.ineqlin );
-assert_close ( yopt.eqlin , lambda.eqlin , 1.e-6 );
-assert_close ( yopt.lower , lambda.lower , 1.e-6 );
-assert_equal ( yopt.upper , lambda.upper );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter > 0 , %t );
+assert_checkequal ( yopt.ineqlin , lambda.ineqlin );
+assert_checkalmostequal ( yopt.eqlin , lambda.eqlin , 1.e-6 );
+assert_checkalmostequal ( yopt.lower , lambda.lower , 1.e-6 );
+assert_checkequal ( yopt.upper , lambda.upper );
 //
 // Give a linear inequality A*x <= b.
 //
@@ -240,14 +201,14 @@ lambda.ineqlin = 1;
 lambda.eqlin = 0;
 lambda.upper = [0;0];
 lambda.lower = [0;0];
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter > 0 , %t );
-assert_close ( yopt.ineqlin , lambda.ineqlin , 1.e-6 );
-assert_close ( yopt.eqlin , lambda.eqlin , 1.e-6 );
-assert_equal ( yopt.lower , lambda.lower );
-assert_equal ( yopt.upper , lambda.upper );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter > 0 , %t );
+assert_checkalmostequal ( yopt.ineqlin , lambda.ineqlin , 1.e-6 );
+assert_checkalmostequal ( yopt.eqlin , lambda.eqlin , [] , 1.e-6 );
+assert_checkequal ( yopt.lower , lambda.lower );
+assert_checkequal ( yopt.upper , lambda.upper );
 //
 // Give a linear inequality A*x <= b
 //
@@ -263,27 +224,27 @@ beq = 0;
 c = [-1;-1];
 A = [1 1];
 b = 2;
-function stop = myoutputfunction2 ( xopt , optimValues , state )
-    assert_equal ( size(xopt) , [2 1] );
-    assert_equal ( or(state==["init","iter","done"]) , %t );
-    assert_equal ( or(optimValues.procedure==["x0","x*"]) , %t );
+function stop = myoutputfunction3 ( xopt , optimValues , state )
+    assert_checkequal ( size(xopt) , [2 1] );
+    assert_checkequal ( or(state==["init","iter","done"]) , %t );
+    assert_checkequal ( or(optimValues.procedure==["x0","x*"]) , %t );
     stop = %f
 endfunction
-[xopt,fopt,exitflag,iter,yopt]=karmarkar(Aeq,beq,c,[],[],[],[],myoutputfunction2,A,b);
+[xopt,fopt,exitflag,iter,yopt]=karmarkar(Aeq,beq,c,[],[],[],[],myoutputfunction3,A,b);
 xstar=[1 1]';
 fstar = c'*xstar;
 lambda.ineqlin = 1;
 lambda.eqlin = 0;
 lambda.upper = [0;0];
 lambda.lower = [0;0];
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter > 0 , %t );
-assert_close ( yopt.ineqlin , lambda.ineqlin , 1.e-6 );
-assert_close ( yopt.eqlin , lambda.eqlin , 1.e-6 );
-assert_equal ( yopt.lower , lambda.lower );
-assert_equal ( yopt.upper , lambda.upper );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter > 0 , %t );
+assert_checkalmostequal ( yopt.ineqlin , lambda.ineqlin , 1.e-6 );
+assert_checkalmostequal ( yopt.eqlin , lambda.eqlin , [] , 1.e-6 );
+assert_checkequal ( yopt.lower , lambda.lower );
+assert_checkequal ( yopt.upper , lambda.upper );
 //
 // Minimize -20.x1 - 24.x2 such as:
 // 3.x1 + 6.x2 >= 60
@@ -303,14 +264,14 @@ lambda.ineqlin = [28/9;8/3];
 lambda.eqlin = [];
 lambda.upper = [0;0];
 lambda.lower = [0;0];
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter > 0 , %t );
-assert_close ( yopt.ineqlin , lambda.ineqlin , 1.e-6 );
-assert_close ( yopt.eqlin , lambda.eqlin , 1.e-6 );
-assert_equal ( yopt.lower , lambda.lower );
-assert_equal ( yopt.upper , lambda.upper );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter > 0 , %t );
+assert_checkalmostequal ( yopt.ineqlin , lambda.ineqlin , 1.e-6 );
+assert_checkequal ( yopt.eqlin , lambda.eqlin );
+assert_checkequal ( yopt.lower , lambda.lower );
+assert_checkequal ( yopt.upper , lambda.upper );
 //
 // References
 // "Practical Optimization", Antoniou, Lu, 2007
@@ -340,19 +301,19 @@ x0 = [0.2;0.7;1];
 [xopt,fopt,exitflag,iter]=karmarkar(Aeq,beq,c,x0,[],[],[],[],A,b);
 xstar = [0 1/3 1/3]';
 fstar = c'*xstar;
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter > 0 , %t );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter > 0 , %t );
 //
 // Let x0 be found by the algorithm.
 [xopt,fopt,exitflag,iter]=karmarkar(Aeq,beq,c,[],[],[],[],[],A,b);
 xstar = [0 1/3 1/3]';
 fstar = c'*xstar;
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter > 0 , %t );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter > 0 , %t );
 /////////////////////////////////////////////////////
 // References
 // "Lipsol toolbox", Yin Zhang, Scilab port by Rubio Scola, example0.sce.
@@ -394,14 +355,14 @@ lambda.eqlin = [];
 lambda.upper = [0;0;0];
 lambda.lower = [0;0;0];
 [xopt,fopt,exitflag,iter,yopt]=karmarkar(Aeq,beq,c,[],[],[],[],[],A,b);
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter > 0 , %t );
-assert_close ( yopt.ineqlin , lambda.ineqlin , 1.e-9 );
-assert_equal ( yopt.eqlin , lambda.eqlin );
-assert_equal ( yopt.lower , lambda.lower );
-assert_equal ( yopt.upper , lambda.upper );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter > 0 , %t );
+assert_checkalmostequal ( yopt.ineqlin , lambda.ineqlin , 1.e-9 );
+assert_checkequal ( yopt.eqlin , lambda.eqlin );
+assert_checkequal ( yopt.lower , lambda.lower );
+assert_checkequal ( yopt.upper , lambda.upper );
 
 //
 // Minimize 2.x1 + 9.x2 + 3.x3
@@ -429,14 +390,14 @@ lambda.ineqlin = [3.5;0.5;8.5;0;0];
 lambda.eqlin = [];
 lambda.upper = [0;0;0];
 lambda.lower = [0;0;0];
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter > 0 , %t );
-assert_close ( yopt.ineqlin , lambda.ineqlin , 1.e-9 );
-assert_equal ( yopt.eqlin , lambda.eqlin );
-assert_equal ( yopt.lower , lambda.lower );
-assert_equal ( yopt.upper , lambda.upper );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter > 0 , %t );
+assert_checkalmostequal ( yopt.ineqlin , lambda.ineqlin , 1.e-9 );
+assert_checkequal ( yopt.eqlin , lambda.eqlin );
+assert_checkequal ( yopt.lower , lambda.lower );
+assert_checkequal ( yopt.upper , lambda.upper );
 
 //////////////////////////////////////////////////////////////////////////
 //
@@ -457,14 +418,14 @@ lambda.ineqlin = [3.5;0.5];
 lambda.eqlin = [];
 lambda.upper = [0;0;0];
 lambda.lower = [8.5;0;0];
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter > 0 , %t );
-assert_close ( yopt.ineqlin , lambda.ineqlin , 1.e-9 );
-assert_equal ( yopt.eqlin , lambda.eqlin );
-assert_close ( yopt.lower , lambda.lower , 1.e-9 );
-assert_equal ( yopt.upper , lambda.upper );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter > 0 , %t );
+assert_checkalmostequal ( yopt.ineqlin , lambda.ineqlin , 1.e-9 );
+assert_checkequal ( yopt.eqlin , lambda.eqlin );
+assert_checkalmostequal ( yopt.lower , lambda.lower , 1.e-9 );
+assert_checkequal ( yopt.upper , lambda.upper );
 //
 // Set lower bound and give x0.
 Aeq=[];
@@ -484,14 +445,14 @@ lambda.ineqlin = [3.5;0.5];
 lambda.eqlin = [];
 lambda.upper = [0;0;0];
 lambda.lower = [8.5;0;0];
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter > 0 , %t );
-assert_close ( yopt.ineqlin , lambda.ineqlin , 1.e-9 );
-assert_close ( yopt.eqlin , lambda.eqlin , %eps );
-assert_close ( yopt.lower , lambda.lower , 1.e-9 );
-assert_close ( yopt.upper , lambda.upper , 1.e-9 );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter > 0 , %t );
+assert_checkalmostequal ( yopt.ineqlin , lambda.ineqlin , 1.e-9 );
+assert_checkalmostequal ( yopt.eqlin , lambda.eqlin , %eps );
+assert_checkalmostequal ( yopt.lower , lambda.lower , 1.e-9 );
+assert_checkalmostequal ( yopt.upper , lambda.upper , 1.e-9 );
 // References
 // LIPSOL is a set of Linear-programming Interior-Point SOLvers written 
 // by Yin Zhang. 
@@ -528,14 +489,14 @@ lambda.ineqlin = [0;0];
 lambda.eqlin = [];
 lambda.upper = [0;0;2.5];
 lambda.lower = [2;5;0];
-assert_close ( xopt , xstar , 1.e-4 );
-assert_close ( fopt , fstar , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( iter > 0 , %t );
-assert_close ( yopt.ineqlin , lambda.ineqlin , 1.e-9 );
-assert_close ( yopt.eqlin , lambda.eqlin , %eps );
-assert_close ( yopt.lower , lambda.lower , 1.e-9 );
-assert_close ( yopt.upper , lambda.upper , 1.e-9 );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( fopt , fstar , 1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( iter > 0 , %t );
+assert_checkalmostequal ( yopt.ineqlin , lambda.ineqlin , [] , 1.e-9 );
+assert_checkequal ( yopt.eqlin , lambda.eqlin );
+assert_checkalmostequal ( yopt.lower , lambda.lower , 1.e-9 );
+assert_checkalmostequal ( yopt.upper , lambda.upper , 1.e-9 );
 //
 // An unbounded problem.
 c = [-20 -24]';
@@ -545,7 +506,7 @@ A = [
 ];
 b = [-60 -32]';
 [xopt,fopt,exitflag,iter,yopt]=karmarkar([],[],c,[],[],[],[],[],A,b);
-assert_equal ( exitflag , -2 );
+assert_checkequal ( exitflag , -2 );
 //
 // "Linear Programming in Matlab"
 // Ferris, Mangasarian, Wright
@@ -567,14 +528,14 @@ b=[-2;10];
 b=-b;
 lb=[0;0];
 [xopt,fopt,exitflag,iter,yopt]=karmarkar([],[],c,[],[],[],[],[],A,b,lb);
-assert_equal ( xopt , [] );
-assert_equal ( fopt , [] );
-assert_equal ( exitflag , -1 );
-assert_equal ( iter > 0 , %t );
-assert_equal ( yopt.ineqlin , [] );
-assert_equal ( yopt.eqlin , [] );
-assert_equal ( yopt.lower , [] );
-assert_equal ( yopt.upper , [] );
+assert_checkequal ( xopt , [] );
+assert_checkequal ( fopt , [] );
+assert_checkequal ( exitflag , -1 );
+assert_checkequal ( iter > 0 , %t );
+assert_checkequal ( yopt.ineqlin , [] );
+assert_checkequal ( yopt.eqlin , [] );
+assert_checkequal ( yopt.lower , [] );
+assert_checkequal ( yopt.upper , [] );
 
 
 //
@@ -598,7 +559,7 @@ b=[1;2];
 b=-b;
 lb=[0;0];
 [xopt,fopt,exitflag,iter,yopt]=karmarkar([],[],c,[],[],[],[],[],A,b,lb);
-assert_equal ( exitflag , -2 );
+assert_checkequal ( exitflag , -2 );
 
 //
 // "Linear and Nonlinear Optimization"
@@ -619,7 +580,7 @@ A=[
 b=[2;1];
 lb=[0;0];
 [xopt,fopt,exitflag,iter,yopt]=karmarkar([],[],c,[],[],[],[],[],A,b,lb);
-assert_equal ( exitflag , -2 );
+assert_checkequal ( exitflag , -2 );
 //
 // "Linear and Nonlinear Optimization"
 // Griva, Nash, Sofer
@@ -639,20 +600,20 @@ A=[
 b=[-6;4];
 lb=[0;0];
 [xopt,fopt,exitflag,iter,yopt]=karmarkar([],[],c,[],[],[],[],[],A,b,lb);
-assert_equal ( exitflag , -1 );
+assert_checkequal ( exitflag , -1 );
 //
 // Example from the help page
 // Check that the output points remain feasible
-function stop = myoutputfunction3 ( xopt , optimValues , state , A , b )
-    assert_equal ( and(A*xopt<=b) , %t );
+function stop = myoutputfunction4 ( xopt , optimValues , state , A , b )
+    assert_checkequal ( and(A*xopt<=b) , %t );
     stop = %f
 endfunction
 n=11;
 A = [2*linspace(0,1,n)',ones(n,1)];
 b = 1 + linspace(0,1,n)'.^2;
 c=[-1;-1];
-xopt=karmarkar([],[],c,[],[],[],[],list(myoutputfunction3,A,b),A,b);
+xopt=karmarkar([],[],c,[],[],[],[],list(myoutputfunction4,A,b),A,b);
 xstar = [0.5005127;0.7494803];
-assert_close ( xopt , xstar , 1.e-4 );
+assert_checkalmostequal ( xopt , xstar , 1.e-4 );
 
 
index b1e5228..c1c9bba 100644 (file)
@@ -1,47 +1,13 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008-2009 - INRIA - Michael Baudin
+// Copyright (C) 2011 - DIGITEO - Michael Baudin
 //
 // This file must be used under the terms of the CeCILL.
 // This source file is licensed as described in the file COPYING, which
 // you should have received as part of this distribution.  The terms
 // are also available at
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
+// <-- JVM NOT MANDATORY -->
 function [ y , index ] = rosenbrock ( x , index )
   y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
 endfunction
@@ -49,48 +15,45 @@ endfunction
 // Test basic use without parameters
 //
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] );
-assert_close ( x , [1.0   1.0], 1e-4 );
-assert_close ( fval , 0.0 , 1e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( output.iterations , 85 );
-assert_equal ( output.algorithm , "Nelder-Mead simplex direct search" );
-assert_equal ( output.funcCount , 159 );
-assert_equal ( output.message(1) , "Optimization terminated:");
+assert_checkalmostequal ( x , [1.0   1.0], 1e-4 );
+assert_checkalmostequal ( fval , 0.0 , [] , 1e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( output.iterations , 85 );
+assert_checkequal ( output.algorithm , "Nelder-Mead simplex direct search" );
+assert_checkequal ( output.funcCount , 159 );
+assert_checkequal ( output.message(1) , "Optimization terminated:");
 if getos() == 'Windows' then
-assert_equal ( output.message(2) , " the current x satisfies the termination criteria using OPTIONS.TolX of 1.000000e-004");
-assert_equal ( output.message(3) , " and F(X) satisfies the convergence criteria using OPTIONS.TolFun of 1.000000e-004");
+assert_checkequal ( output.message(2) , " the current x satisfies the termination criteria using OPTIONS.TolX of 1.000000e-004");
+assert_checkequal ( output.message(3) , " and F(X) satisfies the convergence criteria using OPTIONS.TolFun of 1.000000e-004");
 else
-assert_equal ( output.message(2) , " the current x satisfies the termination criteria using OPTIONS.TolX of 1.000000e-04");
-assert_equal ( output.message(3) , " and F(X) satisfies the convergence criteria using OPTIONS.TolFun of 1.000000e-04");
+assert_checkequal ( output.message(2) , " the current x satisfies the termination criteria using OPTIONS.TolX of 1.000000e-04");
+assert_checkequal ( output.message(3) , " and F(X) satisfies the convergence criteria using OPTIONS.TolFun of 1.000000e-04");
 end
 // 
 // fminsearch with incorrect number of input arguments
 //
 cmd = "fminsearch ( )";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "fminsearch: Unexpected number of input arguments : 0 provided while 2 or 3 are expected.";
-assert_equal ( computed , expected );
+assert_checkerror(cmd,"%s: Wrong number of input arguments: %d or %d expected.\n",[], "fminsearch",2,3);
 //
 // Check that tolerance on X is correctly taken into account
 //
 opt = optimset ( "TolX" , 1.e-2 );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-assert_close ( x , [1.0 1.0], 1.e-2 );
-assert_close ( fval , 0.0 , 1e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( output.iterations , 70 );
-assert_equal ( output.funcCount , 130 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e-2 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( output.iterations , 70 );
+assert_checkequal ( output.funcCount , 130 );
 //
 // Check that tolerance on F is correctly taken into account
 //
 opt = optimset ( "TolFun" , 1.e-10 );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-assert_close ( x , [1.0 1.0], 1.e-4 );
-assert_close ( fval , 0.0 , 1e-2 );
-assert_equal ( exitflag , 1 );
-assert_equal ( output.iterations , 90 );
-assert_equal ( output.funcCount , 168 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e-4 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e-2 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( output.iterations , 90 );
+assert_checkequal ( output.funcCount , 168 );
 //
 // Check that maximum number of iterations is correctly taken into account
 //
@@ -99,11 +62,11 @@ opt = optimset ( "MaxIter" , 10 );
 fminsearch: Exiting: Maximum number of iterations has been exceeded
          - increase MaxIter option.
          Current function value: 4.1355598
-assert_close ( x , [1.0 1.0], 1.e1 );
-assert_close ( fval , 0.0 , 1e1 );
-assert_equal ( exitflag , 0 );
-assert_equal ( output.iterations , 10 );
-assert_equal ( output.funcCount , 21 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e1 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e1 );
+assert_checkequal ( exitflag , 0 );
+assert_checkequal ( output.iterations , 10 );
+assert_checkequal ( output.funcCount , 21 );
 //
 // Check that maximum number of function evaluations is correctly taken into account
 //
@@ -112,11 +75,11 @@ opt = optimset ( "MaxFunEvals" , 10 );
 fminsearch: Exiting: Maximum number of function evaluations has been exceeded
           - increase MaxFunEvals option.
          Current function value: 4.3813601
-assert_close ( x , [1.0 1.0], 1.e1 );
-assert_close ( fval , 0.0 , 1e1 );
-assert_equal ( exitflag , 0 );
-assert_equal ( output.iterations , 5 );
-assert_equal ( output.funcCount , 11 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e1 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e1 );
+assert_checkequal ( exitflag , 0 );
+assert_checkequal ( output.iterations , 5 );
+assert_checkequal ( output.funcCount , 11 );
 //
 // Check that Display is correctly used in mode "final"
 //
@@ -125,11 +88,11 @@ opt = optimset ( "Display" , "final" );
 Optimization terminated:
  the current x satisfies the termination criteria using OPTIONS.TolX of 1.000000e-04
  and F(X) satisfies the convergence criteria using OPTIONS.TolFun of 1.000000e-04
-assert_close ( x , [1.0 1.0], 1.e-4 );
-assert_close ( fval , 0.0 , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( output.iterations , 85 );
-assert_equal ( output.funcCount , 159 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e-4 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( output.iterations , 85 );
+assert_checkequal ( output.funcCount , 159 );
 //
 // Check that Display is correctly used in mode "iter"
 //
@@ -226,41 +189,41 @@ opt = optimset ( "Display" , "iter" );
 Optimization terminated:
  the current x satisfies the termination criteria using OPTIONS.TolX of 1.000000e-04
  and F(X) satisfies the convergence criteria using OPTIONS.TolFun of 1.000000e-04
-assert_close ( x , [1.0 1.0], 1.e-4 );
-assert_close ( fval , 0.0 , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( output.iterations , 85 );
-assert_equal ( output.funcCount , 159 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e-4 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( output.iterations , 85 );
+assert_checkequal ( output.funcCount , 159 );
 //
 // Check that Display is correctly used in mode "off" (no message at all)
 //
 opt = optimset ( "Display" , "off" );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-assert_close ( x , [1.0 1.0], 1.e-4 );
-assert_close ( fval , 0.0 , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( output.iterations , 85 );
-assert_equal ( output.funcCount , 159 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e-4 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( output.iterations , 85 );
+assert_checkequal ( output.funcCount , 159 );
 //
 // Check that Display is correctly used in mode "notify" (display only problem messages)
 //
 opt = optimset ( "Display" , "notify" );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-assert_close ( x , [1.0 1.0], 1.e-4 );
-assert_close ( fval , 0.0 , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( output.iterations , 85 );
-assert_equal ( output.funcCount , 159 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e-4 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( output.iterations , 85 );
+assert_checkequal ( output.funcCount , 159 );
 //
 // Check that Display is correctly used in mode "off" (no message at all), when there is a maximum number of iterations reached
 //
 opt = optimset ( "Display" , "off" , "MaxIter" , 10 );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-assert_close ( x , [1.0 1.0], 1.e1 );
-assert_close ( fval , 0.0 , 1e1 );
-assert_equal ( exitflag , 0 );
-assert_equal ( output.iterations , 10 );
-assert_equal ( output.funcCount , 21 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e1 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e1 );
+assert_checkequal ( exitflag , 0 );
+assert_checkequal ( output.iterations , 10 );
+assert_checkequal ( output.funcCount , 21 );
 //
 // Check that Display is correctly used in mode "notify" (display only problem messages), when there is a maximum number of iterations reached
 //
@@ -269,11 +232,11 @@ opt = optimset ( "Display" , "notify" , "MaxIter" , 10 );
 fminsearch: Exiting: Maximum number of iterations has been exceeded
          - increase MaxIter option.
          Current function value: 4.1355598
-assert_close ( x , [1.0 1.0], 1.e1 );
-assert_close ( fval , 0.0 , 1e1 );
-assert_equal ( exitflag , 0 );
-assert_equal ( output.iterations , 10 );
-assert_equal ( output.funcCount , 21 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e1 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e1 );
+assert_checkequal ( exitflag , 0 );
+assert_checkequal ( output.iterations , 10 );
+assert_checkequal ( output.funcCount , 21 );
 //
 // Check that Display is correctly used in mode "iter", when there is a maximum number of iterations reached
 //
@@ -295,11 +258,11 @@ opt = optimset ( "Display" , "iter" , "MaxIter" , 10 );
 fminsearch: Exiting: Maximum number of iterations has been exceeded
          - increase MaxIter option.
          Current function value: 4.1355598
-assert_close ( x , [1.0 1.0], 1.e1 );
-assert_close ( fval , 0.0 , 1e1 );
-assert_equal ( exitflag , 0 );
-assert_equal ( output.iterations , 10 );
-assert_equal ( output.funcCount , 21 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e1 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e1 );
+assert_checkequal ( exitflag , 0 );
+assert_checkequal ( output.iterations , 10 );
+assert_checkequal ( output.funcCount , 21 );
 //
 // Check that Display is correctly used in mode "final", when there is a maximum number of iterations reached
 //
@@ -308,13 +271,13 @@ opt = optimset ( "Display" , "final" , "MaxIter" , 10 );
 fminsearch: Exiting: Maximum number of iterations has been exceeded
          - increase MaxIter option.
          Current function value: 4.1355598
-assert_close ( x , [1.0 1.0], 1.e1 );
-assert_close ( fval , 0.0 , 1e1 );
-assert_equal ( exitflag , 0 );
-assert_equal ( output.iterations , 10 );
-assert_equal ( output.funcCount , 21 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e1 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e1 );
+assert_checkequal ( exitflag , 0 );
+assert_checkequal ( output.iterations , 10 );
+assert_checkequal ( output.funcCount , 21 );
 //
 // Test basic use with column x0
 //
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1].' );
-assert_close ( x , [1.0   1.0], 1e-4 );
+assert_checkalmostequal ( x , [1.0   1.0], 1e-4 );
index c3e7460..f481b54 100644 (file)
@@ -1,5 +1,6 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008-2009 - INRIA - Michael Baudin
+// Copyright (C) 2011 - DIGITEO - Michael Baudin
 //
 // This file must be used under the terms of the CeCILL.
 // This source file is licensed as described in the file COPYING, which
@@ -8,45 +9,8 @@
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 
 
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
 function [ y , index ] = rosenbrock ( x , index )
   y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
 endfunction
@@ -54,152 +18,149 @@ endfunction
 // Test basic use without parameters
 //
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] );
-assert_close ( x , [1.0   1.0], 1e-4 );
-assert_close ( fval , 0.0 , 1e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( output.iterations , 85 );
-assert_equal ( output.algorithm , "Nelder-Mead simplex direct search" );
-assert_equal ( output.funcCount , 159 );
-assert_equal ( output.message(1) , "Optimization terminated:");
+assert_checkalmostequal ( x , [1.0   1.0], 1e-4 );
+assert_checkalmostequal ( fval , 0.0 , [] , 1e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( output.iterations , 85 );
+assert_checkequal ( output.algorithm , "Nelder-Mead simplex direct search" );
+assert_checkequal ( output.funcCount , 159 );
+assert_checkequal ( output.message(1) , "Optimization terminated:");
 if getos() == 'Windows' then
-assert_equal ( output.message(2) , " the current x satisfies the termination criteria using OPTIONS.TolX of 1.000000e-004");
-assert_equal ( output.message(3) , " and F(X) satisfies the convergence criteria using OPTIONS.TolFun of 1.000000e-004");
+assert_checkequal ( output.message(2) , " the current x satisfies the termination criteria using OPTIONS.TolX of 1.000000e-004");
+assert_checkequal ( output.message(3) , " and F(X) satisfies the convergence criteria using OPTIONS.TolFun of 1.000000e-004");
 else
-assert_equal ( output.message(2) , " the current x satisfies the termination criteria using OPTIONS.TolX of 1.000000e-04");
-assert_equal ( output.message(3) , " and F(X) satisfies the convergence criteria using OPTIONS.TolFun of 1.000000e-04");
+assert_checkequal ( output.message(2) , " the current x satisfies the termination criteria using OPTIONS.TolX of 1.000000e-04");
+assert_checkequal ( output.message(3) , " and F(X) satisfies the convergence criteria using OPTIONS.TolFun of 1.000000e-04");
 end
 // 
 // fminsearch with incorrect number of input arguments
 //
 cmd = "fminsearch ( )";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "fminsearch: Unexpected number of input arguments : 0 provided while 2 or 3 are expected.";
-assert_equal ( computed , expected );
+assert_checkerror(cmd,"%s: Wrong number of input arguments: %d or %d expected.\n",[], "fminsearch",2,3);
 //
 // Check that tolerance on X is correctly taken into account
 //
 opt = optimset ( "TolX" , 1.e-2 );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-assert_close ( x , [1.0 1.0], 1.e-2 );
-assert_close ( fval , 0.0 , 1e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( output.iterations , 70 );
-assert_equal ( output.funcCount , 130 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e-2 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( output.iterations , 70 );
+assert_checkequal ( output.funcCount , 130 );
 //
 // Check that tolerance on F is correctly taken into account
 //
 opt = optimset ( "TolFun" , 1.e-10 );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-assert_close ( x , [1.0 1.0], 1.e-4 );
-assert_close ( fval , 0.0 , 1e-2 );
-assert_equal ( exitflag , 1 );
-assert_equal ( output.iterations , 90 );
-assert_equal ( output.funcCount , 168 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e-4 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e-2 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( output.iterations , 90 );
+assert_checkequal ( output.funcCount , 168 );
 //
 // Check that maximum number of iterations is correctly taken into account
 //
 opt = optimset ( "MaxIter" , 10 );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-assert_close ( x , [1.0 1.0], 1.e1 );
-assert_close ( fval , 0.0 , 1e1 );
-assert_equal ( exitflag , 0 );
-assert_equal ( output.iterations , 10 );
-assert_equal ( output.funcCount , 21 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e1 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e1 );
+assert_checkequal ( exitflag , 0 );
+assert_checkequal ( output.iterations , 10 );
+assert_checkequal ( output.funcCount , 21 );
 //
 // Check that maximum number of function evaluations is correctly taken into account
 //
 opt = optimset ( "MaxFunEvals" , 10 );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-assert_close ( x , [1.0 1.0], 1.e1 );
-assert_close ( fval , 0.0 , 1e1 );
-assert_equal ( exitflag , 0 );
-assert_equal ( output.iterations , 5 );
-assert_equal ( output.funcCount , 11 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e1 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e1 );
+assert_checkequal ( exitflag , 0 );
+assert_checkequal ( output.iterations , 5 );
+assert_checkequal ( output.funcCount , 11 );
 //
 // Check that Display is correctly used in mode "final"
 //
 opt = optimset ( "Display" , "final" );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-assert_close ( x , [1.0 1.0], 1.e-4 );
-assert_close ( fval , 0.0 , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( output.iterations , 85 );
-assert_equal ( output.funcCount , 159 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e-4 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( output.iterations , 85 );
+assert_checkequal ( output.funcCount , 159 );
 //
 // Check that Display is correctly used in mode "iter"
 //
 opt = optimset ( "Display" , "iter" );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-assert_close ( x , [1.0 1.0], 1.e-4 );
-assert_close ( fval , 0.0 , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( output.iterations , 85 );
-assert_equal ( output.funcCount , 159 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e-4 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( output.iterations , 85 );
+assert_checkequal ( output.funcCount , 159 );
 //
 // Check that Display is correctly used in mode "off" (no message at all)
 //
 opt = optimset ( "Display" , "off" );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-assert_close ( x , [1.0 1.0], 1.e-4 );
-assert_close ( fval , 0.0 , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( output.iterations , 85 );
-assert_equal ( output.funcCount , 159 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e-4 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( output.iterations , 85 );
+assert_checkequal ( output.funcCount , 159 );
 //
 // Check that Display is correctly used in mode "notify" (display only problem messages)
 //
 opt = optimset ( "Display" , "notify" );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-assert_close ( x , [1.0 1.0], 1.e-4 );
-assert_close ( fval , 0.0 , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( output.iterations , 85 );
-assert_equal ( output.funcCount , 159 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e-4 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( output.iterations , 85 );
+assert_checkequal ( output.funcCount , 159 );
 //
 // Check that Display is correctly used in mode "off" (no message at all), when there is a maximum number of iterations reached
 //
 opt = optimset ( "Display" , "off" , "MaxIter" , 10 );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-assert_close ( x , [1.0 1.0], 1.e1 );
-assert_close ( fval , 0.0 , 1e1 );
-assert_equal ( exitflag , 0 );
-assert_equal ( output.iterations , 10 );
-assert_equal ( output.funcCount , 21 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e1 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e1 );
+assert_checkequal ( exitflag , 0 );
+assert_checkequal ( output.iterations , 10 );
+assert_checkequal ( output.funcCount , 21 );
 //
 // Check that Display is correctly used in mode "notify" (display only problem messages), when there is a maximum number of iterations reached
 //
 opt = optimset ( "Display" , "notify" , "MaxIter" , 10 );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-assert_close ( x , [1.0 1.0], 1.e1 );
-assert_close ( fval , 0.0 , 1e1 );
-assert_equal ( exitflag , 0 );
-assert_equal ( output.iterations , 10 );
-assert_equal ( output.funcCount , 21 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e1 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e1 );
+assert_checkequal ( exitflag , 0 );
+assert_checkequal ( output.iterations , 10 );
+assert_checkequal ( output.funcCount , 21 );
 //
 // Check that Display is correctly used in mode "iter", when there is a maximum number of iterations reached
 //
 opt = optimset ( "Display" , "iter" , "MaxIter" , 10 );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-assert_close ( x , [1.0 1.0], 1.e1 );
-assert_close ( fval , 0.0 , 1e1 );
-assert_equal ( exitflag , 0 );
-assert_equal ( output.iterations , 10 );
-assert_equal ( output.funcCount , 21 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e1 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e1 );
+assert_checkequal ( exitflag , 0 );
+assert_checkequal ( output.iterations , 10 );
+assert_checkequal ( output.funcCount , 21 );
 //
 // Check that Display is correctly used in mode "final", when there is a maximum number of iterations reached
 //
 opt = optimset ( "Display" , "final" , "MaxIter" , 10 );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-assert_close ( x , [1.0 1.0], 1.e1 );
-assert_close ( fval , 0.0 , 1e1 );
-assert_equal ( exitflag , 0 );
-assert_equal ( output.iterations , 10 );
-assert_equal ( output.funcCount , 21 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e1 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e1 );
+assert_checkequal ( exitflag , 0 );
+assert_checkequal ( output.iterations , 10 );
+assert_checkequal ( output.funcCount , 21 );
 
 //
 // Test basic use with column x0
 //
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1].' );
-assert_close ( x , [1.0   1.0], 1e-4 );
+assert_checkalmostequal ( x , [1.0   1.0], 1e-4 );
 
index c74874d..1c1fe2c 100644 (file)
@@ -1,47 +1,13 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008-2009 - INRIA - Michael Baudin
+// Copyright (C) 2011 - DIGITEO - Michael Baudin
 //
 // This file must be used under the terms of the CeCILL.
 // This source file is licensed as described in the file COPYING, which
 // you should have received as part of this distribution.  The terms
 // are also available at
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
+// <-- JVM NOT MANDATORY -->
 function [ y , index ] = rosenbrock ( x , index )
   y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
 endfunction
@@ -49,394 +15,269 @@ endfunction
 // Test basic use without parameters
 //
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] );
-assert_close ( x , [1.0   1.0], 1e-4 );
-assert_close ( fval , 0.0 , 1e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( output.iterations , 85 );
-assert_equal ( output.algorithm , "Nelder-Mead simplex direct search" );
-assert_equal ( output.funcCount , 159 );
-assert_equal ( output.message(1) , "Optimization terminated:");
+assert_checkalmostequal ( x , [1.0   1.0], 1e-4 );
+assert_checkalmostequal ( fval , 0.0 , [] , 1e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( output.iterations , 85 );
+assert_checkequal ( output.algorithm , "Nelder-Mead simplex direct search" );
+assert_checkequal ( output.funcCount , 159 );
+assert_checkequal ( output.message(1) , "Optimization terminated:");
 if getos() == 'Windows' then
-assert_equal ( output.message(2) , " the current x satisfies the termination criteria using OPTIONS.TolX of 1.000000e-004");
-assert_equal ( output.message(3) , " and F(X) satisfies the convergence criteria using OPTIONS.TolFun of 1.000000e-004");
+assert_checkequal ( output.message(2) , " the current x satisfies the termination criteria using OPTIONS.TolX of 1.000000e-004");
+assert_checkequal ( output.message(3) , " and F(X) satisfies the convergence criteria using OPTIONS.TolFun of 1.000000e-004");
 else
-assert_equal ( output.message(2) , " the current x satisfies the termination criteria using OPTIONS.TolX of 1.000000e-04");
-assert_equal ( output.message(3) , " and F(X) satisfies the convergence criteria using OPTIONS.TolFun of 1.000000e-04");
+assert_checkequal ( output.message(2) , " the current x satisfies the termination criteria using OPTIONS.TolX of 1.000000e-04");
+assert_checkequal ( output.message(3) , " and F(X) satisfies the convergence criteria using OPTIONS.TolFun of 1.000000e-04");
 end
 // 
 // fminsearch with incorrect number of input arguments
 //
 cmd = "fminsearch ( )";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "fminsearch: Unexpected number of input arguments : 0 provided while 2 or 3 are expected.";
-assert_equal ( computed , expected );
+assert_checkerror(cmd,"%s: Wrong number of input arguments: %d or %d expected.\n",[], "fminsearch",2,3);
 //
 // Check that tolerance on X is correctly taken into account
 //
 opt = optimset ( "TolX" , 1.e-2 );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-assert_close ( x , [1.0 1.0], 1.e-2 );
-assert_close ( fval , 0.0 , 1e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( output.iterations , 70 );
-assert_equal ( output.funcCount , 130 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e-2 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( output.iterations , 70 );
+assert_checkequal ( output.funcCount , 130 );
 //
 // Check that tolerance on F is correctly taken into account
 //
 opt = optimset ( "TolFun" , 1.e-10 );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-assert_close ( x , [1.0 1.0], 1.e-4 );
-assert_close ( fval , 0.0 , 1e-2 );
-assert_equal ( exitflag , 1 );
-assert_equal ( output.iterations , 90 );
-assert_equal ( output.funcCount , 168 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e-4 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e-2 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( output.iterations , 90 );
+assert_checkequal ( output.funcCount , 168 );
 //
 // Check that maximum number of iterations is correctly taken into account
 //
 opt = optimset ( "MaxIter" , 10 );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
 fminsearch: Exiting: Maximum number of iterations has been exceeded
-
          - increase MaxIter option.
-
          Current function value: 4.1355598
-
-assert_close ( x , [1.0 1.0], 1.e1 );
-assert_close ( fval , 0.0 , 1e1 );
-assert_equal ( exitflag , 0 );
-assert_equal ( output.iterations , 10 );
-assert_equal ( output.funcCount , 21 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e1 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e1 );
+assert_checkequal ( exitflag , 0 );
+assert_checkequal ( output.iterations , 10 );
+assert_checkequal ( output.funcCount , 21 );
 //
 // Check that maximum number of function evaluations is correctly taken into account
 //
 opt = optimset ( "MaxFunEvals" , 10 );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
 fminsearch: Exiting: Maximum number of function evaluations has been exceeded
-
           - increase MaxFunEvals option.
-
          Current function value: 4.3813601
-
-assert_close ( x , [1.0 1.0], 1.e1 );
-assert_close ( fval , 0.0 , 1e1 );
-assert_equal ( exitflag , 0 );
-assert_equal ( output.iterations , 5 );
-assert_equal ( output.funcCount , 11 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e1 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e1 );
+assert_checkequal ( exitflag , 0 );
+assert_checkequal ( output.iterations , 5 );
+assert_checkequal ( output.funcCount , 11 );
 //
 // Check that Display is correctly used in mode "final"
 //
 opt = optimset ( "Display" , "final" );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
 Optimization terminated:
-
  the current x satisfies the termination criteria using OPTIONS.TolX of 1.000000e-004
-
  and F(X) satisfies the convergence criteria using OPTIONS.TolFun of 1.000000e-004
-
-assert_close ( x , [1.0 1.0], 1.e-4 );
-assert_close ( fval , 0.0 , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( output.iterations , 85 );
-assert_equal ( output.funcCount , 159 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e-4 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( output.iterations , 85 );
+assert_checkequal ( output.funcCount , 159 );
 //
 // Check that Display is correctly used in mode "iter"
 //
 opt = optimset ( "Display" , "iter" );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
  Iteration   Func-count     min f(x)         Procedure
-
      0            3             24.2                             
-
      1            3            20.05         initial simplex     
-
      2            5         5.161796         expand              
-
      3            7         4.497796         reflect             
-
      4            9         4.497796         contract outside    
-
      5           11        4.3813601         contract inside     
-
      6           13        4.2452728         contract inside     
-
      7           15        4.2176247         reflect             
-
      8           17        4.2112906         contract inside     
-
      9           19        4.1355598         expand              
-
     10           21        4.1355598         contract inside     
-
     11           23        4.0127268         expand              
-
     12           25        3.9373812         expand              
-
     13           27         3.602606         expand              
-
     14           28         3.602606         reflect             
-
     15           30        3.4662211         reflect             
-
     16           32        3.2160547         expand              
-
     17           34        3.1649126         reflect             
-
     18           36        2.7068692         expand              
-
     19           37        2.7068692         reflect             
-
     20           39        2.0021824         expand              
-
     21           41        2.0021824         contract inside     
-
     22           43        2.0021824         contract inside     
-
     23           45        1.8154337         expand              
-
     24           47        1.7348144         contract outside    
-
     25           49        1.3169723         expand              
-
     26           50        1.3169723         reflect             
-
     27           51        1.3169723         reflect             
-
     28           53        1.1595038         reflect             
-
     29           55        1.0767387         contract inside     
-
     30           57        0.8834921         reflect             
-
     31           59        0.8834921         contract inside     
-
     32           61        0.6691654         expand              
-
     33           63        0.6691654         contract inside     
-
     34           64        0.6691654         reflect             
-
     35           66        0.5367289         reflect             
-
     36           68        0.5367289         contract inside     
-
     37           70        0.4232940         expand              
-
     38           72        0.4232940         contract outside    
-
     39           74        0.3985272         reflect             
-
     40           76        0.3144704         expand              
-
     41           77        0.3144704         reflect             
-
     42           79        0.1903167         expand              
-
     43           81        0.1903167         contract inside     
-
     44           82        0.1903167         reflect             
-
     45           84        0.1369602         reflect             
-
     46           86        0.1369602         contract outside    
-
     47           88        0.1131281         contract outside    
-
     48           90        0.1105304         contract inside     
-
     49           92        0.1023402         reflect             
-
     50           94        0.1011837         contract inside     
-
     51           96        0.0794969         expand              
-
     52           97        0.0794969         reflect             
-
     53           98        0.0794969         reflect             
-
     54          100        0.0569294         expand              
-
     55          102        0.0569294         contract inside     
-
     56          104        0.0344855         expand              
-
     57          106        0.0179534         expand              
-
     58          108        0.0169469         contract outside    
-
     59          110        0.0040146         reflect             
-
     60          112        0.0040146         contract inside     
-
     61          113        0.0040146         reflect             
-
     62          115        0.0003700         reflect             
-
     63          117        0.0003700         contract inside     
-
     64          118        0.0003700         reflect             
-
     65          120        0.0003700         contract inside     
-
     66          122        0.0000590         contract outside    
-
     67          124        0.0000337         contract inside     
-
     68          126        0.0000337         contract outside    
-
     69          128        0.0000189         contract outside    
-
     70          130        0.0000085         contract inside     
-
     71          132        0.0000029         contract inside     
-
     72          133        0.0000029         reflect             
-
     73          135        0.0000007         contract inside     
-
     74          137        0.0000007         contract inside     
-
     75          139        0.0000006         contract inside     
-
     76          141        0.0000002         contract outside    
-
     77          143        0.0000001         contract inside     
-
     78          145        5.235D-08         contract inside     
-
     79          147        5.035D-08         contract inside     
-
     80          149        2.004D-08         contract inside     
-
     81          151        1.123D-09         contract inside     
-
     82          153        1.123D-09         contract outside    
-
     83          155        1.123D-09         contract inside     
-
     84          157        1.108D-09         contract outside    
-
     85          159        8.178D-10         contract inside     
 
-
-
 Optimization terminated:
-
  the current x satisfies the termination criteria using OPTIONS.TolX of 1.000000e-004
-
  and F(X) satisfies the convergence criteria using OPTIONS.TolFun of 1.000000e-004
-
-assert_close ( x , [1.0 1.0], 1.e-4 );
-assert_close ( fval , 0.0 , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( output.iterations , 85 );
-assert_equal ( output.funcCount , 159 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e-4 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( output.iterations , 85 );
+assert_checkequal ( output.funcCount , 159 );
 //
 // Check that Display is correctly used in mode "off" (no message at all)
 //
 opt = optimset ( "Display" , "off" );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-assert_close ( x , [1.0 1.0], 1.e-4 );
-assert_close ( fval , 0.0 , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( output.iterations , 85 );
-assert_equal ( output.funcCount , 159 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e-4 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( output.iterations , 85 );
+assert_checkequal ( output.funcCount , 159 );
 //
 // Check that Display is correctly used in mode "notify" (display only problem messages)
 //
 opt = optimset ( "Display" , "notify" );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-assert_close ( x , [1.0 1.0], 1.e-4 );
-assert_close ( fval , 0.0 , 1.e-4 );
-assert_equal ( exitflag , 1 );
-assert_equal ( output.iterations , 85 );
-assert_equal ( output.funcCount , 159 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e-4 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1.e-4 );
+assert_checkequal ( exitflag , 1 );
+assert_checkequal ( output.iterations , 85 );
+assert_checkequal ( output.funcCount , 159 );
 //
 // Check that Display is correctly used in mode "off" (no message at all), when there is a maximum number of iterations reached
 //
 opt = optimset ( "Display" , "off" , "MaxIter" , 10 );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-assert_close ( x , [1.0 1.0], 1.e1 );
-assert_close ( fval , 0.0 , 1e1 );
-assert_equal ( exitflag , 0 );
-assert_equal ( output.iterations , 10 );
-assert_equal ( output.funcCount , 21 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e1 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e1 );
+assert_checkequal ( exitflag , 0 );
+assert_checkequal ( output.iterations , 10 );
+assert_checkequal ( output.funcCount , 21 );
 //
 // Check that Display is correctly used in mode "notify" (display only problem messages), when there is a maximum number of iterations reached
 //
 opt = optimset ( "Display" , "notify" , "MaxIter" , 10 );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
 fminsearch: Exiting: Maximum number of iterations has been exceeded
-
          - increase MaxIter option.
-
          Current function value: 4.1355598
-
-assert_close ( x , [1.0 1.0], 1.e1 );
-assert_close ( fval , 0.0 , 1e1 );
-assert_equal ( exitflag , 0 );
-assert_equal ( output.iterations , 10 );
-assert_equal ( output.funcCount , 21 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e1 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e1 );
+assert_checkequal ( exitflag , 0 );
+assert_checkequal ( output.iterations , 10 );
+assert_checkequal ( output.funcCount , 21 );
 //
 // Check that Display is correctly used in mode "iter", when there is a maximum number of iterations reached
 //
 opt = optimset ( "Display" , "iter" , "MaxIter" , 10 );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
  Iteration   Func-count     min f(x)         Procedure
-
      0            3             24.2                             
-
      1            3            20.05         initial simplex     
-
      2            5         5.161796         expand              
-
      3            7         4.497796         reflect             
-
      4            9         4.497796         contract outside    
-
      5           11        4.3813601         contract inside     
-
      6           13        4.2452728         contract inside     
-
      7           15        4.2176247         reflect             
-
      8           17        4.2112906         contract inside     
-
      9           19        4.1355598         expand              
-
     10           21        4.1355598         contract inside     
 
-
-
 fminsearch: Exiting: Maximum number of iterations has been exceeded
-
          - increase MaxIter option.
-
          Current function value: 4.1355598
-
-assert_close ( x , [1.0 1.0], 1.e1 );
-assert_close ( fval , 0.0 , 1e1 );
-assert_equal ( exitflag , 0 );
-assert_equal ( output.iterations , 10 );
-assert_equal ( output.funcCount , 21 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e1 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e1 );
+assert_checkequal ( exitflag , 0 );
+assert_checkequal ( output.iterations , 10 );
+assert_checkequal ( output.funcCount , 21 );
 //
 // Check that Display is correctly used in mode "final", when there is a maximum number of iterations reached
 //
 opt = optimset ( "Display" , "final" , "MaxIter" , 10 );
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1] , opt );
 fminsearch: Exiting: Maximum number of iterations has been exceeded
-
          - increase MaxIter option.
-
          Current function value: 4.1355598
-
-assert_close ( x , [1.0 1.0], 1.e1 );
-assert_close ( fval , 0.0 , 1e1 );
-assert_equal ( exitflag , 0 );
-assert_equal ( output.iterations , 10 );
-assert_equal ( output.funcCount , 21 );
+assert_checkalmostequal ( x , [1.0 1.0], 1.e1 );
+assert_checkalmostequal ( fval , 0.0 , [] ,  1e1 );
+assert_checkequal ( exitflag , 0 );
+assert_checkequal ( output.iterations , 10 );
+assert_checkequal ( output.funcCount , 21 );
 //
 // Test basic use with column x0
 //
 [x , fval , exitflag , output] = fminsearch ( rosenbrock , [-1.2 1].' );
-assert_close ( x , [1.0   1.0], 1e-4 );
+assert_checkalmostequal ( x , [1.0   1.0], 1e-4 );
index 36d38cd..2e4e245 100644 (file)
@@ -1,47 +1,13 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008-2009 - INRIA - Michael Baudin
+// Copyright (C) 2011 - DIGITEO - Michael Baudin
 //
 // This file must be used under the terms of the CeCILL.
 // This source file is licensed as described in the file COPYING, which
 // you should have received as part of this distribution.  The terms
 // are also available at
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
+// <-- ENGLISH IMPOSED -->
 function [ y , index ] = rosenbrock ( x , index )
   y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
 endfunction
@@ -98,200 +64,50 @@ function outfun ( x , optimValues , state )
   mprintf ( "%d %e %d -%s- %s\n" , fc , fv , it , pr , state )
 endfunction
 opt = optimset ( "OutputFcn" , outfun);
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
 3 2.420000e+001 0 -- init
-
 3 2.005000e+001 1 -initial simplex- iter
-
 5 5.161796e+000 2 -expand- iter
-
 7 4.497796e+000 3 -reflect- iter
-
 9 4.497796e+000 4 -contract outside- iter
-
 11 4.381360e+000 5 -contract inside- iter
-
 13 4.245273e+000 6 -contract inside- iter
-
 15 4.217625e+000 7 -reflect- iter
-
 17 4.211291e+000 8 -contract inside- iter
-
 19 4.135560e+000 9 -expand- iter
-
 21 4.135560e+000 10 -contract inside- iter
-
-23 4.012727e+000 11 -expand- iter
-
-25 3.937381e+000 12 -expand- iter
-
-27 3.602606e+000 13 -expand- iter
-
-28 3.602606e+000 14 -reflect- iter
-
-30 3.466221e+000 15 -reflect- iter
-
-32 3.216055e+000 16 -expand- iter
-
-34 3.164913e+000 17 -reflect- iter
-
-36 2.706869e+000 18 -expand- iter
-
-37 2.706869e+000 19 -reflect- iter
-
-39 2.002182e+000 20 -expand- iter
-
-41 2.002182e+000 21 -contract inside- iter
-
-43 2.002182e+000 22 -contract inside- iter
-
-45 1.815434e+000 23 -expand- iter
-
-47 1.734814e+000 24 -contract outside- iter
-
-49 1.316972e+000 25 -expand- iter
-
-50 1.316972e+000 26 -reflect- iter
-
-51 1.316972e+000 27 -reflect- iter
-
-53 1.159504e+000 28 -reflect- iter
-
-55 1.076739e+000 29 -contract inside- iter
-
-57 8.834921e-001 30 -reflect- iter
-
-59 8.834921e-001 31 -contract inside- iter
-
-61 6.691654e-001 32 -expand- iter
-
-63 6.691654e-001 33 -contract inside- iter
-
-64 6.691654e-001 34 -reflect- iter
-
-66 5.367289e-001 35 -reflect- iter
-
-68 5.367289e-001 36 -contract inside- iter
-
-70 4.232940e-001 37 -expand- iter
-
-72 4.232940e-001 38 -contract outside- iter
-
-74 3.985272e-001 39 -reflect- iter
-
-76 3.144704e-001 40 -expand- iter
-
-77 3.144704e-001 41 -reflect- iter
-
-79 1.903167e-001 42 -expand- iter
-
-81 1.903167e-001 43 -contract inside- iter
-
-82 1.903167e-001 44 -reflect- iter
-
-84 1.369602e-001 45 -reflect- iter
-
-86 1.369602e-001 46 -contract outside- iter
-
-88 1.131281e-001 47 -contract outside- iter
-
-90 1.105304e-001 48 -contract inside- iter
-
-92 1.023402e-001 49 -reflect- iter
-
-94 1.011837e-001 50 -contract inside- iter
-
-96 7.949687e-002 51 -expand- iter
-
-97 7.949687e-002 52 -reflect- iter
-
-98 7.949687e-002 53 -reflect- iter
-
-100 5.692937e-002 54 -expand- iter
-
-102 5.692937e-002 55 -contract inside- iter
-
-104 3.448549e-002 56 -expand- iter
-
-106 1.795342e-002 57 -expand- iter
-
-108 1.694692e-002 58 -contract outside- iter
-
-110 4.014627e-003 59 -reflect- iter
-
-112 4.014627e-003 60 -contract inside- iter
-
-113 4.014627e-003 61 -reflect- iter
-
-115 3.699544e-004 62 -reflect- iter
-
-117 3.699544e-004 63 -contract inside- iter
-
-118 3.699544e-004 64 -reflect- iter
-
-120 3.699544e-004 65 -contract inside- iter
-
-122 5.901115e-005 66 -contract outside- iter
-
-124 3.366824e-005 67 -contract inside- iter
-
-126 3.366824e-005 68 -contract outside- iter
-
-128 1.891590e-005 69 -contract outside- iter
-
-130 8.460826e-006 70 -contract inside- iter
-
-132 2.882547e-006 71 -contract inside- iter
-
-133 2.882547e-006 72 -reflect- iter
-
-135 7.489972e-007 73 -contract inside- iter
-
-137 7.489972e-007 74 -contract inside- iter
-
-139 6.203654e-007 75 -contract inside- iter
-
-141 2.169195e-007 76 -contract outside- iter
-
-143 1.002443e-007 77 -contract inside- iter
-
-145 5.234866e-008 78 -contract inside- iter
-
-147 5.035031e-008 79 -contract inside- iter
-
-149 2.004302e-008 80 -contract inside- iter
-
-151 1.122930e-009 81 -contract inside- iter
-
-153 1.122930e-009 82 -contract outside- iter
-
-155 1.122930e-009 83 -contract inside- iter
-
-157 1.107549e-009 84 -contract outside- iter
-
-159 8.177661e-010 85 -contract inside- iter
-
-159 8.177661e-010 85 -- done
-
-close();
+21 4.135560e+000 10 -- done
+fminsearch: Exiting: Maximum number of iterations has been exceeded
+         - increase MaxIter option.
+         Current function value: 4.1355598
+close(gcf());
 //
 // Use several output functions
 //
 function outfun2 ( x , optimValues , state )
-  scf ( fig1 );
+  global __fig1__
+  scf ( __fig1__ );
   plot( x(1),x(2),'.');
 endfunction
 function outfun3 ( x , optimValues , state )
-  scf ( fig2 );
+  global __fig2__
+  scf ( __fig2__ );
   plot( x(1),x(2),'o');
 endfunction
 myfunctions = list ( outfun2 , outfun3 );
-fig1 = scf(1000);
-fig2 = scf(1001);
+global __fig1__
+global __fig2__
+__fig1__ = scf();
+__fig2__ = scf();
 opt = optimset ( "OutputFcn" , myfunctions );
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-close(fig1);
-close(fig2);
+fminsearch: Exiting: Maximum number of iterations has been exceeded
+         - increase MaxIter option.
+         Current function value: 4.1355598
+close(__fig1__);
+close(__fig2__);
 //
 // Use plot function
 //
@@ -312,48 +128,78 @@ function plotfun ( x , optimValues , state )
   plot(x(1),x(2),'.');
 endfunction
 opt = optimset ( "PlotFcns" , plotfun);
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-close();
+fminsearch: Exiting: Maximum number of iterations has been exceeded
+         - increase MaxIter option.
+         Current function value: 4.1355598
+close(gcf());
 //
 // Use several plot functions
 //
 function plotfun2 ( x , optimValues , state )
-  scf ( fig1 );
+  global __fig1__
+  scf ( __fig1__ );
   plot( x(1),x(2),'.');
 endfunction
 function plotfun3 ( x , optimValues , state )
-  scf ( fig2 );
+  global __fig2__
+  scf ( __fig2__ );
   plot( x(1),x(2),'o');
 endfunction
 myfunctions = list ( plotfun2 , plotfun3 );
-fig1 = scf(1000);
-fig2 = scf(1001);
+global __fig1__
+global __fig2__
+__fig1__ = scf();
+__fig2__ = scf();
 opt = optimset ( "PlotFcns" , myfunctions );
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-close(fig1);
-close(fig2);
+fminsearch: Exiting: Maximum number of iterations has been exceeded
+         - increase MaxIter option.
+         Current function value: 4.1355598
+close(__fig1__);
+close(__fig2__);
 //
 // Use optimplotfval plot function
 //
 opt = optimset ( "PlotFcns" , optimplotfval );
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-close();
+fminsearch: Exiting: Maximum number of iterations has been exceeded
+         - increase MaxIter option.
+         Current function value: 4.1355598
+close(gcf());
 //
 // Use optimplotx plot function
 //
 opt = optimset ( "PlotFcns" , optimplotx );
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-close();
+fminsearch: Exiting: Maximum number of iterations has been exceeded
+         - increase MaxIter option.
+         Current function value: 4.1355598
+close(gcf());
 //
 // Use optimplotfunccount plot function
 //
 opt = optimset ( "PlotFcns" , optimplotfunccount );
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-close();
+fminsearch: Exiting: Maximum number of iterations has been exceeded
+         - increase MaxIter option.
+         Current function value: 4.1355598
+close(gcf());
 //
 // Use all 3 plot functions
 //
 myfunctions = list ( optimplotfval , optimplotx , optimplotfunccount );
 opt = optimset ( "PlotFcns" , myfunctions );
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-close();
+fminsearch: Exiting: Maximum number of iterations has been exceeded
+         - increase MaxIter option.
+         Current function value: 4.1355598
+close(gcf());
+close(gcf());
+close(gcf());
index 8b0d96f..cc96b62 100644 (file)
@@ -1,5 +1,6 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008-2009 - INRIA - Michael Baudin
+// Copyright (C) 2011 - DIGITEO - Michael Baudin
 //
 // This file must be used under the terms of the CeCILL.
 // This source file is licensed as described in the file COPYING, which
@@ -9,42 +10,6 @@
 
 // <-- ENGLISH IMPOSED -->
 
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
 function [ y , index ] = rosenbrock ( x , index )
   y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
 endfunction
@@ -101,26 +66,32 @@ function outfun ( x , optimValues , state )
   mprintf ( "%d %e %d -%s- %s\n" , fc , fv , it , pr , state )
 endfunction
 opt = optimset ( "OutputFcn" , outfun);
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-close();
+close(gcf());
 //
 // Use several output functions
 //
 function outfun2 ( x , optimValues , state )
-  scf ( fig1 );
+  global __fig1__
+  scf ( __fig1__ );
   plot( x(1),x(2),'.');
 endfunction
 function outfun3 ( x , optimValues , state )
-  scf ( fig2 );
+  global __fig2__
+  scf ( __fig2__ );
   plot( x(1),x(2),'o');
 endfunction
 myfunctions = list ( outfun2 , outfun3 );
-fig1 = scf(1000);
-fig2 = scf(1001);
+global __fig1__
+global __fig2__
+__fig1__ = scf();
+__fig2__ = scf();
 opt = optimset ( "OutputFcn" , myfunctions );
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-close(fig1);
-close(fig2);
+close(__fig1__);
+close(__fig2__);
 //
 // Use plot function
 //
@@ -141,51 +112,63 @@ function plotfun ( x , optimValues , state )
   plot(x(1),x(2),'.');
 endfunction
 opt = optimset ( "PlotFcns" , plotfun);
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-close();
+close(gcf());
 //
 // Use several plot functions
 //
 function plotfun2 ( x , optimValues , state )
-  scf ( fig1 );
+  global __fig1__
+  scf ( __fig1__ );
   plot( x(1),x(2),'.');
 endfunction
 function plotfun3 ( x , optimValues , state )
-  scf ( fig2 );
+  global __fig2__
+  scf ( __fig2__ );
   plot( x(1),x(2),'o');
 endfunction
 myfunctions = list ( plotfun2 , plotfun3 );
-fig1 = scf(1000);
-fig2 = scf(1001);
+global __fig1__
+global __fig2__
+__fig1__ = scf();
+__fig2__ = scf();
 opt = optimset ( "PlotFcns" , myfunctions );
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-close(fig1);
-close(fig2);
+close(__fig1__);
+close(__fig2__);
 //
 // Use optimplotfval plot function
 //
 opt = optimset ( "PlotFcns" , optimplotfval );
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-close();
+close(gcf());
 //
 // Use optimplotx plot function
 //
 opt = optimset ( "PlotFcns" , optimplotx );
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-close();
+close(gcf());
 //
 // Use optimplotfunccount plot function
 //
 opt = optimset ( "PlotFcns" , optimplotfunccount );
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-close();
+close(gcf());
 
 //
 // Use all 3 plot functions
 //
 myfunctions = list ( optimplotfval , optimplotx , optimplotfunccount );
 opt = optimset ( "PlotFcns" , myfunctions );
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-close();
+close(gcf());
+close(gcf());
+close(gcf());
 
 
index db671aa..773e213 100644 (file)
@@ -1,47 +1,13 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008-2009 - INRIA - Michael Baudin
+// Copyright (C) 2011 - DIGITEO - Michael Baudin
 //
 // This file must be used under the terms of the CeCILL.
 // This source file is licensed as described in the file COPYING, which
 // you should have received as part of this distribution.  The terms
 // are also available at
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
+// <-- ENGLISH IMPOSED -->
 function [ y , index ] = rosenbrock ( x , index )
   y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
 endfunction
@@ -98,6 +64,7 @@ function outfun ( x , optimValues , state )
   mprintf ( "%d %e %d -%s- %s\n" , fc , fv , it , pr , state )
 endfunction
 opt = optimset ( "OutputFcn" , outfun);
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
 3 2.420000e+01 0 -- init
 3 2.005000e+01 1 -initial simplex- iter
@@ -110,101 +77,37 @@ opt = optimset ( "OutputFcn" , outfun);
 17 4.211291e+00 8 -contract inside- iter
 19 4.135560e+00 9 -expand- iter
 21 4.135560e+00 10 -contract inside- iter
-23 4.012727e+00 11 -expand- iter
-25 3.937381e+00 12 -expand- iter
-27 3.602606e+00 13 -expand- iter
-28 3.602606e+00 14 -reflect- iter
-30 3.466221e+00 15 -reflect- iter
-32 3.216055e+00 16 -expand- iter
-34 3.164913e+00 17 -reflect- iter
-36 2.706869e+00 18 -expand- iter
-37 2.706869e+00 19 -reflect- iter
-39 2.002182e+00 20 -expand- iter
-41 2.002182e+00 21 -contract inside- iter
-43 2.002182e+00 22 -contract inside- iter
-45 1.815434e+00 23 -expand- iter
-47 1.734814e+00 24 -contract outside- iter
-49 1.316972e+00 25 -expand- iter
-50 1.316972e+00 26 -reflect- iter
-51 1.316972e+00 27 -reflect- iter
-53 1.159504e+00 28 -reflect- iter
-55 1.076739e+00 29 -contract inside- iter
-57 8.834921e-01 30 -reflect- iter
-59 8.834921e-01 31 -contract inside- iter
-61 6.691654e-01 32 -expand- iter
-63 6.691654e-01 33 -contract inside- iter
-64 6.691654e-01 34 -reflect- iter
-66 5.367289e-01 35 -reflect- iter
-68 5.367289e-01 36 -contract inside- iter
-70 4.232940e-01 37 -expand- iter
-72 4.232940e-01 38 -contract outside- iter
-74 3.985272e-01 39 -reflect- iter
-76 3.144704e-01 40 -expand- iter
-77 3.144704e-01 41 -reflect- iter
-79 1.903167e-01 42 -expand- iter
-81 1.903167e-01 43 -contract inside- iter
-82 1.903167e-01 44 -reflect- iter
-84 1.369602e-01 45 -reflect- iter
-86 1.369602e-01 46 -contract outside- iter
-88 1.131281e-01 47 -contract outside- iter
-90 1.105304e-01 48 -contract inside- iter
-92 1.023402e-01 49 -reflect- iter
-94 1.011837e-01 50 -contract inside- iter
-96 7.949687e-02 51 -expand- iter
-97 7.949687e-02 52 -reflect- iter
-98 7.949687e-02 53 -reflect- iter
-100 5.692937e-02 54 -expand- iter
-102 5.692937e-02 55 -contract inside- iter
-104 3.448549e-02 56 -expand- iter
-106 1.795342e-02 57 -expand- iter
-108 1.694692e-02 58 -contract outside- iter
-110 4.014627e-03 59 -reflect- iter
-112 4.014627e-03 60 -contract inside- iter
-113 4.014627e-03 61 -reflect- iter
-115 3.699544e-04 62 -reflect- iter
-117 3.699544e-04 63 -contract inside- iter
-118 3.699544e-04 64 -reflect- iter
-120 3.699544e-04 65 -contract inside- iter
-122 5.901115e-05 66 -contract outside- iter
-124 3.366824e-05 67 -contract inside- iter
-126 3.366824e-05 68 -contract outside- iter
-128 1.891590e-05 69 -contract outside- iter
-130 8.460826e-06 70 -contract inside- iter
-132 2.882547e-06 71 -contract inside- iter
-133 2.882547e-06 72 -reflect- iter
-135 7.489972e-07 73 -contract inside- iter
-137 7.489972e-07 74 -contract inside- iter
-139 6.203654e-07 75 -contract inside- iter
-141 2.169195e-07 76 -contract outside- iter
-143 1.002443e-07 77 -contract inside- iter
-145 5.234866e-08 78 -contract inside- iter
-147 5.035031e-08 79 -contract inside- iter
-149 2.004302e-08 80 -contract inside- iter
-151 1.122930e-09 81 -contract inside- iter
-153 1.122930e-09 82 -contract outside- iter
-155 1.122930e-09 83 -contract inside- iter
-157 1.107549e-09 84 -contract outside- iter
-159 8.177661e-10 85 -contract inside- iter
-159 8.177661e-10 85 -- done
-close();
+21 4.135560e+00 10 -- done
+fminsearch: Exiting: Maximum number of iterations has been exceeded
+         - increase MaxIter option.
+         Current function value: 4.1355598
+close(gcf());
 //
 // Use several output functions
 //
 function outfun2 ( x , optimValues , state )
-  scf ( fig1 );
+  global __fig1__
+  scf ( __fig1__ );
   plot( x(1),x(2),'.');
 endfunction
 function outfun3 ( x , optimValues , state )
-  scf ( fig2 );
+  global __fig2__
+  scf ( __fig2__ );
   plot( x(1),x(2),'o');
 endfunction
 myfunctions = list ( outfun2 , outfun3 );
-fig1 = scf(1000);
-fig2 = scf(1001);
+global __fig1__
+global __fig2__
+__fig1__ = scf();
+__fig2__ = scf();
 opt = optimset ( "OutputFcn" , myfunctions );
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-close(fig1);
-close(fig2);
+fminsearch: Exiting: Maximum number of iterations has been exceeded
+         - increase MaxIter option.
+         Current function value: 4.1355598
+close(__fig1__);
+close(__fig2__);
 //
 // Use plot function
 //
@@ -225,48 +128,78 @@ function plotfun ( x , optimValues , state )
   plot(x(1),x(2),'.');
 endfunction
 opt = optimset ( "PlotFcns" , plotfun);
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-close();
+fminsearch: Exiting: Maximum number of iterations has been exceeded
+         - increase MaxIter option.
+         Current function value: 4.1355598
+close(gcf());
 //
 // Use several plot functions
 //
 function plotfun2 ( x , optimValues , state )
-  scf ( fig1 );
+  global __fig1__
+  scf ( __fig1__ );
   plot( x(1),x(2),'.');
 endfunction
 function plotfun3 ( x , optimValues , state )
-  scf ( fig2 );
+  global __fig2__
+  scf ( __fig2__ );
   plot( x(1),x(2),'o');
 endfunction
 myfunctions = list ( plotfun2 , plotfun3 );
-fig1 = scf(1000);
-fig2 = scf(1001);
+global __fig1__
+global __fig2__
+__fig1__ = scf();
+__fig2__ = scf();
 opt = optimset ( "PlotFcns" , myfunctions );
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-close(fig1);
-close(fig2);
+fminsearch: Exiting: Maximum number of iterations has been exceeded
+         - increase MaxIter option.
+         Current function value: 4.1355598
+close(__fig1__);
+close(__fig2__);
 //
 // Use optimplotfval plot function
 //
 opt = optimset ( "PlotFcns" , optimplotfval );
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-close();
+fminsearch: Exiting: Maximum number of iterations has been exceeded
+         - increase MaxIter option.
+         Current function value: 4.1355598
+close(gcf());
 //
 // Use optimplotx plot function
 //
 opt = optimset ( "PlotFcns" , optimplotx );
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-close();
+fminsearch: Exiting: Maximum number of iterations has been exceeded
+         - increase MaxIter option.
+         Current function value: 4.1355598
+close(gcf());
 //
 // Use optimplotfunccount plot function
 //
 opt = optimset ( "PlotFcns" , optimplotfunccount );
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-close();
+fminsearch: Exiting: Maximum number of iterations has been exceeded
+         - increase MaxIter option.
+         Current function value: 4.1355598
+close(gcf());
 //
 // Use all 3 plot functions
 //
 myfunctions = list ( optimplotfval , optimplotx , optimplotfunccount );
 opt = optimset ( "PlotFcns" , myfunctions );
+opt = optimset ( opt , "MaxIter" , 10 );
 [x fval] = fminsearch ( rosenbrock , [-1.2 1] , opt );
-close();
+fminsearch: Exiting: Maximum number of iterations has been exceeded
+         - increase MaxIter option.
+         Current function value: 4.1355598
+close(gcf());
+close(gcf());
+close(gcf());
index 125b13b..6bf7e97 100644 (file)
@@ -1,5 +1,6 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008-2009 - INRIA - Michael Baudin
+// Copyright (C) 2011 - DIGITEO - Michael Baudin
 //
 // This file must be used under the terms of the CeCILL.
 // This source file is licensed as described in the file COPYING, which
@@ -7,46 +8,9 @@
 // are also available at
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 //
 // Check behaviour with configured settings.
 //
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
 function [ y , index ] = rosenbrock ( x , index )
   y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
 endfunction
@@ -64,7 +28,7 @@ nm = neldermead_configure(nm,"-maxfunevals",10);
 nm = neldermead_search(nm);
 funevals = neldermead_get(nm,"-funevals");
 // Let's be not strict
-assert_equal ( funevals < 15 , %T );
+assert_checkequal ( funevals < 15 , %T );
 // Cleanup
 nm = neldermead_destroy(nm);
 //
@@ -80,44 +44,31 @@ nm = neldermead_configure(nm,"-function",rosenbrock);
 nm = neldermead_configure(nm,"-maxiter",10);
 nm = neldermead_search(nm);
 iterations = neldermead_get(nm,"-iterations");
-assert_equal ( iterations , 10 );
+assert_checkequal ( iterations , 10 );
 // Cleanup
 nm = neldermead_destroy(nm);
 // Wrong -method flag
 nm = neldermead_new ();
 cmd = "nm = neldermead_configure(nm,''-method'',''foo'')";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "unknownValueForOption: Unknown value foo for -method option";
-assert_equal ( computed , expected );
+assert_checkerror(cmd,"%s: Unknown value %s for %s option",[],"unknownValueForOption","foo","-method");
 nm = neldermead_destroy(nm);
 // Wrong -simplex0method flag
 nm = neldermead_new ();
 cmd = "nm = neldermead_configure(nm,''-simplex0method'',''foo'')";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "unknownValueForOption: Unknown value foo for -simplex0method option";
-assert_equal ( computed , expected );
+assert_checkerror(cmd,"%s: Unknown value %s for %s option",[],"unknownValueForOption","foo","-simplex0method");
 nm = neldermead_destroy(nm);
 // Wrong -tolsimplexizemethod flag
 nm = neldermead_new ();
 cmd = "nm = neldermead_configure(nm,''-tolsimplexizemethod'',''foo'')";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "assert_typeboolean: Expected boolean but for variable value at input #3, got string instead.";
-assert_equal ( computed , expected );
+assert_checkerror(cmd,"%s: Expected boolean but for variable %s at input #%d, got %s instead.",[],"assert_typeboolean","value",3,"string");
 nm = neldermead_destroy(nm);
 // Wrong -tolssizedeltafvmethod flag
 nm = neldermead_new ();
 cmd = "nm = neldermead_configure(nm,''-tolssizedeltafvmethod'',''foo'')";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "assert_typeboolean: Expected boolean but for variable value at input #3, got string instead.";
-assert_equal ( computed , expected );
+assert_checkerror(cmd,"%s: Expected boolean but for variable %s at input #%d, got %s instead.",[],"assert_typeboolean","value",3,"string");
 nm = neldermead_destroy(nm);
 //
 // Check wrong key for get method
-//
 nm = neldermead_new ();
 nm = neldermead_configure(nm,"-numberofvariables",2);
 nm = neldermead_configure(nm,"-x0",[1.1 1.1]');
@@ -128,61 +79,35 @@ nm = neldermead_configure(nm,"-function",rosenbrock);
 nm = neldermead_configure(nm,"-maxfunevals",2);
 nm = neldermead_search(nm);
 cmd = "funevals = neldermead_get(nm,''-foo'')";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "optimbase_get: Unknown key -foo";
-assert_equal ( computed , expected );
+assert_checkerror(cmd,"%s: Unknown key %s",[],"optimbase_get","-foo");
 nm = neldermead_destroy(nm);
 //
 // Check that x0 is forced to be a column vector
-//
 nm = neldermead_new ();
 nm = neldermead_configure(nm,"-numberofvariables",2);
 cmd = "nm = neldermead_configure(nm,''-x0'',[-1.2 1.0]);";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "optimbase_configure: The x0 vector is expected to be a column matrix, but current shape is 1 x 2";
-assert_equal ( computed , expected );
+assert_checkerror(cmd,"%s: The x0 vector is expected to be a column matrix, but current shape is %d x %d",[],"optimbase_configure",1,2);
 nm = neldermead_destroy(nm);
 //
 // Check -restartstep
-//
 nm = neldermead_new ();
 nm = neldermead_configure(nm,"-numberofvariables",2);
-// Check that -restartstep is forced to be of consistent length : 1 or n
 cmd = "nm = neldermead_configure(nm,''-restartstep'',[1 2 3]);";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "neldermead_configure: The restartstep vector is expected to have 2 x 1 shape, but current shape is 1 x 3";
-assert_equal ( computed , expected );
-// Check that -restartstep is forced to be positive
+assert_checkerror(cmd,"%s: The restartstep vector is expected to have %d x %d shape, but current shape is %d x %d",[],"neldermead_configure",2,1,1,3);
 cmd = "nm = neldermead_configure(nm,''-restartstep'',[-1 2]'');";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "neldermead_configure: The restartstep vector is expected to be positive";
-assert_equal ( computed , expected );
+assert_checkerror(cmd,"%s: The restartstep vector is expected to be positive",[],"neldermead_configure");
 nm = neldermead_destroy(nm);
 //
 // Check -restarteps
-//
 nm = neldermead_new ();
 nm = neldermead_configure(nm,"-numberofvariables",2);
-// Check that -restarteps is forced to be a scalar double
 cmd = "nm = neldermead_configure(nm,''-restarteps'',[1 2]);";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "neldermead_configure: The restarteps option is expected to be a scalar, but current shape is 1 x 2";
-assert_equal ( computed , expected );
-// Check that -restarteps is forced to be positive
+assert_checkerror(cmd,"%s: The restarteps option is expected to be a scalar, but current shape is %d x %d",[],"neldermead_configure",1,2);
 cmd = "nm = neldermead_configure(nm,''-restarteps'',-1);";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "neldermead_configure: The restarteps option is expected to be positive";
-assert_equal ( computed , expected );
+assert_checkerror(cmd,"%s: The restarteps option is expected to be positive",[],"neldermead_configure");
 nm = neldermead_destroy(nm);
 //
 // Check the display system
-//
 nm = neldermead_new ();
 nm
  nm  =
diff --git a/scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_configure.linux.dia.ref b/scilab/modules/optimization/tests/unit_tests/neldermead/neldermead_configure.linux.dia.ref
new file mode 100644 (file)
index 0000000..05fb68c
--- /dev/null
@@ -0,0 +1,202 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2008-2009 - INRIA - Michael Baudin
+// Copyright (C) 2011 - DIGITEO - Michael Baudin
+//
+// This file must be used under the terms of the CeCILL.
+// This source file is licensed as described in the file COPYING, which
+// you should have received as part of this distribution.  The terms
+// are also available at
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+// <-- JVM NOT MANDATORY -->
+//
+// Check behaviour with configured settings.
+//
+function [ y , index ] = rosenbrock ( x , index )
+  y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
+endfunction
+//
+// Check maxfunevals with "variable" method
+//
+nm = neldermead_new ();
+nm = neldermead_configure(nm,"-numberofvariables",2);
+nm = neldermead_configure(nm,"-x0",[1.1 1.1]');
+nm = neldermead_configure(nm,"-simplex0method","axes");
+nm = neldermead_configure(nm,"-simplex0length",0.1);
+nm = neldermead_configure(nm,"-method","variable");
+nm = neldermead_configure(nm,"-function",rosenbrock);
+nm = neldermead_configure(nm,"-maxfunevals",10);
+nm = neldermead_search(nm);
+funevals = neldermead_get(nm,"-funevals");
+// Let's be not strict
+assert_checkequal ( funevals < 15 , %T );
+// Cleanup
+nm = neldermead_destroy(nm);
+//
+// Check maxiter with "variable" method
+//
+nm = neldermead_new ();
+nm = neldermead_configure(nm,"-numberofvariables",2);
+nm = neldermead_configure(nm,"-x0",[1.1 1.1]');
+nm = neldermead_configure(nm,"-simplex0method","axes");
+nm = neldermead_configure(nm,"-simplex0length",0.1);
+nm = neldermead_configure(nm,"-method","variable");
+nm = neldermead_configure(nm,"-function",rosenbrock);
+nm = neldermead_configure(nm,"-maxiter",10);
+nm = neldermead_search(nm);
+iterations = neldermead_get(nm,"-iterations");
+assert_checkequal ( iterations , 10 );
+// Cleanup
+nm = neldermead_destroy(nm);
+// Wrong -method flag
+nm = neldermead_new ();
+cmd = "nm = neldermead_configure(nm,''-method'',''foo'')";
+assert_checkerror(cmd,"%s: Unknown value %s for %s option",[],"unknownValueForOption","foo","-method");
+nm = neldermead_destroy(nm);
+// Wrong -simplex0method flag
+nm = neldermead_new ();
+cmd = "nm = neldermead_configure(nm,''-simplex0method'',''foo'')";
+assert_checkerror(cmd,"%s: Unknown value %s for %s option",[],"unknownValueForOption","foo","-simplex0method");
+nm = neldermead_destroy(nm);
+// Wrong -tolsimplexizemethod flag
+nm = neldermead_new ();
+cmd = "nm = neldermead_configure(nm,''-tolsimplexizemethod'',''foo'')";
+assert_checkerror(cmd,"%s: Expected boolean but for variable %s at input #%d, got %s instead.",[],"assert_typeboolean","value",3,"string");
+nm = neldermead_destroy(nm);
+// Wrong -tolssizedeltafvmethod flag
+nm = neldermead_new ();
+cmd = "nm = neldermead_configure(nm,''-tolssizedeltafvmethod'',''foo'')";
+assert_checkerror(cmd,"%s: Expected boolean but for variable %s at input #%d, got %s instead.",[],"assert_typeboolean","value",3,"string");
+nm = neldermead_destroy(nm);
+//
+// Check wrong key for get method
+nm = neldermead_new ();
+nm = neldermead_configure(nm,"-numberofvariables",2);
+nm = neldermead_configure(nm,"-x0",[1.1 1.1]');
+nm = neldermead_configure(nm,"-simplex0method","axes");
+nm = neldermead_configure(nm,"-simplex0length",0.1);
+nm = neldermead_configure(nm,"-method","variable");
+nm = neldermead_configure(nm,"-function",rosenbrock);
+nm = neldermead_configure(nm,"-maxfunevals",2);
+nm = neldermead_search(nm);
+cmd = "funevals = neldermead_get(nm,''-foo'')";
+assert_checkerror(cmd,"%s: Unknown key %s",[],"optimbase_get","-foo");
+nm = neldermead_destroy(nm);
+//
+// Check that x0 is forced to be a column vector
+nm = neldermead_new ();
+nm = neldermead_configure(nm,"-numberofvariables",2);
+cmd = "nm = neldermead_configure(nm,''-x0'',[-1.2 1.0]);";
+assert_checkerror(cmd,"%s: The x0 vector is expected to be a column matrix, but current shape is %d x %d",[],"optimbase_configure",1,2);
+nm = neldermead_destroy(nm);
+//
+// Check -restartstep
+nm = neldermead_new ();
+nm = neldermead_configure(nm,"-numberofvariables",2);
+cmd = "nm = neldermead_configure(nm,''-restartstep'',[1 2 3]);";
+assert_checkerror(cmd,"%s: The restartstep vector is expected to have %d x %d shape, but current shape is %d x %d",[],"neldermead_configure",2,1,1,3);
+cmd = "nm = neldermead_configure(nm,''-restartstep'',[-1 2]'');";
+assert_checkerror(cmd,"%s: The restartstep vector is expected to be positive",[],"neldermead_configure");
+nm = neldermead_destroy(nm);
+//
+// Check -restarteps
+nm = neldermead_new ();
+nm = neldermead_configure(nm,"-numberofvariables",2);
+cmd = "nm = neldermead_configure(nm,''-restarteps'',[1 2]);";
+assert_checkerror(cmd,"%s: The restarteps option is expected to be a scalar, but current shape is %d x %d",[],"neldermead_configure",1,2);
+cmd = "nm = neldermead_configure(nm,''-restarteps'',-1);";
+assert_checkerror(cmd,"%s: The restarteps option is expected to be positive",[],"neldermead_configure");
+nm = neldermead_destroy(nm);
+//
+// Check the display system
+nm = neldermead_new ();
+nm
+ nm  =
+Nelder-Mead Object:
+======================
+
+Simplex0 Method : axes
+Simplex0 Length : 1
+Simplex0, Pfeffer, Delta Usual : 0.05
+Simplex0, Pfeffer, Delta Zero : 0.0075
+Simplex0, Given, Coords :
+[]
+
+Termination parameters
+Termination on simplex size : T
+Termination on simplex size, Absolute Tolerance : 0
+Termination on simplex size, Relative Tolerance : 2.220D-16
+Termination on simplex size, Initial Simplex Size : 0
+Termination on simplex size + Delta of function value : F
+Termination on simplex size + Delta of function value, Absolute Tolerance on Delta F : 2.220D-16
+Termination on Kelley's Stagnation : F
+Termination on Kelley's Stagnation, Normalization : T
+Termination on Kelley's Stagnation, Alpha0 : 0.0001
+Termination on Kelley's Stagnation, Alpha : 0.0001
+Termination by Box : F
+Termination by Box, Absolute Tolerance on Function: 0.00001
+Termination by Box, Maximum Number of Consecutive Match : 5
+Termination by Box, Current Number of Consecutive Match : 0
+Termination on Variance : F
+Termination on Variance, Absolute Tolerance : 0
+Termination on Variance, Relative Tolerance : 2.220D-16
+Termination on Variance, Variance of Initial Simplex : 0
+
+Algorithms parameters
+Method : variable
+Reflection Factor (rho) : 1
+Expansion Factor (chi) : 2
+Contraction Factor (gamma) : 0.5
+Shrinkage Factor (sigma) : 0.5
+Kelley Stagnation : F
+Restart Epsilon : 2.220446e-16
+Restart Step : 1
+Restart Maximum : 3
+Restart Simplex Method : oriented
+Restart Flag : F
+Restart Number : 0
+Restart Detection Method : oneill
+Startup Flag : F
+Automatic Checking of Cost Function : T
+Box, Number of Points  : 2n
+Box, Current Number of Points  : 0
+Box, Scaling, Factor  : 0.5
+Box, Scaling, Method  : tox0
+Box, Scaling, Minimum : 0.00001
+Box, Bounds Parameter: 0.000001
+Box, Reflection Coefficient : 1.3
+
+Optim Base Object:
+==================
+Number of variables : 0
+Initial Guess : []
+Initial Function Value :
+Number of Inequality Constraints :0
+Bounds Mininimum : []
+Bounds Maxinimum :[]
+Optimum Parameters : [0]
+Optimum Function Value :0.000000e+00
+Number of iterations : 0
+Maximum number of iterations : 100
+Number function evaluations : 0
+Maximum number of function evaluations : 100
+Termination Method on function value : F
+Termination Absolute Tolerance on function value : 0
+Termination Relative Tolerance on function value : 2.220D-16
+Termination Method on x : T
+Termination Absolute Tolerance on x : 0
+Termination Relative Tolerance on x : 2.220D-16
+Optimization Status : 
+Verbose logging : 0
+Verbose Termination : 0
+Verbose Log File : 
+Verbose Log File Startup Up: F
+Store History : F
+
+Simplex0 : 
+Optim Simplex Object:
+=====================
+Empty simplex (zero dimension)
+
+Simplex Optimum : 
+nm = neldermead_destroy(nm);
index 753afdb..a92c1b5 100644 (file)
@@ -1,5 +1,6 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008-2009 - INRIA - Michael Baudin
+// Copyright (C) 2011 - DIGITEO - Michael Baudin
 //
 // This file must be used under the terms of the CeCILL.
 // This source file is licensed as described in the file COPYING, which
@@ -8,48 +9,12 @@
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 
 // <-- JVM NOT MANDATORY -->
-// <-- ENGLISH IMPOSED -->
 
 //
 // Check behaviour with configured settings.
 //
 
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
+
 function [ y , index ] = rosenbrock ( x , index )
   y = 100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
 endfunction
@@ -68,7 +33,7 @@ nm = neldermead_configure(nm,"-maxfunevals",10);
 nm = neldermead_search(nm);
 funevals = neldermead_get(nm,"-funevals");
 // Let's be not strict
-assert_equal ( funevals < 15 , %T );
+assert_checkequal ( funevals < 15 , %T );
 // Cleanup
 nm = neldermead_destroy(nm);
 
@@ -85,49 +50,36 @@ nm = neldermead_configure(nm,"-function",rosenbrock);
 nm = neldermead_configure(nm,"-maxiter",10);
 nm = neldermead_search(nm);
 iterations = neldermead_get(nm,"-iterations");
-assert_equal ( iterations , 10 );
+assert_checkequal ( iterations , 10 );
 // Cleanup
 nm = neldermead_destroy(nm);
 
 // Wrong -method flag
 nm = neldermead_new ();
 cmd = "nm = neldermead_configure(nm,''-method'',''foo'')";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "unknownValueForOption: Unknown value foo for -method option";
-assert_equal ( computed , expected );
+assert_checkerror(cmd,"%s: Unknown value %s for %s option",[],"unknownValueForOption","foo","-method");
 nm = neldermead_destroy(nm);
 
 // Wrong -simplex0method flag
 nm = neldermead_new ();
 cmd = "nm = neldermead_configure(nm,''-simplex0method'',''foo'')";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "unknownValueForOption: Unknown value foo for -simplex0method option";
-assert_equal ( computed , expected );
+assert_checkerror(cmd,"%s: Unknown value %s for %s option",[],"unknownValueForOption","foo","-simplex0method");
 nm = neldermead_destroy(nm);
 
 // Wrong -tolsimplexizemethod flag
 nm = neldermead_new ();
 cmd = "nm = neldermead_configure(nm,''-tolsimplexizemethod'',''foo'')";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "assert_typeboolean: Expected boolean but for variable value at input #3, got string instead.";
-assert_equal ( computed , expected );
+assert_checkerror(cmd,"%s: Expected boolean but for variable %s at input #%d, got %s instead.",[],"assert_typeboolean","value",3,"string");
 nm = neldermead_destroy(nm);
 
 // Wrong -tolssizedeltafvmethod flag
 nm = neldermead_new ();
 cmd = "nm = neldermead_configure(nm,''-tolssizedeltafvmethod'',''foo'')";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "assert_typeboolean: Expected boolean but for variable value at input #3, got string instead.";
-assert_equal ( computed , expected );
+assert_checkerror(cmd,"%s: Expected boolean but for variable %s at input #%d, got %s instead.",[],"assert_typeboolean","value",3,"string");
 nm = neldermead_destroy(nm);
 
 //
 // Check wrong key for get method
-//
 nm = neldermead_new ();
 nm = neldermead_configure(nm,"-numberofvariables",2);
 nm = neldermead_configure(nm,"-x0",[1.1 1.1]');
@@ -138,67 +90,39 @@ nm = neldermead_configure(nm,"-function",rosenbrock);
 nm = neldermead_configure(nm,"-maxfunevals",2);
 nm = neldermead_search(nm);
 cmd = "funevals = neldermead_get(nm,''-foo'')";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "optimbase_get: Unknown key -foo";
-assert_equal ( computed , expected );
+assert_checkerror(cmd,"%s: Unknown key %s",[],"optimbase_get","-foo");
 nm = neldermead_destroy(nm);
 
-
 //
 // Check that x0 is forced to be a column vector
-//
 nm = neldermead_new ();
 nm = neldermead_configure(nm,"-numberofvariables",2);
 cmd = "nm = neldermead_configure(nm,''-x0'',[-1.2 1.0]);";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "optimbase_configure: The x0 vector is expected to be a column matrix, but current shape is 1 x 2";
-assert_equal ( computed , expected );
+assert_checkerror(cmd,"%s: The x0 vector is expected to be a column matrix, but current shape is %d x %d",[],"optimbase_configure",1,2);
 nm = neldermead_destroy(nm);
 
 //
 // Check -restartstep
-//
 nm = neldermead_new ();
 nm = neldermead_configure(nm,"-numberofvariables",2);
-// Check that -restartstep is forced to be of consistent length : 1 or n
 cmd = "nm = neldermead_configure(nm,''-restartstep'',[1 2 3]);";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "neldermead_configure: The restartstep vector is expected to have 2 x 1 shape, but current shape is 1 x 3";
-assert_equal ( computed , expected );
-// Check that -restartstep is forced to be positive
+assert_checkerror(cmd,"%s: The restartstep vector is expected to have %d x %d shape, but current shape is %d x %d",[],"neldermead_configure",2,1,1,3);
 cmd = "nm = neldermead_configure(nm,''-restartstep'',[-1 2]'');";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "neldermead_configure: The restartstep vector is expected to be positive";
-assert_equal ( computed , expected );
+assert_checkerror(cmd,"%s: The restartstep vector is expected to be positive",[],"neldermead_configure");
 nm = neldermead_destroy(nm);
 
-
 //
 // Check -restarteps
-//
 nm = neldermead_new ();
 nm = neldermead_configure(nm,"-numberofvariables",2);
-// Check that -restarteps is forced to be a scalar double
 cmd = "nm = neldermead_configure(nm,''-restarteps'',[1 2]);";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "neldermead_configure: The restarteps option is expected to be a scalar, but current shape is 1 x 2";
-assert_equal ( computed , expected );
-// Check that -restarteps is forced to be positive
+assert_checkerror(cmd,"%s: The restarteps option is expected to be a scalar, but current shape is %d x %d",[],"neldermead_configure",1,2);
 cmd = "nm = neldermead_configure(nm,''-restarteps'',-1);";
-execstr(cmd,"errcatch");
-computed = lasterror();
-expected = "neldermead_configure: The restarteps option is expected to be positive";
-assert_equal ( computed , expected );
+assert_checkerror(cmd,"%s: The restarteps option is expected to be positive",[],"neldermead_configure");
 nm = neldermead_destroy(nm);
 
 //
 // Check the display system
-//
 nm = neldermead_new ();
 nm
 nm = neldermead_destroy(nm);
index 2e159de..c2a1800 100644 (file)
@@ -1,5 +1,6 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008-2009 - INRIA - Michael Baudin
+// Copyright (C) 2011 - DIGITEO - Michael Baudin
 //
 // This file must be used under the terms of the CeCILL.
 // This source file is licensed as described in the file COPYING, which
 // after the first optimization, which has failed.
 // The restart allows to compute a new simplex and makes the 
 // optimization converge toward the good point.
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
 //% MCKINNON computes the McKinnon function.
 //
 //  Discussion:
@@ -153,13 +118,13 @@ nm = neldermead_search(nm);
 // but this is the expected result of the Nelder-Mead
 // algorithm.
 xopt = neldermead_get(nm,"-xopt");
-assert_close ( xopt , [0.0;0.0], 1e-6 );
+assert_checkalmostequal ( xopt , [0.0;0.0], 1e-6 );
 // Check optimum point value
 fopt = neldermead_get(nm,"-fopt");
-assert_close ( fopt , 0.0 , 1e-6 );
+assert_checkalmostequal ( fopt , 0.0 , 1e-6 );
 // Check status
 status = neldermead_get(nm,"-status");
-assert_equal ( status , "tolsize" );
+assert_checkequal ( status , "tolsize" );
 nm = neldermead_destroy(nm);
 //
 // Test with manual restart
@@ -184,16 +149,16 @@ computing least squares solution. (see lsq).
 
 // Check optimum point
 xopt = neldermead_get(nm,"-xopt");
-assert_close ( xopt , [0.0;-0.5], 1e-5 );
+assert_checkalmostequal ( xopt , [0.0;-0.5], 1e-5 );
 // Check optimum point value
 fopt = neldermead_get(nm,"-fopt");
-assert_close ( fopt , -0.25 , 1e-6 );
+assert_checkalmostequal ( fopt , -0.25 , 1e-6 );
 // Check status
 status = neldermead_get(nm,"-status");
-assert_equal ( status , "tolsize" );
+assert_checkequal ( status , "tolsize" );
 // Check iterations
 iterations = neldermead_get(nm,"-iterations");
-assert_equal ( iterations > 200 , %t );
+assert_checkequal ( iterations > 200 , %t );
 nm = neldermead_destroy(nm);
 //
 // Test with Kelley stagnation criteria
@@ -213,7 +178,7 @@ nm = neldermead_configure(nm,"-kelleystagnationflag",%t);
 nm = neldermead_search(nm);
 // Check status
 status = neldermead_get(nm,"-status");
-assert_equal ( status , "kelleystagnation" );
+assert_checkequal ( status , "kelleystagnation" );
 nm = neldermead_destroy(nm);
 //
 // Test with auto-restart, Kelley stagnation detection and Kelley restart method
@@ -236,19 +201,19 @@ nm = neldermead_configure(nm,"-restartdetection","kelley");
 nm = neldermead_search(nm);
 // Check status
 status = neldermead_get(nm,"-status");
-assert_equal ( status , "maxrestart" );
+assert_checkequal ( status , "maxrestart" );
 // Check optimum point
 xopt = neldermead_get(nm,"-xopt");
-assert_close ( xopt , [0.0;-0.5], 1e-5 );
+assert_checkalmostequal ( xopt , [0.0;-0.5], 1e-5 );
 // Check optimum point value
 fopt = neldermead_get(nm,"-fopt");
-assert_close ( fopt , -0.25 , 1e-6 );
+assert_checkalmostequal ( fopt , -0.25 , 1e-6 );
 // Check iterations
 iterations = neldermead_get(nm,"-iterations");
-assert_equal ( ( iterations > 100 ) , %t );
+assert_checkequal ( ( iterations > 100 ) , %t );
 // Check number of restarts
 restartnb = neldermead_get ( nm , "-restartnb" );
-assert_equal ( restartnb , 3 );
+assert_checkequal ( restartnb , 3 );
 nm = neldermead_destroy(nm);
 //
 // Test with auto-restart, low precision on simplex size and O'Neill restart method.
@@ -275,19 +240,19 @@ computing least squares solution. (see lsq).
 
 // Check status
 status = neldermead_get(nm,"-status");
-assert_equal ( status , "tolsize" );
+assert_checkequal ( status , "tolsize" );
 // Check optimum point
 xopt = neldermead_get(nm,"-xopt");
-assert_close ( xopt , [0.0;-0.5], 1e-1 );
+assert_checkalmostequal ( xopt , [0.0;-0.5], 1e-1 );
 // Check optimum point value
 fopt = neldermead_get(nm,"-fopt");
-assert_close ( fopt , -0.25 , 1e-4 );
+assert_checkalmostequal ( fopt , -0.25 , 1e-4 );
 // Check iterations
 iterations = neldermead_get(nm,"-iterations");
-assert_equal ( ( iterations > 40 ) , %t );
+assert_checkequal ( ( iterations > 40 ) , %t );
 // Check number of restarts
 restartnb = neldermead_get ( nm , "-restartnb" );
-assert_equal ( restartnb , 1 );
+assert_checkequal ( restartnb , 1 );
 nm = neldermead_destroy(nm);
 //
 // Test with auto-restart, Kelley stagnation detection and Kelley restart method
@@ -313,19 +278,19 @@ nm = neldermead_configure(nm,"-kelleystagnationalpha0",1.e-2);
 nm = neldermead_search(nm);
 // Check status
 status = neldermead_get(nm,"-status");
-assert_equal ( status , "tolsize" );
+assert_checkequal ( status , "tolsize" );
 // Check optimum point
 xopt = neldermead_get(nm,"-xopt");
-assert_close ( xopt , [0.0;-0.5], 1e-5 );
+assert_checkalmostequal ( xopt , [0.0;-0.5], 1e-5 );
 // Check optimum point value
 fopt = neldermead_get(nm,"-fopt");
-assert_close ( fopt , -0.25 , 1e-4 );
+assert_checkalmostequal ( fopt , -0.25 , 1e-4 );
 // Check iterations
 iterations = neldermead_get(nm,"-iterations");
-assert_equal ( ( iterations > 50 ) , %t );
+assert_checkequal ( ( iterations > 50 ) , %t );
 // Check number of restarts
 restartnb = neldermead_get ( nm , "-restartnb" );
-assert_equal ( restartnb , 1 );
+assert_checkequal ( restartnb , 1 );
 nm = neldermead_destroy(nm);
 //
 // Test with auto-restart, Kelley stagnation detection and Kelley restart method
@@ -351,19 +316,19 @@ nm = neldermead_configure(nm,"-kelleystagnationalpha0",1.e-2);
 nm = neldermead_search(nm);
 // Check status
 status = neldermead_get(nm,"-status");
-assert_equal ( status , "tolsize" );
+assert_checkequal ( status , "tolsize" );
 // Check optimum point
 xopt = neldermead_get(nm,"-xopt");
-assert_close ( xopt , [0.0;-0.5], 1e-4 );
+assert_checkalmostequal ( xopt , [0.0;-0.5], 1e-4 );
 // Check optimum point value
 fopt = neldermead_get(nm,"-fopt");
-assert_close ( fopt , -0.25 , 1e-4 );
+assert_checkalmostequal ( fopt , -0.25 , 1e-4 );
 // Check iterations
 iterations = neldermead_get(nm,"-iterations");
-assert_equal ( ( iterations > 50 ) , %t );
+assert_checkequal ( ( iterations > 50 ) , %t );
 // Check number of restarts
 restartnb = neldermead_get ( nm , "-restartnb" );
-assert_equal ( restartnb , 1 );
+assert_checkequal ( restartnb , 1 );
 nm = neldermead_destroy(nm);
 //
 // Test with auto-restart, Kelley stagnation detection and Kelley restart method
@@ -391,19 +356,19 @@ nm = neldermead_configure(nm,"-kelleystagnationalpha0",1.e-2);
 nm = neldermead_search(nm);
 // Check status
 status = neldermead_get(nm,"-status");
-assert_equal ( status , "maxrestart" );
+assert_checkequal ( status , "maxrestart" );
 // Check optimum point
 xopt = neldermead_get(nm,"-xopt");
-assert_close ( xopt , [0.0;-0.5], 1e-5 );
+assert_checkalmostequal ( xopt , [0.0;-0.5], 1e-5 );
 // Check optimum point value
 fopt = neldermead_get(nm,"-fopt");
-assert_close ( fopt , -0.25 , 1e-4 );
+assert_checkalmostequal ( fopt , -0.25 , 1e-4 );
 // Check iterations
 iterations = neldermead_get(nm,"-iterations");
-assert_equal ( ( iterations > 110 ) , %t );
+assert_checkequal ( ( iterations > 110 ) , %t );
 // Check number of restarts
 restartnb = neldermead_get ( nm , "-restartnb" );
-assert_equal ( restartnb , 3 );
+assert_checkequal ( restartnb , 3 );
 nm = neldermead_destroy(nm);
 //
 // Test with auto-restart, low precision on simplex size and O'Neill restart method.
@@ -431,11 +396,11 @@ matrix is close to singular or badly scaled. rcond =    6.6651D-13
 computing least squares solution. (see lsq).
 
 xopt = neldermead_get(nm,"-xopt");
-assert_close ( xopt , [0.0;-0.5], 1e-1 );
+assert_checkalmostequal ( xopt , [0.0;-0.5], 1e-1 );
 iterations = neldermead_get(nm,"-iterations");
-assert_equal ( ( iterations > 40 ) , %t );
+assert_checkequal ( ( iterations > 40 ) , %t );
 restartnb = neldermead_get ( nm , "-restartnb" );
-assert_equal ( restartnb , 1 );
+assert_checkequal ( restartnb , 1 );
 nm = neldermead_destroy(nm);
 //
 // Test with auto-restart, low precision on simplex size and O'Neill restart method.
@@ -463,11 +428,11 @@ matrix is close to singular or badly scaled. rcond =    6.6651D-13
 computing least squares solution. (see lsq).
 
 xopt = neldermead_get(nm,"-xopt");
-assert_close ( xopt , [0.0;-0.5], 1e-1 );
+assert_checkalmostequal ( xopt , [0.0;-0.5], 1e-1 );
 iterations = neldermead_get(nm,"-iterations");
-assert_equal ( ( iterations > 40 ) , %t );
+assert_checkequal ( ( iterations > 40 ) , %t );
 restartnb = neldermead_get ( nm , "-restartnb" );
-assert_equal ( restartnb , 1 );
+assert_checkequal ( restartnb , 1 );
 nm = neldermead_destroy(nm);
 //
 // Test with auto-restart, low precision on simplex size and O'Neill restart method.
@@ -495,9 +460,9 @@ matrix is close to singular or badly scaled. rcond =    6.6651D-13
 computing least squares solution. (see lsq).
 
 xopt = neldermead_get(nm,"-xopt");
-assert_close ( xopt , [0.0;-0.5], 1e-1 );
+assert_checkalmostequal ( xopt , [0.0;-0.5], 1e-1 );
 iterations = neldermead_get(nm,"-iterations");
-assert_equal ( ( iterations > 40 ) , %t );
+assert_checkequal ( ( iterations > 40 ) , %t );
 restartnb = neldermead_get ( nm , "-restartnb" );
-assert_equal ( restartnb , 1 );
+assert_checkequal ( restartnb , 1 );
 nm = neldermead_destroy(nm);
index 5c73de3..7e7f144 100644 (file)
@@ -1,5 +1,6 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008-2009 - INRIA - Michael Baudin
+// Copyright (C) 2011 - DIGITEO - Michael Baudin
 //
 // This file must be used under the terms of the CeCILL.
 // This source file is licensed as described in the file COPYING, which
 // The restart allows to compute a new simplex and makes the 
 // optimization converge toward the good point.
 
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
+
 
 //% MCKINNON computes the McKinnon function.
 //
@@ -164,13 +130,13 @@ nm = neldermead_search(nm);
 // but this is the expected result of the Nelder-Mead
 // algorithm.
 xopt = neldermead_get(nm,"-xopt");
-assert_close ( xopt , [0.0;0.0], 1e-6 );
+assert_checkalmostequal ( xopt , [0.0;0.0], 1e-6 );
 // Check optimum point value
 fopt = neldermead_get(nm,"-fopt");
-assert_close ( fopt , 0.0 , 1e-6 );
+assert_checkalmostequal ( fopt , 0.0 , 1e-6 );
 // Check status
 status = neldermead_get(nm,"-status");
-assert_equal ( status , "tolsize" );
+assert_checkequal ( status , "tolsize" );
 nm = neldermead_destroy(nm);
 
 //
@@ -192,16 +158,16 @@ nm = neldermead_search(nm);
 nm = neldermead_restart ( nm );
 // Check optimum point
 xopt = neldermead_get(nm,"-xopt");
-assert_close ( xopt , [0.0;-0.5], 1e-5 );
+assert_checkalmostequal ( xopt , [0.0;-0.5], 1e-5 );
 // Check optimum point value
 fopt = neldermead_get(nm,"-fopt");
-assert_close ( fopt , -0.25 , 1e-6 );
+assert_checkalmostequal ( fopt , -0.25 , 1e-6 );
 // Check status
 status = neldermead_get(nm,"-status");
-assert_equal ( status , "tolsize" );
+assert_checkequal ( status , "tolsize" );
 // Check iterations
 iterations = neldermead_get(nm,"-iterations");
-assert_equal ( iterations > 200 , %t );
+assert_checkequal ( iterations > 200 , %t );
 nm = neldermead_destroy(nm);
 
 //
@@ -222,7 +188,7 @@ nm = neldermead_configure(nm,"-kelleystagnationflag",%t);
 nm = neldermead_search(nm);
 // Check status
 status = neldermead_get(nm,"-status");
-assert_equal ( status , "kelleystagnation" );
+assert_checkequal ( status , "kelleystagnation" );
 nm = neldermead_destroy(nm);
 
 //
@@ -246,19 +212,19 @@ nm = neldermead_configure(nm,"-restartdetection","kelley");
 nm = neldermead_search(nm);
 // Check status
 status = neldermead_get(nm,"-status");
-assert_equal ( status , "maxrestart" );
+assert_checkequal ( status , "maxrestart" );
 // Check optimum point
 xopt = neldermead_get(nm,"-xopt");
-assert_close ( xopt , [0.0;-0.5], 1e-5 );
+assert_checkalmostequal ( xopt , [0.0;-0.5], 1e-5 );
 // Check optimum point value
 fopt = neldermead_get(nm,"-fopt");
-assert_close ( fopt , -0.25 , 1e-6 );
+assert_checkalmostequal ( fopt , -0.25 , 1e-6 );
 // Check iterations
 iterations = neldermead_get(nm,"-iterations");
-assert_equal ( ( iterations > 100 ) , %t );
+assert_checkequal ( ( iterations > 100 ) , %t );
 // Check number of restarts
 restartnb = neldermead_get ( nm , "-restartnb" );
-assert_equal ( restartnb , 3 );
+assert_checkequal ( restartnb , 3 );
 nm = neldermead_destroy(nm);
 
 //
@@ -282,19 +248,19 @@ nm = neldermead_configure(nm,"-restartdetection","oneill");
 nm = neldermead_search(nm);
 // Check status
 status = neldermead_get(nm,"-status");
-assert_equal ( status , "tolsize" );
+assert_checkequal ( status , "tolsize" );
 // Check optimum point
 xopt = neldermead_get(nm,"-xopt");
-assert_close ( xopt , [0.0;-0.5], 1e-1 );
+assert_checkalmostequal ( xopt , [0.0;-0.5], 1e-1 );
 // Check optimum point value
 fopt = neldermead_get(nm,"-fopt");
-assert_close ( fopt , -0.25 , 1e-4 );
+assert_checkalmostequal ( fopt , -0.25 , 1e-4 );
 // Check iterations
 iterations = neldermead_get(nm,"-iterations");
-assert_equal ( ( iterations > 40 ) , %t );
+assert_checkequal ( ( iterations > 40 ) , %t );
 // Check number of restarts
 restartnb = neldermead_get ( nm , "-restartnb" );
-assert_equal ( restartnb , 1 );
+assert_checkequal ( restartnb , 1 );
 nm = neldermead_destroy(nm);
 
 //
@@ -321,19 +287,19 @@ nm = neldermead_configure(nm,"-kelleystagnationalpha0",1.e-2);
 nm = neldermead_search(nm);
 // Check status
 status = neldermead_get(nm,"-status");
-assert_equal ( status , "tolsize" );
+assert_checkequal ( status , "tolsize" );
 // Check optimum point
 xopt = neldermead_get(nm,"-xopt");
-assert_close ( xopt , [0.0;-0.5], 1e-5 );
+assert_checkalmostequal ( xopt , [0.0;-0.5], 1e-5 );
 // Check optimum point value
 fopt = neldermead_get(nm,"-fopt");
-assert_close ( fopt , -0.25 , 1e-4 );
+assert_checkalmostequal ( fopt , -0.25 , 1e-4 );
 // Check iterations
 iterations = neldermead_get(nm,"-iterations");
-assert_equal ( ( iterations > 50 ) , %t );
+assert_checkequal ( ( iterations > 50 ) , %t );
 // Check number of restarts
 restartnb = neldermead_get ( nm , "-restartnb" );
-assert_equal ( restartnb , 1 );
+assert_checkequal ( restartnb , 1 );
 nm = neldermead_destroy(nm);
 
 //
@@ -360,19 +326,19 @@ nm = neldermead_configure(nm,"-kelleystagnationalpha0",1.e-2);
 nm = neldermead_search(nm);
 // Check status
 status = neldermead_get(nm,"-status");
-assert_equal ( status , "tolsize" );
+assert_checkequal ( status , "tolsize" );
 // Check optimum point
 xopt = neldermead_get(nm,"-xopt");
-assert_close ( xopt , [0.0;-0.5], 1e-4 );
+assert_checkalmostequal ( xopt , [0.0;-0.5], 1e-4 );
 // Check optimum point value
 fopt = neldermead_get(nm,"-fopt");
-assert_close ( fopt , -0.25 , 1e-4 );
+assert_checkalmostequal ( fopt , -0.25 , 1e-4 );
 // Check iterations
 iterations = neldermead_get(nm,"-iterations");
-assert_equal ( ( iterations > 50 ) , %t );
+assert_checkequal ( ( iterations > 50 ) , %t );
 // Check number of restarts
 restartnb = neldermead_get ( nm , "-restartnb" );
-assert_equal ( restartnb , 1 );
+assert_checkequal ( restartnb , 1 );
 nm = neldermead_destroy(nm);
 
 //
@@ -401,19 +367,19 @@ nm = neldermead_configure(nm,"-kelleystagnationalpha0",1.e-2);
 nm = neldermead_search(nm);
 // Check status
 status = neldermead_get(nm,"-status");
-assert_equal ( status , "maxrestart" );
+assert_checkequal ( status , "maxrestart" );
 // Check optimum point
 xopt = neldermead_get(nm,"-xopt");
-assert_close ( xopt , [0.0;-0.5], 1e-5 );
+assert_checkalmostequal ( xopt , [0.0;-0.5], 1e-5 );
 // Check optimum point value
 fopt = neldermead_get(nm,"-fopt");
-assert_close ( fopt , -0.25 , 1e-4 );
+assert_checkalmostequal ( fopt , -0.25 , 1e-4 );
 // Check iterations
 iterations = neldermead_get(nm,"-iterations");
-assert_equal ( ( iterations > 110 ) , %t );
+assert_checkequal ( ( iterations > 110 ) , %t );
 // Check number of restarts
 restartnb = neldermead_get ( nm , "-restartnb" );
-assert_equal ( restartnb , 3 );
+assert_checkequal ( restartnb , 3 );
 nm = neldermead_destroy(nm);
 
 //
@@ -438,11 +404,11 @@ nm = neldermead_configure(nm,"-restartdetection","oneill");
 nm = neldermead_configure(nm,"-restartstep", 0.5 );
 nm = neldermead_search(nm);
 xopt = neldermead_get(nm,"-xopt");
-assert_close ( xopt , [0.0;-0.5], 1e-1 );
+assert_checkalmostequal ( xopt , [0.0;-0.5], 1e-1 );
 iterations = neldermead_get(nm,"-iterations");
-assert_equal ( ( iterations > 40 ) , %t );
+assert_checkequal ( ( iterations > 40 ) , %t );
 restartnb = neldermead_get ( nm , "-restartnb" );
-assert_equal ( restartnb , 1 );
+assert_checkequal ( restartnb , 1 );
 nm = neldermead_destroy(nm);
 
 //
@@ -467,11 +433,11 @@ nm = neldermead_configure(nm,"-restartdetection","oneill");
 nm = neldermead_configure(nm,"-restartstep", [0.5 0.1]');
 nm = neldermead_search(nm);
 xopt = neldermead_get(nm,"-xopt");
-assert_close ( xopt , [0.0;-0.5], 1e-1 );
+assert_checkalmostequal ( xopt , [0.0;-0.5], 1e-1 );
 iterations = neldermead_get(nm,"-iterations");
-assert_equal ( ( iterations > 40 ) , %t );
+assert_checkequal ( ( iterations > 40 ) , %t );
 restartnb = neldermead_get ( nm , "-restartnb" );
-assert_equal ( restartnb , 1 );
+assert_checkequal ( restartnb , 1 );
 nm = neldermead_destroy(nm);
 
 //
@@ -496,11 +462,11 @@ nm = neldermead_configure(nm,"-restartdetection","oneill");
 nm = neldermead_configure(nm,"-restarteps", 0.1);
 nm = neldermead_search(nm);
 xopt = neldermead_get(nm,"-xopt");
-assert_close ( xopt , [0.0;-0.5], 1e-1 );
+assert_checkalmostequal ( xopt , [0.0;-0.5], 1e-1 );
 iterations = neldermead_get(nm,"-iterations");
-assert_equal ( ( iterations > 40 ) , %t );
+assert_checkequal ( ( iterations > 40 ) , %t );
 restartnb = neldermead_get ( nm , "-restartnb" );
-assert_equal ( restartnb , 1 );
+assert_checkequal ( restartnb , 1 );
 nm = neldermead_destroy(nm);
 
 
index 98e7c0f..021e26b 100644 (file)
@@ -1,47 +1,14 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008-2009 - INRIA - Michael Baudin
+// Copyright (C) 2011 - DIGITEO - Michael Baudin
 //
 // This file must be used under the terms of the CeCILL.
 // This source file is licensed as described in the file COPYING, which
 // you should have received as part of this distribution.  The terms
 // are also available at
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then bugmes();quit;end
-endfunction
+// <-- JVM NOT MANDATORY -->
+// <-- ENGLISH IMPOSED -->
 //
 //  Reference:
 //
@@ -401,11 +368,11 @@ nm = neldermead_configure(nm,"-mymethod",neldermead_constraints);
 nm = neldermead_search(nm);
 // Check optimum point
 xopt = neldermead_get(nm,"-xopt");
-assert_close ( xopt , [0.0 1.0 2.0 -1.0]', 1e-3 );
+assert_checkalmostequal ( xopt , [0.0 1.0 2.0 -1.0]', 1e-3 );
 // Check optimum point value
 fopt = neldermead_get(nm,"-fopt");
-assert_close ( fopt , -44.0 , 1e-5 );
+assert_checkalmostequal ( fopt , -44.0 , 1e-5 );
 // Check status
 status = neldermead_get(nm,"-status");
-assert_equal ( status , "tolsize" );
+assert_checkequal ( status , "tolsize" );
 nm = neldermead_destroy(nm);
index 3e5f9f6..54fdd74 100644 (file)
@@ -1,5 +1,6 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2008-2009 - INRIA - Michael Baudin
+// Copyright (C) 2011 - DIGITEO - Michael Baudin
 //
 // This file must be used under the terms of the CeCILL.
 // This source file is licensed as described in the file COPYING, which
 // <-- ENGLISH IMPOSED -->
 
 
-//
-// assert_close --
-//   Returns 1 if the two real matrices computed and expected are close,
-//   i.e. if the relative distance between computed and expected is lesser than epsilon.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_close ( computed, expected, epsilon )
-  if expected==0.0 then
-    shift = norm(computed-expected);
-  else
-    shift = norm(computed-expected)/norm(expected);
-  end
-  if shift < epsilon then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
-//
-// assert_equal --
-//   Returns 1 if the two real matrices computed and expected are equal.
-// Arguments
-//   computed, expected : the two matrices to compare
-//   epsilon : a small number
-//
-function flag = assert_equal ( computed , expected )
-  if computed==expected then
-    flag = 1;
-  else
-    flag = 0;
-  end
-  if flag <> 1 then pause,end
-endfunction
+
 
 //
 //  Reference: