1. 调用doc
public class Libsvm {
static Libsvm libsvm;
private Libsvm() {
}
public static Libsvm getInstance() {
if (libsvm == null) {
libsvm = new Libsvm();
}
return libsvm;
}
public void train(String trainFile, String modelFile) {
String trainCmd = "d:/libsvm-3.17/windows/svm-train -t 0 -b 1 " + trainFile + " " + modelFile;
try {
Runtime.getRuntime().exec(trainCmd);
Thread.sleep(15000);
} catch (Exception e) {
e.printStackTrace();
}
}
public void predict(String predictFile, String modelFile, String ouputFile) {
String predictCmd = "d:/libsvm-3.17/windows/svm-predict -b 1 " + predictFile + " " + modelFile
+ " " + ouputFile;
try {
Runtime.getRuntime().exec(predictCmd);
Thread.sleep(500);
} catch (Exception e) {
e.printStackTrace();
}
}
}
java源码应用
训练
public void libsvm_train(String options, String trainfile, String modelfile) {
String[] args = { options, trainfile, modelfile};
Svm_train.main(args);
}预测
public void libsvm_predict(String predict, String model, String outfile ) {
String[] args = { predict, model, outfile };
Svm_predict.main(args);
}Svm_predict.java
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.util.StringTokenizer;
import libsvm.svm;
import libsvm.svm_model;
import libsvm.svm_node;
import libsvm.svm_parameter;
import libsvm.svm_print_interface;
public class Svm_predict {
private static svm_print_interface svm_print_null = new svm_print_interface() {
public void print(String s) {
}
};
private static svm_print_interface svm_print_stdout = new svm_print_interface() {
public void print(String s) {
System.out.print(s);
}
};
private static svm_print_interface svm_print_string = svm_print_stdout;
static void info(String s) {
svm_print_string.print(s);
}
private static double atof(String s) {
return Double.valueOf(s).doubleValue();
}
private static int atoi(String s) {
return Integer.parseInt(s);
}
private static void predict(BufferedReader input, DataOutputStream output,
svm_model model, int predict_probability) throws IOException {
int correct = 0;
int total = 0;
double error = 0;
double sumv = 0, sumy = 0, sumvv = 0, sumyy = 0, sumvy = 0;
int svm_type = svm.svm_get_svm_type(model);
int nr_class = svm.svm_get_nr_class(model);
double[] prob_estimates = null;
if (predict_probability == 1) {
if (svm_type == svm_parameter.EPSILON_SVR
|| svm_type == svm_parameter.NU_SVR) {
Svm_predict
.info("Prob. model for test data: target value = predicted value + z,\nz: Laplace distribution e^(-|z|/sigma)/(2sigma),sigma="
+ svm.svm_get_svr_probability(model) + "\n");
} else {
int[] labels = new int[nr_class];
svm.svm_get_labels(model, labels);
prob_estimates = new double[nr_class];
output.writeBytes("labels");
for (int j = 0; j < nr_class; j++)
output.writeBytes(" " + labels[j]);
output.writeBytes("\n");
}
}
while (true) {
String line = input.readLine();
if (line == null)
break;
StringTokenizer st = new StringTokenizer(line, " \t\n\r\f:");
double target = atof(st.nextToken());
int m = st.countTokens() / 2;
svm_node[] x = new svm_node[m];
for (int j = 0; j < m; j++) {
x[j] = new svm_node();
x[j].index = atoi(st.nextToken());
x[j].value = atof(st.nextToken());
}
double v;
if (predict_probability == 1
&& (svm_type == svm_parameter.C_SVC || svm_type == svm_parameter.NU_SVC)) {
v = svm.svm_predict_probability(model, x, prob_estimates);
output.writeBytes(v + " ");
for (int j = 0; j < nr_class; j++)
output.writeBytes(prob_estimates[j] + " ");
output.writeBytes("\n");
} else {
v = svm.svm_predict(model, x);
output.writeBytes(v + "\n");
}
if (v == target)
++correct;
error += (v - target) * (v - target);
sumv += v;
sumy += target;
sumvv += v * v;
sumyy += target * target;
sumvy += v * target;
++total;
}
if (svm_type == svm_parameter.EPSILON_SVR
|| svm_type == svm_parameter.NU_SVR) {
Svm_predict.info("Mean squared error = " + error / total
+ " (regression)\n");
Svm_predict.info("Squared correlation coefficient = "
+ ((total * sumvy - sumv * sumy) * (total * sumvy - sumv
* sumy))
/ ((total * sumvv - sumv * sumv) * (total * sumyy - sumy
* sumy)) + " (regression)\n");
} else
Svm_predict.info("Accuracy = " + (double) correct / total * 100
+ "% (" + correct + "/" + total + ") (classification)\n");
}
private static void exit_with_help() {
System.err
.print("usage: svm_predict [options] test_file model_file output_file\n"
+ "options:\n"
+ "-b probability_estimates: whether to predict probability estimates, 0 or 1 (default 0); one-class SVM not supported yet\n"
+ "-q : quiet mode (no outputs)\n");
System.exit(1);
}
public static void main(String argv[]) throws IOException {
int i, predict_probability = 1; //测试时开启label概率计算
svm_print_string = svm_print_stdout;
// parse options
for (i = 0; i < argv.length; i++) {
if (argv[i].charAt(0) != '-')
break;
++i;
switch (argv[i - 1].charAt(1)) {
case 'b':
predict_probability = atoi(argv[i]);
break;
case 'q':
svm_print_string = svm_print_null;
i--;
break;
default:
System.err.print("Unknown option: " + argv[i - 1] + "\n");
exit_with_help();
}
}
if (i >= argv.length - 2)
exit_with_help();
try {
BufferedReader input = new BufferedReader(new FileReader(argv[i]));
DataOutputStream output = new DataOutputStream(
new BufferedOutputStream(new FileOutputStream(argv[i + 2])));
svm_model model = svm.svm_load_model(argv[i + 1]);
if (predict_probability == 1) {
if (svm.svm_check_probability_model(model) == 0) {
System.err
.print("Model does not support probabiliy estimates\n");
System.exit(1);
}
} else {
if (svm.svm_check_probability_model(model) != 0) {
Svm_predict
.info("Model supports probability estimates, but disabled in prediction.\n");
}
}
predict(input, output, model, predict_probability);
input.close();
output.close();
} catch (FileNotFoundException e) {
exit_with_help();
} catch (ArrayIndexOutOfBoundsException e) {
exit_with_help();
}
}
}
Svm_scale.java
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Formatter;
import java.util.StringTokenizer;
class Svm_scale {
private String line = null;
private double lower = -1.0;
private double upper = 1.0;
private double y_lower;
private double y_upper;
private boolean y_scaling = false;
private double[] feature_max;
private double[] feature_min;
private double y_max = -Double.MAX_VALUE;
private double y_min = Double.MAX_VALUE;
private int max_index;
private long num_nonzeros = 0;
private long new_num_nonzeros = 0;
private static void exit_with_help() {
System.out
.print("Usage: svm-scale [options] data_filename\n"
+ "options:\n"
+ "-l lower : x scaling lower limit (default -1)\n"
+ "-u upper : x scaling upper limit (default +1)\n"
+ "-y y_lower y_upper : y scaling limits (default: no y scaling)\n"
+ "-s save_filename : save scaling parameters to save_filename\n"
+ "-r restore_filename : restore scaling parameters from restore_filename\n");
System.exit(1);
}
private BufferedReader rewind(BufferedReader fp, String filename)
throws IOException {
fp.close();
return new BufferedReader(new FileReader(filename));
}
private void output_target(double value) {
if (y_scaling) {
if (value == y_min)
value = y_lower;
else if (value == y_max)
value = y_upper;
else
value = y_lower + (y_upper - y_lower) * (value - y_min)
/ (y_max - y_min);
}
System.out.print(value + " ");
}
private void output(int index, double value) {
/* skip single-valued attribute */
if (feature_max[index] == feature_min[index])
return;
if (value == feature_min[index])
value = lower;
else if (value == feature_max[index])
value = upper;
else
value = lower + (upper - lower) * (value - feature_min[index])
/ (feature_max[index] - feature_min[index]);
if (value != 0) {
System.out.print(index + ":" + value + " ");
new_num_nonzeros++;
}
}
private String readline(BufferedReader fp) throws IOException {
line = fp.readLine();
return line;
}
@SuppressWarnings({ "unused", "resource" })
private void run(String[] argv) throws IOException {
int i, index;
BufferedReader fp = null, fp_restore = null;
String save_filename = null;
String restore_filename = null;
String data_filename = null;
for (i = 0; i < argv.length; i++) {
if (argv[i].charAt(0) != '-')
break;
++i;
switch (argv[i - 1].charAt(1)) {
case 'l':
lower = Double.parseDouble(argv[i]);
break;
case 'u':
upper = Double.parseDouble(argv[i]);
break;
case 'y':
y_lower = Double.parseDouble(argv[i]);
++i;
y_upper = Double.parseDouble(argv[i]);
y_scaling = true;
break;
case 's':
save_filename = argv[i];
break;
case 'r':
restore_filename = argv[i];
break;
default:
System.err.println("unknown option");
exit_with_help();
}
}
if (!(upper > lower) || (y_scaling && !(y_upper > y_lower))) {
System.err.println("inconsistent lower/upper specification");
System.exit(1);
}
if (restore_filename != null && save_filename != null) {
System.err.println("cannot use -r and -s simultaneously");
System.exit(1);
}
if (argv.length != i + 1)
exit_with_help();
data_filename = argv[i];
try {
fp = new BufferedReader(new FileReader(data_filename));
} catch (Exception e) {
System.err.println("can't open file " + data_filename);
System.exit(1);
}
/* assumption: min index of attributes is 1 */
/* pass 1: find out max index of attributes */
max_index = 0;
if (restore_filename != null) {
int idx, c;
try {
fp_restore = new BufferedReader(
new FileReader(restore_filename));
} catch (Exception e) {
System.err.println("can't open file " + restore_filename);
System.exit(1);
}
if ((c = fp_restore.read()) == 'y') {
fp_restore.readLine();
fp_restore.readLine();
fp_restore.readLine();
}
fp_restore.readLine();
fp_restore.readLine();
String restore_line = null;
while ((restore_line = fp_restore.readLine()) != null) {
StringTokenizer st2 = new StringTokenizer(restore_line);
idx = Integer.parseInt(st2.nextToken());
max_index = Math.max(max_index, idx);
}
fp_restore = rewind(fp_restore, restore_filename);
}
while (readline(fp) != null) {
StringTokenizer st = new StringTokenizer(line, " \t\n\r\f:");
st.nextToken();
while (st.hasMoreTokens()) {
index = Integer.parseInt(st.nextToken());
max_index = Math.max(max_index, index);
st.nextToken();
num_nonzeros++;
}
}
try {
feature_max = new double[(max_index + 1)];
feature_min = new double[(max_index + 1)];
} catch (OutOfMemoryError e) {
System.err.println("can't allocate enough memory");
System.exit(1);
}
for (i = 0; i <= max_index; i++) {
feature_max[i] = -Double.MAX_VALUE;
feature_min[i] = Double.MAX_VALUE;
}
fp = rewind(fp, data_filename);
/* pass 2: find out min/max value */
while (readline(fp) != null) {
int next_index = 1;
double target;
double value;
StringTokenizer st = new StringTokenizer(line, " \t\n\r\f:");
target = Double.parseDouble(st.nextToken());
y_max = Math.max(y_max, target);
y_min = Math.min(y_min, target);
while (st.hasMoreTokens()) {
index = Integer.parseInt(st.nextToken());
value = Double.parseDouble(st.nextToken());
for (i = next_index; i < index; i++) {
feature_max[i] = Math.max(feature_max[i], 0);
feature_min[i] = Math.min(feature_min[i], 0);
}
feature_max[index] = Math.max(feature_max[index], value);
feature_min[index] = Math.min(feature_min[index], value);
next_index = index + 1;
}
for (i = next_index; i <= max_index; i++) {
feature_max[i] = Math.max(feature_max[i], 0);
feature_min[i] = Math.min(feature_min[i], 0);
}
}
fp = rewind(fp, data_filename);
/* pass 2.5: save/restore feature_min/feature_max */
if (restore_filename != null) {
// fp_restore rewinded in finding max_index
int idx, c;
double fmin, fmax;
fp_restore.mark(2); // for reset
if ((c = fp_restore.read()) == 'y') {
fp_restore.readLine(); // pass the '\n' after 'y'
StringTokenizer st = new StringTokenizer(fp_restore.readLine());
y_lower = Double.parseDouble(st.nextToken());
y_upper = Double.parseDouble(st.nextToken());
st = new StringTokenizer(fp_restore.readLine());
y_min = Double.parseDouble(st.nextToken());
y_max = Double.parseDouble(st.nextToken());
y_scaling = true;
} else
fp_restore.reset();
if (fp_restore.read() == 'x') {
fp_restore.readLine(); // pass the '\n' after 'x'
StringTokenizer st = new StringTokenizer(fp_restore.readLine());
lower = Double.parseDouble(st.nextToken());
upper = Double.parseDouble(st.nextToken());
String restore_line = null;
while ((restore_line = fp_restore.readLine()) != null) {
StringTokenizer st2 = new StringTokenizer(restore_line);
idx = Integer.parseInt(st2.nextToken());
fmin = Double.parseDouble(st2.nextToken());
fmax = Double.parseDouble(st2.nextToken());
if (idx <= max_index) {
feature_min[idx] = fmin;
feature_max[idx] = fmax;
}
}
}
fp_restore.close();
}
if (save_filename != null) {
Formatter formatter = new Formatter(new StringBuilder());
BufferedWriter fp_save = null;
try {
fp_save = new BufferedWriter(new FileWriter(save_filename));
} catch (IOException e) {
System.err.println("can't open file " + save_filename);
System.exit(1);
}
if (y_scaling) {
formatter.format("y\n");
formatter.format("%.16g %.16g\n", y_lower, y_upper);
formatter.format("%.16g %.16g\n", y_min, y_max);
}
formatter.format("x\n");
formatter.format("%.16g %.16g\n", lower, upper);
for (i = 1; i <= max_index; i++) {
if (feature_min[i] != feature_max[i])
formatter.format("%d %.16g %.16g\n", i, feature_min[i],
feature_max[i]);
}
fp_save.write(formatter.toString());
fp_save.close();
}
/* pass 3: scale */
while (readline(fp) != null) {
int next_index = 1;
double target;
double value;
StringTokenizer st = new StringTokenizer(line, " \t\n\r\f:");
target = Double.parseDouble(st.nextToken());
output_target(target);
while (st.hasMoreElements()) {
index = Integer.parseInt(st.nextToken());
value = Double.parseDouble(st.nextToken());
for (i = next_index; i < index; i++)
output(i, 0);
output(index, value);
next_index = index + 1;
}
for (i = next_index; i <= max_index; i++)
output(i, 0);
System.out.print("\n");
}
if (new_num_nonzeros > num_nonzeros)
System.err.print("WARNING: original #nonzeros " + num_nonzeros
+ "\n" + " new #nonzeros " + new_num_nonzeros
+ "\n"
+ "Use -l 0 if many original feature values are zeros\n");
fp.close();
}
public static void main(String argv[]) throws IOException {
Svm_scale s = new Svm_scale();
s.run(argv);
}
}Svm_train.java
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.StringTokenizer;
import java.util.Vector;
import libsvm.svm;
import libsvm.svm_model;
import libsvm.svm_node;
import libsvm.svm_parameter;
import libsvm.svm_print_interface;
import libsvm.svm_problem;
public class Svm_train {
private svm_parameter param; // set by parse_command_line
private svm_problem prob; // set by read_problem
private svm_model model;
private String input_file_name; // set by parse_command_line
private String model_file_name; // set by parse_command_line
private String error_msg;
private int cross_validation;
private int nr_fold;
private static svm_print_interface svm_print_null = new svm_print_interface() {
public void print(String s) {
}
};
private static void exit_with_help() {
System.out
.print("Usage: svm_train [options] training_set_file [model_file]\n"
+ "options:\n"
+ "-s svm_type : set type of SVM (default 0)\n"
+ " 0 -- C-SVC (multi-class classification)\n"
+ " 1 -- nu-SVC (multi-class classification)\n"
+ " 2 -- one-class SVM\n"
+ " 3 -- epsilon-SVR (regression)\n"
+ " 4 -- nu-SVR (regression)\n"
+ "-t kernel_type : set type of kernel function (default 2)\n"
+ " 0 -- linear: u'*v\n"
+ " 1 -- polynomial: (gamma*u'*v + coef0)^degree\n"
+ " 2 -- radial basis function: exp(-gamma*|u-v|^2)\n"
+ " 3 -- sigmoid: tanh(gamma*u'*v + coef0)\n"
+ " 4 -- precomputed kernel (kernel values in training_set_file)\n"
+ "-d degree : set degree in kernel function (default 3)\n"
+ "-g gamma : set gamma in kernel function (default 1/num_features)\n"
+ "-r coef0 : set coef0 in kernel function (default 0)\n"
+ "-c cost : set the parameter C of C-SVC, epsilon-SVR, and nu-SVR (default 1)\n"
+ "-n nu : set the parameter nu of nu-SVC, one-class SVM, and nu-SVR (default 0.5)\n"
+ "-p epsilon : set the epsilon in loss function of epsilon-SVR (default 0.1)\n"
+ "-m cachesize : set cache memory size in MB (default 100)\n"
+ "-e epsilon : set tolerance of termination criterion (default 0.001)\n"
+ "-h shrinking : whether to use the shrinking heuristics, 0 or 1 (default 1)\n"
+ "-b probability_estimates : whether to train a SVC or SVR model for probability estimates, 0 or 1 (default 0)\n"
+ "-wi weight : set the parameter C of class i to weight*C, for C-SVC (default 1)\n"
+ "-v n : n-fold cross validation mode\n"
+ "-q : quiet mode (no outputs)\n");
System.exit(1);
}
private void do_cross_validation() {
int i;
int total_correct = 0;
double total_error = 0;
double sumv = 0, sumy = 0, sumvv = 0, sumyy = 0, sumvy = 0;
double[] target = new double[prob.l];
svm.svm_cross_validation(prob, param, nr_fold, target);
if (param.svm_type == svm_parameter.EPSILON_SVR
|| param.svm_type == svm_parameter.NU_SVR) {
for (i = 0; i < prob.l; i++) {
double y = prob.y[i];
double v = target[i];
total_error += (v - y) * (v - y);
sumv += v;
sumy += y;
sumvv += v * v;
sumyy += y * y;
sumvy += v * y;
}
System.out.print("Cross Validation Mean squared error = "
+ total_error / prob.l + "\n");
System.out
.print("Cross Validation Squared correlation coefficient = "
+ ((prob.l * sumvy - sumv * sumy) * (prob.l * sumvy - sumv
* sumy))
/ ((prob.l * sumvv - sumv * sumv) * (prob.l * sumyy - sumy
* sumy)) + "\n");
} else {
for (i = 0; i < prob.l; i++)
if (target[i] == prob.y[i])
++total_correct;
System.out.print("Cross Validation Accuracy = " + 100.0
* total_correct / prob.l + "%\n");
}
}
private void run(String argv[]) throws IOException {
parse_command_line(argv);
read_problem();
error_msg = svm.svm_check_parameter(prob, param);
if (error_msg != null) {
System.err.print("ERROR: " + error_msg + "\n");
System.exit(1);
}
if (cross_validation != 0) {
do_cross_validation();
} else {
model = svm.svm_train(prob, param);
svm.svm_save_model(model_file_name, model);
}
}
public static void main(String argv[]) throws IOException {
Svm_train t = new Svm_train();
t.run(argv);
}
private static double atof(String s) {
double d = Double.valueOf(s).doubleValue();
if (Double.isNaN(d) || Double.isInfinite(d)) {
System.err.print("NaN or Infinity in input\n");
System.exit(1);
}
return (d);
}
private static int atoi(String s) {
return Integer.parseInt(s);
}
private void parse_command_line(String argv[]) {
int i;
svm_print_interface print_func = null; // default printing to stdout
param = new svm_parameter();
// default values
param.svm_type = svm_parameter.C_SVC;
param.kernel_type = svm_parameter.LINEAR; // 使用线性函数
param.degree = 3;
param.gamma = 0; // 1/num_features
param.coef0 = 0;
param.nu = 0.5;
param.cache_size = 100;
param.C = 1;
param.eps = 1e-3;
param.p = 0.1;
param.shrinking = 1;
param.probability = 1; // 使用概率值，对每个label进行概率分析
param.nr_weight = 0;
param.weight_label = new int[0];
param.weight = new double[0];
cross_validation = 0;
// parse options
for (i = 0; i < argv.length; i++) {
if (argv[i].charAt(0) != '-')
break;
if (++i >= argv.length)
exit_with_help();
switch (argv[i - 1].charAt(1)) {
case 's':
param.svm_type = atoi(argv[i]);
break;
case 't':
param.kernel_type = atoi(argv[i]);
break;
case 'd':
param.degree = atoi(argv[i]);
break;
case 'g':
param.gamma = atof(argv[i]);
break;
case 'r':
param.coef0 = atof(argv[i]);
break;
case 'n':
param.nu = atof(argv[i]);
break;
case 'm':
param.cache_size = atof(argv[i]);
break;
case 'c':
param.C = atof(argv[i]);
break;
case 'e':
param.eps = atof(argv[i]);
break;
case 'p':
param.p = atof(argv[i]);
break;
case 'h':
param.shrinking = atoi(argv[i]);
break;
case 'b':
param.probability = atoi(argv[i]);
break;
case 'q':
print_func = svm_print_null;
i--;
break;
case 'v':
cross_validation = 1;
nr_fold = atoi(argv[i]);
if (nr_fold < 2) {
System.err.print("n-fold cross validation: n must >= 2\n");
exit_with_help();
}
break;
case 'w':
++param.nr_weight;
{
int[] old = param.weight_label;
param.weight_label = new int[param.nr_weight];
System.arraycopy(old, 0, param.weight_label, 0,
param.nr_weight - 1);
}
{
double[] old = param.weight;
param.weight = new double[param.nr_weight];
System.arraycopy(old, 0, param.weight, 0,
param.nr_weight - 1);
}
param.weight_label[param.nr_weight - 1] = atoi(argv[i - 1]
.substring(2));
param.weight[param.nr_weight - 1] = atof(argv[i]);
break;
default:
System.err.print("Unknown option: " + argv[i - 1] + "\n");
exit_with_help();
}
}
svm.svm_set_print_string_function(print_func);
// determine filenames
if (i >= argv.length)
exit_with_help();
input_file_name = argv[i];
if (i < argv.length - 1)
model_file_name = argv[i + 1];
else {
int p = argv[i].lastIndexOf('/');
++p; // whew...
model_file_name = argv[i].substring(p) + ".model";
}
}
// read in a problem (in svmlight format)
private void read_problem() throws IOException {
BufferedReader fp = new BufferedReader(new FileReader(input_file_name));
Vector<Double> vy = new Vector<Double>();
Vector<svm_node[]> vx = new Vector<svm_node[]>();
int max_index = 0;
while (true) {
String line = fp.readLine();
if (line == null)
break;
StringTokenizer st = new StringTokenizer(line, " \t\n\r\f:");
vy.addElement(atof(st.nextToken()));
int m = st.countTokens() / 2;
svm_node[] x = new svm_node[m];
for (int j = 0; j < m; j++) {
x[j] = new svm_node();
x[j].index = atoi(st.nextToken());
x[j].value = atof(st.nextToken());
}
if (m > 0)
max_index = Math.max(max_index, x[m - 1].index);
vx.addElement(x);
}
prob = new svm_problem();
prob.l = vy.size();
prob.x = new svm_node[prob.l][];
for (int i = 0; i < prob.l; i++)
prob.x[i] = vx.elementAt(i);
prob.y = new double[prob.l];
for (int i = 0; i < prob.l; i++)
prob.y[i] = vy.elementAt(i);
if (param.gamma == 0 && max_index > 0)
param.gamma = 1.0 / max_index;
if (param.kernel_type == svm_parameter.PRECOMPUTED)
for (int i = 0; i < prob.l; i++) {
if (prob.x[i][0].index != 0) {
System.err
.print("Wrong kernel matrix: first column must be 0:sample_serial_number\n");
System.exit(1);
}
if ((int) prob.x[i][0].value <= 0
|| (int) prob.x[i][0].value > max_index) {
System.err
.print("Wrong input format: sample_serial_number out of range\n");
System.exit(1);
}
}
fp.close();
}
}
753
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
