numo-liblinear 1.2.2 → 2.1.1

data/ext/numo/liblinear/{liblinear → src}/linear.cpp

@@ -56,7 +56,7 @@ public:
 			ret += x->value*x->value;
 			x++;
 		}
-		return (ret);
+		return ret;
 	}
 
 	static double dot(const double *s, const feature_node *x)
@@ -67,7 +67,7 @@ public:
 			ret += s[x->index-1]*x->value;
 			x++;
 		}
-		return (ret);
+		return ret;
 	}
 
 	static double sparse_dot(const feature_node *x1, const feature_node *x2)
@@ -89,7 +89,7 @@ public:
 					++x1;
 			}
 		}
-		return (ret);
+		return ret;
 	}
 
 	static void axpy(const double a, const feature_node *x, double *y)
@@ -164,7 +164,7 @@ double l2r_erm_fun::fun(double *w)
 		f += C_times_loss(i, wx[i]);
 	f = f + 0.5 * wTw;
 
-	return(f);
+	return f;
 }
 
 int l2r_erm_fun::get_nr_variable(void)
@@ -876,13 +876,13 @@ void Solver_MCSVM_CS::Solve(double *w)
 //  D is a diagonal matrix
 //
 // In L1-SVM case:
-// 		upper_bound_i = Cp if y_i = 1
-// 		upper_bound_i = Cn if y_i = -1
-// 		D_ii = 0
+//              upper_bound_i = Cp if y_i = 1
+//              upper_bound_i = Cn if y_i = -1
+//              D_ii = 0
 // In L2-SVM case:
-// 		upper_bound_i = INF
-// 		D_ii = 1/(2*Cp)	if y_i = 1
-// 		D_ii = 1/(2*Cn)	if y_i = -1
+//              upper_bound_i = INF
+//              D_ii = 1/(2*Cp) if y_i = 1
+//              D_ii = 1/(2*Cn) if y_i = -1
 //
 // Given:
 // x, y, Cp, Cn
@@ -890,22 +890,23 @@ void Solver_MCSVM_CS::Solve(double *w)
 //
 // solution will be put in w
 //
+// this function returns the number of iterations
+//
 // See Algorithm 3 of Hsieh et al., ICML 2008
 
 #undef GETI
 #define GETI(i) (y[i]+1)
 // To support weights for instances, use GETI(i) (i)
 
-static void solve_l2r_l1l2_svc(
-	const problem *prob, double *w, double eps,
-	double Cp, double Cn, int solver_type)
+static int solve_l2r_l1l2_svc(const problem *prob, const parameter *param, double *w, double Cp, double Cn, int max_iter=300)
 {
 	int l = prob->l;
 	int w_size = prob->n;
+	double eps = param->eps;
+	int solver_type = param->solver_type;
 	int i, s, iter = 0;
 	double C, d, G;
 	double *QD = new double[l];
-	int max_iter = 1000;
 	int *index = new int[l];
 	double *alpha = new double[l];
 	schar *y = new schar[l];
@@ -1024,7 +1025,8 @@ static void solve_l2r_l1l2_svc(
 		if(iter % 10 == 0)
 			info(".");
 
-		if(PGmax_new - PGmin_new <= eps)
+		if(PGmax_new - PGmin_new <= eps &&
+			fabs(PGmax_new) <= eps && fabs(PGmin_new) <= eps)
 		{
 			if(active_size == l)
 				break;
@@ -1046,8 +1048,6 @@ static void solve_l2r_l1l2_svc(
 	}
 
 	info("\noptimization finished, #iter = %d\n",iter);
-	if (iter >= max_iter)
-		info("\nWARNING: reaching max number of iterations\nUsing -s 2 may be faster (also see FAQ)\n\n");
 
 	// calculate objective value
 
@@ -1068,6 +1068,8 @@ static void solve_l2r_l1l2_svc(
 	delete [] alpha;
 	delete [] y;
 	delete [] index;
+
+	return iter;
 }
 
 
@@ -1081,11 +1083,11 @@ static void solve_l2r_l1l2_svc(
 //  D is a diagonal matrix
 //
 // In L1-SVM case:
-// 		upper_bound_i = C
-// 		lambda_i = 0
+//              upper_bound_i = C
+//              lambda_i = 0
 // In L2-SVM case:
-// 		upper_bound_i = INF
-// 		lambda_i = 1/(2*C)
+//              upper_bound_i = INF
+//              lambda_i = 1/(2*C)
 //
 // Given:
 // x, y, p, C
@@ -1093,23 +1095,23 @@ static void solve_l2r_l1l2_svc(
 //
 // solution will be put in w
 //
+// this function returns the number of iterations
+//
 // See Algorithm 4 of Ho and Lin, 2012
 
 #undef GETI
 #define GETI(i) (0)
 // To support weights for instances, use GETI(i) (i)
 
-static void solve_l2r_l1l2_svr(
-	const problem *prob, double *w, const parameter *param,
-	int solver_type)
+static int solve_l2r_l1l2_svr(const problem *prob, const parameter *param, double *w, int max_iter=300)
 {
+	const int solver_type = param->solver_type;
 	int l = prob->l;
 	double C = param->C;
 	double p = param->p;
 	int w_size = prob->n;
 	double eps = param->eps;
 	int i, s, iter = 0;
-	int max_iter = 1000;
 	int active_size = l;
 	int *index = new int[l];
 
@@ -1260,8 +1262,6 @@ static void solve_l2r_l1l2_svr(
 	}
 
 	info("\noptimization finished, #iter = %d\n", iter);
-	if(iter >= max_iter)
-		info("\nWARNING: reaching max number of iterations\nUsing -s 11 may be faster\n\n");
 
 	// calculate objective value
 	double v = 0;
@@ -1282,6 +1282,8 @@ static void solve_l2r_l1l2_svr(
 	delete [] beta;
 	delete [] QD;
 	delete [] index;
+
+	return iter;
 }
 
 
@@ -1301,19 +1303,21 @@ static void solve_l2r_l1l2_svr(
 //
 // solution will be put in w
 //
+// this function returns the number of iterations
+//
 // See Algorithm 5 of Yu et al., MLJ 2010
 
 #undef GETI
 #define GETI(i) (y[i]+1)
 // To support weights for instances, use GETI(i) (i)
 
-void solve_l2r_lr_dual(const problem *prob, double *w, double eps, double Cp, double Cn)
+static int solve_l2r_lr_dual(const problem *prob, const parameter *param, double *w, double Cp, double Cn, int max_iter=300)
 {
 	int l = prob->l;
 	int w_size = prob->n;
+	double eps = param->eps;
 	int i, s, iter = 0;
 	double *xTx = new double[l];
-	int max_iter = 1000;
 	int *index = new int[l];
 	double *alpha = new double[2*l]; // store alpha and C - alpha
 	schar *y = new schar[l];
@@ -1428,8 +1432,6 @@ void solve_l2r_lr_dual(const problem *prob, double *w, double eps, double Cp, do
 	}
 
 	info("\noptimization finished, #iter = %d\n",iter);
-	if (iter >= max_iter)
-		info("\nWARNING: reaching max number of iterations\nUsing -s 0 may be faster (also see FAQ)\n\n");
 
 	// calculate objective value
 
@@ -1446,6 +1448,8 @@ void solve_l2r_lr_dual(const problem *prob, double *w, double eps, double Cp, do
 	delete [] alpha;
 	delete [] y;
 	delete [] index;
+
+	return iter;
 }
 
 // A coordinate descent algorithm for
@@ -1459,6 +1463,8 @@ void solve_l2r_lr_dual(const problem *prob, double *w, double eps, double Cp, do
 //
 // solution will be put in w
 //
+// this function returns the number of iterations
+//
 // See Yuan et al. (2010) and appendix of LIBLINEAR paper, Fan et al. (2008)
 //
 // To not regularize the bias (i.e., regularize_bias = 0), a constant feature = 1
@@ -1468,12 +1474,11 @@ void solve_l2r_lr_dual(const problem *prob, double *w, double eps, double Cp, do
 #define GETI(i) (y[i]+1)
 // To support weights for instances, use GETI(i) (i)
 
-static void solve_l1r_l2_svc(
-	problem *prob_col, double *w, double eps,
-	double Cp, double Cn, int regularize_bias)
+static int solve_l1r_l2_svc(const problem *prob_col, const parameter* param, double *w, double Cp, double Cn, double eps)
 {
 	int l = prob_col->l;
 	int w_size = prob_col->n;
+	int regularize_bias = param->regularize_bias;
 	int j, s, iter = 0;
 	int max_iter = 1000;
 	int active_size = w_size;
@@ -1747,6 +1752,8 @@ static void solve_l1r_l2_svc(
 	delete [] y;
 	delete [] b;
 	delete [] xj_sq;
+
+	return iter;
 }
 
 // A coordinate descent algorithm for
@@ -1760,6 +1767,8 @@ static void solve_l1r_l2_svc(
 //
 // solution will be put in w
 //
+// this function returns the number of iterations
+//
 // See Yuan et al. (2011) and appendix of LIBLINEAR paper, Fan et al. (2008)
 //
 // To not regularize the bias (i.e., regularize_bias = 0), a constant feature = 1
@@ -1769,12 +1778,11 @@ static void solve_l1r_l2_svc(
 #define GETI(i) (y[i]+1)
 // To support weights for instances, use GETI(i) (i)
 
-static void solve_l1r_lr(
-	const problem *prob_col, double *w, double eps,
-	double Cp, double Cn, int regularize_bias)
+static int solve_l1r_lr(const problem *prob_col, const parameter *param, double *w, double Cp, double Cn, double eps)
 {
 	int l = prob_col->l;
 	int w_size = prob_col->n;
+	int regularize_bias = param->regularize_bias;
 	int j, s, newton_iter=0, iter=0;
 	int max_newton_iter = 100;
 	int max_iter = 1000;
@@ -2143,6 +2151,8 @@ static void solve_l1r_lr(
 	delete [] exp_wTx_new;
 	delete [] tau;
 	delete [] D;
+
+	return newton_iter;
 }
 
 struct heap {
@@ -2230,12 +2240,16 @@ struct heap {
 //
 // solution will be put in w and rho
 //
+// this function returns the number of iterations
+//
 // See Algorithm 7 in supplementary materials of Chou et al., SDM 2020.
 
-static void solve_oneclass_svm(const problem *prob, double *w, double *rho, double eps, double nu)
+static int solve_oneclass_svm(const problem *prob, const parameter *param, double *w, double *rho)
 {
 	int l = prob->l;
 	int w_size = prob->n;
+	double eps = param->eps;
+	double nu = param->nu;
 	int i, j, s, iter = 0;
 	double Gi, Gj;
 	double Qij, quad_coef, delta, sum;
@@ -2248,13 +2262,13 @@ static void solve_oneclass_svm(const problem *prob, double *w, double *rho, doub
 	int max_iter = 1000;
 	int active_size = l;
 
-	double negGmax;			// max { -grad(f)_i | alpha_i < 1 }
-	double negGmin;			// min { -grad(f)_i | alpha_i > 0 }
+	double negGmax;                 // max { -grad(f)_i | alpha_i < 1 }
+	double negGmin;                 // min { -grad(f)_i | alpha_i > 0 }
 
 	int *most_violating_i = new int[l];
 	int *most_violating_j = new int[l];
 
-	int n = (int)(nu*l);		// # of alpha's at upper bound
+	int n = (int)(nu*l);            // # of alpha's at upper bound
 	for(i=0; i<n; i++)
 		alpha[i] = 1;
 	if (n<l)
@@ -2479,6 +2493,8 @@ static void solve_oneclass_svm(const problem *prob, double *w, double *rho, doub
 	delete [] alpha;
 	delete [] most_violating_i;
 	delete [] most_violating_j;
+
+	return iter;
 }
 
 // transpose matrix X from row format to column format
@@ -2616,67 +2632,85 @@ static void group_classes(const problem *prob, int *nr_class_ret, int **label_re
 
 static void train_one(const problem *prob, const parameter *param, double *w, double Cp, double Cn)
 {
-	double eps = param->eps;
+	int solver_type = param->solver_type;
+	int dual_solver_max_iter = 300;
+	int iter;
 
-	int pos = 0;
-	int neg = 0;
-	for(int i=0;i<prob->l;i++)
-		if(prob->y[i] > 0)
-			pos++;
-	neg = prob->l - pos;
-	double primal_solver_tol = eps*max(min(pos,neg), 1)/prob->l;
+	bool is_regression = (solver_type==L2R_L2LOSS_SVR ||
+				solver_type==L2R_L1LOSS_SVR_DUAL ||
+				solver_type==L2R_L2LOSS_SVR_DUAL);
 
-	function *fun_obj=NULL;
-	switch(param->solver_type)
+	// Some solvers use Cp,Cn but not C array; extensions possible but no plan for now
+	double *C = new double[prob->l];
+	double primal_solver_tol = param->eps;
+	if(is_regression)
 	{
-		case L2R_LR:
+		for(int i=0;i<prob->l;i++)
+			C[i] = param->C;
+	}
+	else
+	{
+		int pos = 0;
+		for(int i=0;i<prob->l;i++)
 		{
-			double *C = new double[prob->l];
-			for(int i = 0; i < prob->l; i++)
+			if(prob->y[i] > 0)
 			{
-				if(prob->y[i] > 0)
-					C[i] = Cp;
-				else
-					C[i] = Cn;
+				pos++;
+				C[i] = Cp;
 			}
-			fun_obj=new l2r_lr_fun(prob, param, C);
-			NEWTON newton_obj(fun_obj, primal_solver_tol);
+			else
+				C[i] = Cn;
+		}
+		int neg = prob->l - pos;
+		primal_solver_tol = param->eps*max(min(pos,neg), 1)/prob->l;
+	}
+
+	switch(solver_type)
+	{
+		case L2R_LR:
+		{
+			l2r_lr_fun fun_obj(prob, param, C);
+			NEWTON newton_obj(&fun_obj, primal_solver_tol);
 			newton_obj.set_print_string(liblinear_print_string);
 			newton_obj.newton(w);
-			delete fun_obj;
-			delete[] C;
 			break;
 		}
 		case L2R_L2LOSS_SVC:
 		{
-			double *C = new double[prob->l];
-			for(int i = 0; i < prob->l; i++)
-			{
-				if(prob->y[i] > 0)
-					C[i] = Cp;
-				else
-					C[i] = Cn;
-			}
-			fun_obj=new l2r_l2_svc_fun(prob, param, C);
-			NEWTON newton_obj(fun_obj, primal_solver_tol);
+			l2r_l2_svc_fun fun_obj(prob, param, C);
+			NEWTON newton_obj(&fun_obj, primal_solver_tol);
 			newton_obj.set_print_string(liblinear_print_string);
 			newton_obj.newton(w);
-			delete fun_obj;
-			delete[] C;
 			break;
 		}
 		case L2R_L2LOSS_SVC_DUAL:
-			solve_l2r_l1l2_svc(prob, w, eps, Cp, Cn, L2R_L2LOSS_SVC_DUAL);
+		{
+			iter = solve_l2r_l1l2_svc(prob, param, w, Cp, Cn, dual_solver_max_iter);
+			if(iter >= dual_solver_max_iter)
+			{
+				info("\nWARNING: reaching max number of iterations\nSwitching to use -s 2\n\n");
+				// primal_solver_tol obtained from eps for dual may be too loose
+				primal_solver_tol *= 0.1;
+				l2r_l2_svc_fun fun_obj(prob, param, C);
+				NEWTON newton_obj(&fun_obj, primal_solver_tol);
+				newton_obj.set_print_string(liblinear_print_string);
+				newton_obj.newton(w);
+			}
 			break;
+		}
 		case L2R_L1LOSS_SVC_DUAL:
-			solve_l2r_l1l2_svc(prob, w, eps, Cp, Cn, L2R_L1LOSS_SVC_DUAL);
+		{
+			iter = solve_l2r_l1l2_svc(prob, param, w, Cp, Cn, dual_solver_max_iter);
+			if(iter >= dual_solver_max_iter)
+				info("\nWARNING: reaching max number of iterations\nUsing -s 2 may be faster (also see FAQ)\n\n");			
 			break;
+		}
 		case L1R_L2LOSS_SVC:
 		{
 			problem prob_col;
 			feature_node *x_space = NULL;
 			transpose(prob, &x_space ,&prob_col);
-			solve_l1r_l2_svc(&prob_col, w, primal_solver_tol, Cp, Cn, param->regularize_bias);
+			solve_l1r_l2_svc(&prob_col, param, w, Cp, Cn, primal_solver_tol);
 			delete [] prob_col.y;
 			delete [] prob_col.x;
 			delete [] x_space;
@@ -2687,40 +2721,64 @@ static void train_one(const problem *prob, const parameter *param, double *w, do
 			problem prob_col;
 			feature_node *x_space = NULL;
 			transpose(prob, &x_space ,&prob_col);
-			solve_l1r_lr(&prob_col, w, primal_solver_tol, Cp, Cn, param->regularize_bias);
+			solve_l1r_lr(&prob_col, param, w, Cp, Cn, primal_solver_tol);
 			delete [] prob_col.y;
 			delete [] prob_col.x;
 			delete [] x_space;
 			break;
 		}
 		case L2R_LR_DUAL:
-			solve_l2r_lr_dual(prob, w, eps, Cp, Cn);
+		{
+			iter = solve_l2r_lr_dual(prob, param, w, Cp, Cn, dual_solver_max_iter);
+			if(iter >= dual_solver_max_iter)
+			{
+				info("\nWARNING: reaching max number of iterations\nSwitching to use -s 0\n\n");
+				// primal_solver_tol obtained from eps for dual may be too loose
+				primal_solver_tol *= 0.1;
+				l2r_lr_fun fun_obj(prob, param, C);
+				NEWTON newton_obj(&fun_obj, primal_solver_tol);
+				newton_obj.set_print_string(liblinear_print_string);
+				newton_obj.newton(w);
+			}
 			break;
+		}
 		case L2R_L2LOSS_SVR:
 		{
-			double *C = new double[prob->l];
-			for(int i = 0; i < prob->l; i++)
-				C[i] = param->C;
-
-			fun_obj=new l2r_l2_svr_fun(prob, param, C);
-			NEWTON newton_obj(fun_obj, param->eps);
+			l2r_l2_svr_fun fun_obj(prob, param, C);
+			NEWTON newton_obj(&fun_obj, primal_solver_tol);
 			newton_obj.set_print_string(liblinear_print_string);
 			newton_obj.newton(w);
-			delete fun_obj;
-			delete[] C;
 			break;
-
 		}
 		case L2R_L1LOSS_SVR_DUAL:
-			solve_l2r_l1l2_svr(prob, w, param, L2R_L1LOSS_SVR_DUAL);
+		{
+			iter = solve_l2r_l1l2_svr(prob, param, w, dual_solver_max_iter);
+			if(iter >= dual_solver_max_iter)
+				info("\nWARNING: reaching max number of iterations\nUsing -s 11 may be faster (also see FAQ)\n\n");			
+
 			break;
+		}
 		case L2R_L2LOSS_SVR_DUAL:
-			solve_l2r_l1l2_svr(prob, w, param, L2R_L2LOSS_SVR_DUAL);
+		{
+			iter = solve_l2r_l1l2_svr(prob, param, w, dual_solver_max_iter);
+			if(iter >= dual_solver_max_iter)
+			{
+				info("\nWARNING: reaching max number of iterations\nSwitching to use -s 11\n\n");
+				// primal_solver_tol obtained from eps for dual may be too loose
+				primal_solver_tol *= 0.001;
+				l2r_l2_svr_fun fun_obj(prob, param, C);
+				NEWTON newton_obj(&fun_obj, primal_solver_tol);
+				newton_obj.set_print_string(liblinear_print_string);
+				newton_obj.newton(w);
+			}
 			break;
+		}
 		default:
 			fprintf(stderr, "ERROR: unknown solver_type\n");
 			break;
 	}
+
+	delete[] C;
 }
 
 // Calculate the initial C for parameter selection
@@ -2768,7 +2826,7 @@ static double calc_start_C(const problem *prob, const parameter *param)
 	return pow( 2, floor(log(min_C) / log(2.0)) );
 }
 
-static double calc_max_p(const problem *prob, const parameter *param)
+static double calc_max_p(const problem *prob)
 {
 	int i;
 	double max_p = 0.0;
@@ -2938,7 +2996,7 @@ model* train(const problem *prob, const parameter *param)
 		model_->w = Malloc(double, w_size);
 		model_->nr_class = 2;
 		model_->label = NULL;
-		solve_oneclass_svm(prob, model_->w, &(model_->rho), param->eps, param->nu);
+		solve_oneclass_svm(prob, param, model_->w, &(model_->rho));
 	}
 	else
 	{
@@ -3173,7 +3231,6 @@ void find_parameters(const problem *prob, const parameter *param, int nr_fold, d
 			subprob[i].y[k] = prob->y[perm[j]];
 			++k;
 		}
-
 	}
 
 	struct parameter param_tmp = *param;
@@ -3193,7 +3250,7 @@ void find_parameters(const problem *prob, const parameter *param, int nr_fold, d
 	}
 	else if(param->solver_type == L2R_L2LOSS_SVR)
 	{
-		double max_p = calc_max_p(prob, &param_tmp);
+		double max_p = calc_max_p(prob);
 		int num_p_steps = 20;
 		double max_C = 1048576;
 		*best_score = INF;
@@ -3655,7 +3712,7 @@ const char *check_parameter(const problem *prob, const parameter *param)
 	if(param->C <= 0)
 		return "C <= 0";
 
-	if(param->p < 0)
+	if(param->p < 0 && param->solver_type == L2R_L2LOSS_SVR)
 		return "p < 0";
 
 	if(prob->bias >= 0 && param->solver_type == ONECLASS_SVM)

data/ext/numo/liblinear/{liblinear → src}/linear.h

@@ -1,7 +1,7 @@
 #ifndef _LIBLINEAR_H
 #define _LIBLINEAR_H
 
-#define LIBLINEAR_VERSION 241
+#define LIBLINEAR_VERSION 244
 
 #ifdef __cplusplus
 extern "C" {
@@ -30,7 +30,7 @@ struct parameter
 	int solver_type;
 
 	/* these are for training only */
-	double eps;	        /* stopping criteria */
+	double eps;             /* stopping tolerance */
 	double C;
 	int nr_weight;
 	int *weight_label;
@@ -44,12 +44,12 @@ struct parameter
 struct model
 {
 	struct parameter param;
-	int nr_class;		/* number of classes */
+	int nr_class;           /* number of classes */
 	int nr_feature;
 	double *w;
-	int *label;		/* label of each class */
+	int *label;             /* label of each class */
 	double bias;
-	double rho;		/* one-class SVM only */
+	double rho;             /* one-class SVM only */
 };
 
 struct model* train(const struct problem *prob, const struct parameter *param);

data/ext/numo/liblinear/{liblinear → src}/newton.cpp

@@ -117,14 +117,13 @@ void NEWTON::newton(double *w)
 	delete [] w0;
 
 	f = fun_obj->fun(w);
-	info("init f %5.3e\n", f);
 	fun_obj->grad(w, g);
 	double gnorm = dnrm2_(&n, g, &inc);
+	info("init f %5.3e |g| %5.3e\n", f, gnorm);
 
 	if (gnorm <= eps*gnorm0)
 		search = 0;
 
-	double *w_new = new double[n];
 	while (iter <= max_iter && search)
 	{
 		fun_obj->get_diag_preconditioner(M);
@@ -133,7 +132,7 @@ void NEWTON::newton(double *w)
 		cg_iter = pcg(g, M, s, r);
 
 		fold = f;
-		step_size = fun_obj->linesearch_and_update(w, s, & f, g, init_step_size);
+		step_size = fun_obj->linesearch_and_update(w, s, &f, g, init_step_size);
 
 		if (step_size == 0)
 		{
@@ -141,14 +140,11 @@ void NEWTON::newton(double *w)
 			break;
 		}
 
-		info("iter %2d f %5.3e |g| %5.3e CG %3d step_size %4.2e \n", iter, f, gnorm, cg_iter, step_size);
-
-		actred = fold - f;
-		iter++;
-
 		fun_obj->grad(w, g);
-
 		gnorm = dnrm2_(&n, g, &inc);
+
+		info("iter %2d f %5.3e |g| %5.3e CG %3d step_size %4.2e \n", iter, f, gnorm, cg_iter, step_size);
+		
 		if (gnorm <= eps*gnorm0)
 			break;
 		if (f < -1.0e+32)
@@ -156,16 +152,21 @@ void NEWTON::newton(double *w)
 			info("WARNING: f < -1.0e+32\n");
 			break;
 		}
+		actred = fold - f;
 		if (fabs(actred) <= 1.0e-12*fabs(f))
 		{
 			info("WARNING: actred too small\n");
 			break;
 		}
+
+		iter++;
 	}
 
+	if(iter >= max_iter)
+		info("\nWARNING: reaching max number of Newton iterations\n");
+
 	delete[] g;
 	delete[] r;
-	delete[] w_new;
 	delete[] s;
 	delete[] M;
 }
@@ -177,7 +178,7 @@ int NEWTON::pcg(double *g, double *M, double *s, double *r)
 	double one = 1;
 	double *d = new double[n];
 	double *Hd = new double[n];
-	double zTr, znewTrnew, alpha, beta, cgtol;
+	double zTr, znewTrnew, alpha, beta, cgtol, dHd;
 	double *z = new double[n];
 	double Q = 0, newQ, Qdiff;
 
@@ -198,9 +199,14 @@ int NEWTON::pcg(double *g, double *M, double *s, double *r)
 	while (cg_iter < max_cg_iter)
 	{
 		cg_iter++;
-		fun_obj->Hv(d, Hd);
 
-		alpha = zTr/ddot_(&n, d, &inc, Hd, &inc);
+		fun_obj->Hv(d, Hd);
+		dHd = ddot_(&n, d, &inc, Hd, &inc);
+		// avoid 0/0 in getting alpha
+		if (dHd <= 1.0e-16)
+			break;
+		
+		alpha = zTr/dHd;
 		daxpy_(&n, &alpha, d, &inc, s, &inc);
 		alpha = -alpha;
 		daxpy_(&n, &alpha, Hd, &inc, r, &inc);
@@ -236,7 +242,7 @@ int NEWTON::pcg(double *g, double *M, double *s, double *r)
 	delete[] Hd;
 	delete[] z;
 
-	return(cg_iter);
+	return cg_iter;
 }
 
 void NEWTON::set_print_string(void (*print_string) (const char *buf))

data/lib/numo/liblinear/version.rb

@@ -3,6 +3,6 @@
 module Numo
   module Liblinear
     # The version of Numo::Liblienar you are using.
-    VERSION = '1.2.2'
+    VERSION = '2.1.1'
   end
 end