public static void main(String[] args) throws IOException {

    String train_file_name = "150(1000)-100-train.csv",
        test_file_name = "test-1000-100.csv",
        train_data,
        test_data,
        output_file;
    int training_rows = 0, training_cols = 0, testing_rows = 0, testing_cols = 0;

    BufferedReader CSVTrain = new BufferedReader(new FileReader(train_file_name));
    train_data = CSVTrain.readLine();
    BufferedReader CSVTest = new BufferedReader(new FileReader(test_file_name));
    test_data = CSVTest.readLine();

    ArrayList<String[]> train_array_list = new ArrayList<String[]>();
    ArrayList<String[]> test_array_list = new ArrayList<String[]>();

    training_cols = countColumns(train_data, training_cols);
    testing_cols = countColumns(test_data, testing_cols);
    training_rows = readData(CSVTrain, train_array_list, training_rows, training_cols);
    testing_rows = readData(CSVTest, test_array_list, testing_rows, testing_cols);

    double X_train[][] = new double[training_rows][training_cols];
    double Y_train[][] = new double[training_rows][1];
    double X_test[][] = new double[testing_rows][testing_cols];
    double Y_test[][] = new double[testing_rows][1];

    insertX0(training_rows, X_train);
    insertX0(testing_rows, X_test);

    createXYarray(train_array_list, training_cols, X_train, Y_train);
    createXYarray(test_array_list, testing_cols, X_test, Y_test);

    Matrix mx_train = Matrix.constructWithCopy(X_train);
    Matrix my_train = Matrix.constructWithCopy(Y_train);
    Matrix mx_test = Matrix.constructWithCopy(X_test);
    Matrix my_test = Matrix.constructWithCopy(Y_test);

    double minimum_error = (double) 1000;
    int optimal_lambda = 0;

    output_file = "output-" + train_file_name;
    PrintStream output = new PrintStream(new File(output_file));

    for (int lambda = 0; lambda <= 150; lambda++) {
      Matrix w =
          ((((mx_train.transpose().times(mx_train))
                      .plus(Matrix.identity(training_cols, training_cols).times((double) lambda)))
                  .inverse())
              .times((mx_train.transpose()).times(my_train)));

      Matrix E_train = calculateMSE(training_rows, mx_train, my_train, w);
      Matrix E_test = calculateMSE(testing_rows, mx_test, my_test, w);

      output.append(Double.toString(E_train.get(0, 0)) + ",");
      output.append(Double.toString(E_test.get(0, 0)) + ",");
      output.append(Integer.toString(lambda) + ",");
      output.println();

      if (E_test.get(0, 0) < minimum_error) {
        minimum_error = E_test.get(0, 0);
        optimal_lambda = lambda;
      }
    }

    System.out.println("Minimum Error:" + minimum_error);
    System.out.println("Optimal Lambda:" + optimal_lambda);
    output.close();
  }