Why is there output even after changing System.out?

I'm using scpsolver for a little personal project. The library is generating output, which I don't want to see. I actually reported this as a bug, just to see what they say about it.

There's no exposed way to disable the output. The GLPKSolver class attempts to disable itusing what GLPK is exposing to them, but as described in one of the comments below, that isn't doing anything either.

I've tried to alter System.out and System.err to be null output streams but that has not helped, as the library apparently is able to print to the console in a different way. I still don't understand how this works.

Finally, there's a setHook() function I've tried to use but even that has failed, as shown in the output at the bottom.
My Solver class

public class Solver {
    private static final PrintStream out = System.out;
    private static final PrintStream err = System.err;
    private static final PrintStream null_stream = new PrintStream( OutputStream.nullOutputStream() );
    static {
        System.setOut( null_stream );
        System.setErr( null_stream );
    }
    public static double[] solve ( double[][] A, double[] b, double[] c, double[] lb ) {
        LinearProgram lp = new LinearProgram( c );
        for ( int i = 0; i < b.length; i++ ) {
            lp.addConstraint( new LinearEqualsConstraint( A[i], b[i], "c" + i ) );
        }
        lp.setLowerbound( lb );
        lp.setMinProblem( false );
        LinearProgramSolver solver = SolverFactory.newDefault();
        double[] sol = solver.solve( lp );
        System.out.flush();
        System.err.flush();
        System.setOut( out );
        System.setErr( err );
        return sol;
    }
}

Snippet from the GLPKSolver.java that I'm re-compiling in inserting back into the library

    solver.enablePrints(false);  // turn this to "false" to prevent printouts
    System.out.println("Hello, world!");
    solver.setHook( new GlpkHookIFC() {
        @Override
        public void fault ( String s ) {}
        @Override
        public void print ( String s ) {}
    } );
    System.out.println("Hi, world!");

Output:

GLPK Simplex Optimizer, v4.65
8 rows, 9 columns, 20 non-zeros
      0: obj = -0.000000000e+000 inf =  1.590e+002 (2)
      5: obj = -2.400000000e+003 inf =  0.000e+000 (0)
OPTIMAL LP SOLUTION FOUND
Process finished with exit code 0

In particular, notice that "Hello, world!" and "Hi, world!" are both absent from the output. Some small portion of the GLPK output is suppressed by doing this. If I remove all the System.* redirects, this is what I get.

Hello, world!
Hi, world!
GLPK Simplex Optimizer, v4.65
8 rows, 9 columns, 20 non-zeros
      0: obj = -0.000000000e+000 inf =  1.590e+002 (2)
      5: obj = -2.400000000e+003 inf =  0.000e+000 (0)
OPTIMAL LP SOLUTION FOUND
x1: 2.0
x2: 0.0
x3: 0.5
x4: 0.0
x5: 4.9
x6: 2.2
x7: 0.0
x8: 0.0
x9: 2.4

Interestingly, the output comes after hello world...

The output you see is produced by a native library that scpsolver calls. Native libraries can write directly to the JVM's standard output streams without going through the System.out and System.err objects, and often do because using these objects from native code is pretty inconvenient.

Disabling the output is not easy, unless the native library itself includes a capability to do it. I'm not familiar with scpsolver or the libraries it uses but I can have a look when I get the time. In the general case you may need to create a new native library just to turn the output off.

Update: After spelunking a little I see that there is a way to turn off terminal output in the underlying native library:

> Programmers using the GLPK API can enable and disable terminal output by calling glp_term_out. The hook function glp_term_hook can be used to intercept terminal output. Finer grain output control is also provided but is not covered here — consult the GLPK API manual instead.

So all you need to do is make sure these functions get called. Simple right? In the SCPSolver source code I see that there is an attempt at turning off the output from the native library:

	solver.enablePrints(false);  // turn this to "false" to prevent printouts

But this call to the C-code native library doesn't actually do anything because the code to disable printing is commented out. In fact, all it does it leak a little bit of memory:

JNIEXPORT void JNICALL
Java_org_gnu_glpk_GlpkSolver_enablePrints(JNIEnv *env, jobject obj,
										  jboolean enable)
{
    info_t  *info=malloc(sizeof(info_t));
    info->env = env;
    info->obj = obj;
    //lib_set_fault_hook((void*)info, enable ? NULL : &_fault_hook_fn);
    //lib_set_print_hook((void*)info, enable ? NULL : &_print_hook_fn);
}

There may be another way to disable the output, by setting a "hook" on the GlpkSolver solver object in scpsolver.lpsolver.GLPKSolver, but with the way the code is written you have no way to access this object.

I would recommend copying the code of scpsolver.lpsolver.GLPKSolver to a class in your own project, and replacing the call to solver.enablePrints with a call to solver.setHook.