GLPK/IAJAAR.H project

This page describes a C++ class that wraps the C-style GLPK vectors ia, ja, and ar. The class can be used directly with C++ or via language bindings for Java and R created with SWIG.

IAJAAR.H project

IAJAAR.H is a small project that provides the specialized triple container class IAJAAR. The purpose of this C++ class is to offer more convenient problem build calls than those available using straight C code. The author is Nigel Galloway.

C++ class IAJAAR definition

The C++ IAJAAR class definition is:

//  File: 'iajaar.h'
//  Provides: C++ class 'IAJAAR'

class IAJAAR
{
private:
  int *    xia;
  int *    xja;
  double * xar;
  int      entry;
  int      maxSize;
public:
 ~IAJAAR();                                  // destructor, deallocate memory
  IAJAAR(int s);                             // constructor, s is maximum array length
  const int * ia();                          // return C-style int array
  const int * ja();                          // return C-style int array
  const double * ar();                       // return C-style double array
  void Add(int row, int col, double value);
  int ne();                                  // return number of entries
};

The member function IAJAAR::Add adds 3-tuples (triples) in the form (row, col, value). The respective arrays can be later retrieved using the member functions IAJAAR::ia, IAJAAR::ja, and IAJAAR::ar. The member function IAJAAR::ne returns the current number of entries.

IAJAAR is designed to work with the following GLPK routine:

void glp_load_matrix(glp_prob *lp, int ne, const int ia[], const int ja[], const double ar[]);

It would be possible to reformulate class IAJAAR using std::vectors internally. That would omit the need to pre-specify the maximum size s in advance, although an optional hint could be given.

C++ usage

Usage with C++ is straightforward — no special language bindings are required. A description of the underlying problem is can be found on the project website.

//  File: 'igst10yo.cpp'
//  An example of using IAJAAR.H with GLPK in C++.
//  Usage: 'igst10yo.cpp 6.5 7' will calculate 6.5 divided by 7.
//  Nigel Galloway / July 2009

#include <iostream>
#include <stdlib.h>
#include "iajaar.h"          // see above on wikipage
#include "glpk.h"

int main(int argc, char * argv[])
{
  double Q = atof(argv[1]);
  int    N = atoi(argv[2]);
  IAJAAR * igst10yo = new IAJAAR(5*N);
  glp_prob * lp = glp_create_prob();
  // col 1 is M
  // cols 2 .. N+1 is a sample of N numbers which sum to Q
  // cols N+2 .. 2*N+1 are v[1..N]
  glp_add_rows(lp,N+2);
  glp_add_cols(lp,2*N+1);
  for(int i=1; i<=2*N+1; i++) glp_set_col_bnds(lp,i,GLP_FR,0,0);
  glp_set_row_bnds(lp,N+1,GLP_FX,Q,Q);
  glp_set_row_bnds(lp,N+2,GLP_FX,0,0);
  try {
    for(int i=1; i<=N; i++) {
      glp_set_row_bnds(lp,i,GLP_FX,0,0);
      igst10yo->Add(i,i+1,-1);
      igst10yo->Add(i,1,1);
      igst10yo->Add(i,i+N+1,1);
      igst10yo->Add(N+1,i+1,1);
      igst10yo->Add(N+2,i+N+1,1);
    }
  } catch (char * error) {
    std::cout << error << std::endl;
  }
  glp_load_matrix(lp,igst10yo->ne(),igst10yo->ia(),igst10yo->ja(),igst10yo->ar());
  glp_simplex(lp,NULL);
  double Result = glp_get_col_prim(lp,1);
  std::cout << "The arithmetic mean of a sample of " << N
            << " numbers whose sum is " << Q << " is " << Result
            << std::endl;
  delete igst10yo;
  glp_delete_prob(lp);
  return 0;
}

Python usage

IAJAAR can be used with Python. This February 2011 posting explains more.

Java usage

Java usage requires dedicated language bindings. Unlike the C++ example, Q and N are hardcoded.

/*
  File: 'gmst10yo.java'
  Usage: 'java -classpath IAJAAR_JAVA.jar;GLPK_JAVA.jar;. gmst10yo'
  will calculate 22 divided by 7.
  Modify Q and N below to try alternatives.
  Nigel Galloway / July 2009
*/

import org.gnu.glpk.*;

public class gmst10yo {
  static {
    System.loadLibrary("IAJAAR_JAVA");
  }
  public static void main(String argv[]) {
    double Q = 22;
    int N = 7;
    IAJAAR t = new IAJAAR(3*N);
    glp_prob lp = GLPK.glp_create_prob();
    GLPK.glp_add_rows(lp,N+1);
    /* col 1 is M
       cols 2 .. N+1 are S[n]
    */
    GLPK.glp_add_cols(lp,N+1);
    for(int i=1; i<=N+1; i++) GLPK.glp_set_col_bnds(lp,i,GLPK.GLP_FR,0,0);
    t.Add(1,1,1);
    t.Add(1,2,1);
    t.Add(N+1,2,1);
    GLPK.glp_set_row_bnds(lp,N+1,GLPK.GLP_FX,0,0);
    GLPK.glp_set_row_bnds(lp,1,GLPK.GLP_FX,Q,Q);
    for(int i=2; i<=N; i++){
            GLPK.glp_set_row_bnds(lp,i,GLPK.GLP_FX,0,0);
            t.Add(i,1,1);
            t.Add(i,i+1,1);
            t.Add(N+1,i+1,1);
    }
    GLPK.glp_load_matrix(lp,t.ne(),t.ia(),t.ja(),t.ar());
    GLPK.glp_simplex(lp,null);
    double Result = GLPK.glp_get_col_prim(lp,1);
    GLPK.glp_delete_prob(lp);
    System.out.println("The arithmetic mean of a sample of " + N 
                       + " numbers which sum to " + Q + " is " + Result);
  }
}

R usage

R usage requires dedicated language bindings. Unlike the C++ example, Q and N are hard-coded.

#  File: 'gist10yo.R'
#  Nigel Galloway / July 2009

dyn.load(paste("GLPK_R", .Platform$dynlib.ext, sep=""))
source("GLPKconstants.R")
source("GLPK_R.R")
cacheMetaData(1)
Q <- 22
N <- 7
t <- IAJAAR(6)
lp <- glp_create_prob()
glp_add_rows(lp,3)
#  col 1 is M
#  col 2 is v1
#  col 3 is v2
glp_add_cols(lp,3)
glp_set_col_bnds(lp,1,GLP_FR,0,0)
glp_set_col_bnds(lp,2,GLP_FR,0,0)
glp_set_col_bnds(lp,3,GLP_FR,0,0)
IAJAAR_Add(t,1,1,1)
IAJAAR_Add(t,1,2,1)
IAJAAR_Add(t,2,1,1)
IAJAAR_Add(t,2,3,1)
IAJAAR_Add(t,3,2,1)
IAJAAR_Add(t,3,3,N-1)
glp_set_row_bnds(lp,1,GLP_FX,Q,Q)
glp_set_row_bnds(lp,2,GLP_FX,0,0)
glp_set_row_bnds(lp,3,GLP_FX,0,0)
loadMatrix(t,lp);
delete(t)
if (glp_simplex(lp,t)==0) {
  R <- glp_get_col_prim(lp,1)
  print(sprintf("The arithmetic mean of a sample of %f numbers which sum to %f is %f",N,Q,R))
} else {
  print("No solution")
}

Further information is available from the project website. In particular, the source code for iajaar.cpp is worth reviewing.