@CP

[Terrence Brannon]

1- It would be nice if you could simply specify the filename instead
of including the text from the .cpp file

2- Apparently this mode does not support pagebreaks. A small c
fragment was included fine. A larger one yielded: 

 244,1: 18.354c object horizontally scaled by factor 0.87 (too wide for 15.989c 
paragraph)

Entire lout document included for reference:

@SysInclude {tab}
@SysInclude {creport}

@Report
        @Title  {Lateral Inhibition}
        @Author {Terrence Brannon}
//

@Section
        @Title {Feedforward Case}
@Begin
@PP
The feedforward case is analytically straightforward. We will
characterize it by variation of the mask and sigmoid parameters
As a baseline,
the following parameters were used:

@Tab
        @Fmta { @Col A ! @Col B ! @Col C}
        {
        @Rowa A {Synaptic Weights} B {1,1,1,1,1}
        @Rowa A {Sigmoid} B {theta=3, s=4}
        }

@PP
0.2 @Scale @IncludeGraphic {ff:S1.eps}
0.2 @Scale @IncludeGraphic {ff:S2.eps}
0.2 @Scale @IncludeGraphic {ff:S3.eps}
@PP
0.2 @Scale @IncludeGraphic {ff:U-from-S1.eps}
0.2 @Scale @IncludeGraphic {ff:U-from-S2.eps}
0.2 @Scale @IncludeGraphic {ff:U-from-S3.eps}

@PP
@PP
The next experiment varied the weight mask:

@Tab
        @Fmta { @Col A ! @Col B ! @Col C}
        {
        @Rowa A {Synaptic Weights} B {-1,-2,5,-2,-1}
        @Rowa A {Sigmoid} B {theta=3, s=4}
        }

@PP
0.2 @Scale @IncludeGraphic {ff2:S1.eps}
0.2 @Scale @IncludeGraphic {ff2:S2.eps}
0.2 @Scale @IncludeGraphic {ff2:S3.eps}
@PP
0.2 @Scale @IncludeGraphic {ff2:U-from-S1.eps}
0.2 @Scale @IncludeGraphic {ff2:U-from-S2.eps}
0.2 @Scale @IncludeGraphic {ff2:U-from-S3.eps}

@PP
The next experiment made the sigmoid very steep:

@Tab
        @Fmta { @Col A ! @Col B ! @Col C}
        {
        @Rowa A {Synaptic Weights} B {-1,-2,5,-2,-1}
        @Rowa A {Sigmoid} B {theta=3, s=0.5}
        }

@PP
0.2 @Scale @IncludeGraphic {ff3:S1.eps}
0.2 @Scale @IncludeGraphic {ff3:S2.eps}
0.2 @Scale @IncludeGraphic {ff3:S3.eps}
@PP
0.2 @Scale @IncludeGraphic {ff3:U-from-S1.eps}
0.2 @Scale @IncludeGraphic {ff3:U-from-S2.eps}
0.2 @Scale @IncludeGraphic {ff3:U-from-S3.eps}


@End @Section

@Section
        @Title {Feedback Case}
@Begin
@PP
Before exploring the feedback case, I wanted to see how attenuated the
input pattern would be since there was no convolution of the
input. Hence I simply used the same input stimuli and feed them
forward into a layer with no convolution:

@Tab
        @Fmta { @Col A ! @Col B ! @Col C}
        {
        @Rowa A {Synaptic Weights} B {-0.25,0,-0,25}
        @Rowa A {Sigmoid} B {theta=3, s=4}
        }

@PP
0.2 @Scale @IncludeGraphic {fb:S2.eps}
@PP
0.2 @Scale @IncludeGraphic {fb:U-from-S2.eps}
@PP
As you can see, after the input layer is pushed through the sigmoid,
it has almost flattened out the input. Hence, the first goal was to
amplify the input so that it could play a more significant role in
integration. Multiplying the input values by eight yielded a
reasonable mirroring on the input layer. The next experiment varied
the weight mask so that neighbors received some lateral squashing:

@Tab
        @Fmta { @Col A ! @Col B ! @Col C}
        {
        @Rowa A {Synaptic Weights} B {-0.25,0,-0,25}
        @Rowa A {Sigmoid} B {theta=0.5, s=4}
        }



@PP

0.2 @Scale @IncludeGraphic {fb2:S2.eps}

@PP

0.2 @Scale @IncludeGraphic {fb2:U-from-S2.eps}


@PP
The next experiment made the sigmoid very steep:

@Tab
        @Fmta { @Col A ! @Col B ! @Col C}
        {
        @Rowa A {Synaptic Weights} B {-0.25,0,-0.25}
        @Rowa A {Sigmoid} B {theta=0.5, s=4}
        }

@PP
0.2 @Scale @IncludeGraphic {fb3:S1.eps}
0.2 @Scale @IncludeGraphic {fb3:S2.eps}
0.2 @Scale @IncludeGraphic {fb3:S3.eps}
@PP
0.2 @Scale @IncludeGraphic {fb3:U-from-S1.eps}
0.2 @Scale @IncludeGraphic {fb3:U-from-S2.eps}
0.2 @Scale @IncludeGraphic {fb3:U-from-S3.eps}
@PP
@PP
Just for kicks, I created a case where each unit gave itself recurrent
self-excitation:

@Tab
        @Fmta { @Col A ! @Col B ! @Col C}
        {
        @Rowa A {Synaptic Weights} B {-0.25,0.50,-0.25}
        @Rowa A {Sigmoid} B {theta=0.5, s=4}
        }

@PP
0.2 @Scale @IncludeGraphic {fb4:S1.eps}
0.2 @Scale @IncludeGraphic {fb4:S2.eps}
0.2 @Scale @IncludeGraphic {fb4:S3.eps}
@PP
0.2 @Scale @IncludeGraphic {fb4:U-from-S1.eps}
0.2 @Scale @IncludeGraphic {fb4:U-from-S2.eps}
0.2 @Scale @IncludeGraphic {fb4:U-from-S3.eps}
@PP
@PP

@End @Section

@Section
        @Title {2-dimensional network}
@Begin
@PP

In the two dimensional case, the first run used the following parameters:

@Tab
        @Fmta { @Col A ! @Col B ! @Col C}
        {
        @Rowa A {Synaptic Weights} B {mask 1, figure 3}
        @Rowa A {Sigmoid} B {theta=0.75, s=0.25}
        }

@PP
0.5 @Scale @IncludeGraphic {ff-2d:orig.eps}
0.5 @Scale @IncludeGraphic {ff-2d:proc.eps}
@PP
@PP
The results with the same parameters for the other image are shown below:
@PP
0.5 @Scale @IncludeGraphic {ff-2d:orig2.eps}
0.5 @Scale @IncludeGraphic {ff-2d:proc2.eps}


@PP
@PP



@BeginSubSections
@SubSection 
        @Title {Vertical Orientation}
@Begin
@PP
The sigmoid used theta 1 and s=0.75.
The weight mask was as follows:
@Tab
        @Fmta { @Col A ! @Col B ! @Col C}
        {
        @Rowa A {-0.1} B {0.5} C {-0.1}
        @Rowa A {-0.1} B {0.5} C {-0.1}
        @Rowa A {-0.1} B {0.5} C {-0.1}
        }

0.5 @Scale @IncludeGraphic {ff-2d:orig3.eps}
0.5 @Scale @IncludeGraphic {ff-2d:proc3.eps}
@PP
As you can see, the performance of this filter is poor. This is
because all vertical edges are dark in color. There is no way to
simply boost values along a vertical axis and set the sigmoid so that
these values return much larger values than other regions. A much more
complicated filter, ie, one that used dark areas as disinhibition to
to an excitable vertical edge detector, would have to be implemented. 
@End @SubSection
@EndSubSections

@End @Section

@Section
        @Title {Source Code}
@Begin
@PP
This code was written as an instance of my implementation of a
neurosimulation program initially conceived and developed by Alfredo
Weitzenfeld and Dr. Michael Arbib. The code resides in
"/newport/freeway/brannon/rs/ancient-research/rs/l-nsl/." It makes use
of the following:
@List
@ListItem @I {MATCLASS}, a public domain matrix class
@ListItem @I {SIM-2.1}, a public domain discrete-event simulation
package
@ListItem @I {PLPLOT}, a public domain plotting package.
@EndList

@BeginSubSections
@SubSection 
        @Title {The Lateral Inhibition Program}
@Begin
@PP

@CP 
  style {varying}
{
#include "nslInclude.h"
#include <fstream.h>
#include <stdlib.h>
#include <stdio.h>

PLINT C[101] = {
  0,
  3,  5,  8, 10, 13, 15, 18, 20, 23, 26, 28, 31, 33, 36, 38,
  41, 43, 46, 48, 51, 54, 56, 59, 61, 64, 66, 69, 71, 74, 77,
  79, 82, 84, 87, 89, 92, 94, 97, 99,102,105,107,110,112,115,
  117,120,122,125,127,130,133,135,138,140,143,145,148,150,153,
  156,158,161,163,166,168,171,173,176,179,181,184,186,189,191,
  194,196,199,201,204,207,209,212,214,217,219,222,224,227,229,
  232,235,237,240,242,245,247,250,252,255
} ;

char     s[200] ;
ifstream picfile("venice100x100.pgm") ;

//FILE * picfile;

char driver[] = "xwin";
char geometry_master[] = "500x210+100+0";
char geometry_slave[]  = "500x210+50+20";
char geometry_slave2[] = "500x210+100+450";
char geometry_slave3[] = "300x300+400+400";
char geometry_slave4[] = "300x300+0+0";

static int locate_mode;
static PLOptionTable options[] = {
  {
    "locate",                   /* Turns on test of API locate function */
    NULL,
    NULL,
    &locate_mode,
    PL_OPT_BOOL,
    "-locate",
    "Turns on test of API locate function" },
  {
    NULL,                       /* option */
    NULL,                       /* handler */
    NULL,                       /* client data */
    NULL,                       /* address of variable to set */
    0,                          /* mode flag */
    NULL,                       /* short syntax */
    NULL }                      /* long syntax */
};

char *notes[] = {"Make sure you get it right!", NULL};

nslSimulation * NSL_SIM = new nslSimulation(0.1);

nslRowVector S(10);             // network input 
nslRowVector S1(50);            // network input pattern 1
nslRowVector S2(50);            // network input pattern 2
nslRowVector S3(50);            // network input pattern 3

nslMatrix img("img",100,100);
nslMatrix img_mask1("img_mask1",3,3);
nslMatrix img_mask2("img_mask2",3,3);
nslMatrix img_out("img_out",100,100);
nslMatrix IMG_OUT("img_out",100,100);

nslRowVector weight_mask(5);

nslRowVector u(50);     // membrane potential
nslRowVector U(50);     // firing rate

double Umin, Umax;

double tu;
double to;

double delta ;

simulation * sim ;

void didday_init_variables()
{
  u = 0;
  U = 0;

  Umin=-0.1; Umax=1.1;

  weight_mask(1,1) = -1;
  weight_mask(1,5) = -1;

  weight_mask(1,2) = -2;
  weight_mask(1,4) = -2;

  weight_mask(1,3) = 5;

  img_mask1(1,1)=0;
  img_mask1(1,3)=0;
  img_mask1(3,1)=0;
  img_mask1(3,3)=0;
  img_mask1(2,2)=-4;
  
  img_mask1(1,2)=1;
  img_mask1(2,1)=1;
  img_mask1(2,3)=1;
  img_mask1(3,2)=1;

  img_mask2(1,1)=-0.1;
  img_mask2(1,3)=-0.1;
  img_mask2(3,1)=-0.1;
  img_mask2(3,3)=-0.1;
  img_mask2(2,1)=-0.1;
  img_mask2(2,3)=-0.1;

  img_mask2(2,2)=0.5;
  img_mask2(1,2)=0.5;
  img_mask2(3,2)=0.5;

  delta = 0.1 ;
  tu=1.0;
  to=1.0;
}


void didday_init_graphics()
{
  int i , k ; 
  char str[100];

  plssub(3,5);
  plinit();

  for (k=1; k<=10; ++k) {
    pladv(k); 
    plvsta();
    plwind( 0.0, 20.0, -2.0, 2.0 );

    plcol(1);
    plbox("bcnst",0,0,   "bcnst", 0,0);

    sprintf(str,"(zippety) D I D D A Y: %d", k) ;
    pllab("(x)", "(y)", str);
  }

}

void init_grayscale_graphics() {
  int i , k ; 
  char str[100];

  plsstrm(3);
  plSetOpt("geometry",geometry_slave3);

  plsdev(driver);
  plscmap0n(101);
  plinit();
  plscmap0(C,C,C,101);
  pladv(0); 

  plcol(100);
  plvpor(0.1, 0.9, 0.1, 0.9);
  plwind(0.0, 100.0, 0.0, 100.0);

  plcol(100);
  plbox("bcgt", 1, 0, "bcgt", 1, 0);

  int I,J, val ;
  float med;


  if (!picfile) {
    cerr << "cannot open picfile" << endl;
    exit(1);
  }

  while (picfile.getline(s,100)) {
    if (!(strcmp(s,"255"))) { break; }
    printf ("%s\n", s);
  }

  int q,p;
  int num;

  for (p=100; p>=1; --p) {
    for (q=100; q>=1; --q) { 
        picfile >> num;
        img(q,p) = num / 255.0;
    }
  }
}

void didday_grayscale_graphics()
{
  int i,j,k;
  PLFLT x, y ;

  plsstrm(3);

  k = 16;
  y = 0.5;      
  for (i = 1; i <= 100; i++) {
    for (j = 1; j <= 100; j++) {
    x = i+0.5;
    y = j+0.5;

    //    printf ("ij: %d \n", (int)(img(i,j)*100));
    plcol( (int)(img(i,j)*100) );
    /* Display the symbols (plpoin expects that x and y are arrays so */
    /* pass pointers) */
    plpoin(1, &x, &y, k);
    }
  }
}

void didday_init_S1graphics()
{
  int i , k ; 
  char str[100];

  plsstrm(2);
  plssub(50,1);
  plSetOpt("geometry",geometry_slave2);

  plsdev(driver);
  plinit();

  for (k=1; k<=50; ++k) {
    pladv(k); 
    plvpor(0.0,1.00,  0.4,0.6);
    plwind( 0.0, 20.0, Umin, Umax );

    plcol(15);
    plbox("bc",0,0,   "bc", 0,0);
  }

}

void didday_S1graphics()
{
int i,j,k;
  PLFLT x, y ;

  plsstrm(2);

  x = (PLFLT) NSL_SIM->clock() ;

  for (k=1; k<=50; ++k) {
    pladv(k); 

    y = S1(1,k) ;


    plvpor(0.0,1.00,  0.4,0.6);
    plwind( 0.0, 20.0, Umin, Umax );

    plpoin(1, &x, &y, -1);
  }
}

void didday_init_S2graphics()
{
  int i , k ; 
  char str[100];

  plsstrm(2);
  plssub(50,1);
  plSetOpt("geometry",geometry_slave2);

  plsdev(driver);
  plinit();

  for (k=1; k<=50; ++k) {
    pladv(k); 
    plvpor(0.0,1.00,  0.4,0.6);
    plwind( 0.0, 20.0, Umin, Umax );

    plcol(15);
    plbox("bc",0,0,   "bc", 0,0);
  }

}

void didday_S2graphics()
{
  int i,j,k;
  PLFLT x, y ;

  plsstrm(2);

  x = (PLFLT) NSL_SIM->clock() ;

  for (k=1; k<=50; ++k) {
    pladv(k); 

    y = S2(1,k) ;


    plvpor(0.0,1.00,  0.4,0.6);
    plwind( 0.0, 20.0, Umin, Umax );

    plpoin(1, &x, &y, -1);
  }
}

void didday_init_S3graphics()
{
int i , k ; 
  char str[100];

  plsstrm(2);
  plssub(50,1);
  plSetOpt("geometry",geometry_slave2);

  plsdev(driver);
  plinit();

  for (k=1; k<=50; ++k) {
    pladv(k); 
    plvpor(0.0,1.00,  0.4,0.6);
    plwind( 0.0, 20.0, Umin, Umax );

    plcol(15);
    plbox("bc",0,0,   "bc", 0,0);
  }

}

void didday_S3graphics()
{
  int i,j,k;
  PLFLT x, y ;

  plsstrm(2);

  x = (PLFLT) NSL_SIM->clock() ;

  for (k=1; k<=50; ++k) {
    pladv(k); 

    y = S3(1,k) ;


    plvpor(0.0,1.00,  0.4,0.6);
    plwind( 0.0, 20.0, Umin, Umax );

    plpoin(1, &x, &y, -1);
  }
}

void didday_init_Ugraphics()
{
  int i , k ; 
  char str[100];

  plsstrm(1);
  plssub(50,1);
  plSetOpt("geometry",geometry_slave);

  plsdev(driver);
  plinit();

  for (k=1; k<=50; ++k) {
    pladv(k); 
    plvpor(0.0,1.00,  0.4,0.6);
    plwind( 0.0, 20.0, Umin, Umax );

    plcol(15);
    plbox("bc",0,0,   "bc", 0,0);
  }
  //  plmtex("t", 1.5, 0.5, 0.5, "u Layer in Temporal Graph");
}

void init_imgout_graphics()
{
  int i , k ; 
  char str[100];

  plsstrm(1);
  plSetOpt("geometry",geometry_slave4);

  plsdev(driver);
  plscmap0n(101);
  plinit();
  plscmap0(C,C,C,101);
  pladv(0); 

  plcol(100);
  plvpor(0.1, 0.9, 0.1, 0.9);
  plwind(0.0, 100.0, 0.0, 100.0);

  plcol(100);
  plbox("bcgt", 1, 0, "bcgt", 1, 0);

}

void didday_imgout_graphics()
{
  int i,j,k;
  PLFLT x, y ;

  plsstrm(1);

  k = 16;
  y = 0.5;      
  for (i = 1; i <= 100; i++) {
    for (j = 1; j <= 100; j++) {
      x = i+0.5;
      y = j+0.5;

      //    printf ("ij: %d \n", (int)(IMG_OUT(i,j)*100));
      //    plcol( (int)(IMG_OUT(i,j)*100) );
      plcol  ((int)(IMG_OUT(i,j)*100));
      /* Display the symbols (plpoin expects that x and y are arrays so */
      /* pass pointers) */
      plpoin (1,&x,&y,k);
    }
  } 
}   


void didday_Ugraphics()
{
  int i,j,k;
  PLFLT x, y ;

  x = (PLFLT) NSL_SIM->clock() ;

  plsstrm(1);
  

  for (k=1; k<=50; ++k) {
    pladv(k); 

    y = U(1,k) ;


    plvpor(0.0,1.00,  0.4,0.6);
    plwind( 0.0, 20.0, Umin, Umax );

    plpoin(1, &x, &y, -1);
  }
}

void didday_S()
{
  S(1,5) = 1.0 ;
  S(1,7) = 0.5 ;
}

void didday_S1()
{
  int i;
  S1 = 0;

  for (i=15; i <= 35; ++i) {
    S1(1,i) = 1.0 ;
  }

}

void didday_S2()
{
  int i;
  S2 = 0;

  for (i=15; i <= 35; ++i) {
    S2(1,i) = 1.0 - ( (35. - i) / (35. - 15.) ) ;
  }

}

void didday_S3()
{
  int i;
  S3 = 0;

  for (i=15; i <= 20; ++i) {
    S3(1,i) = 1.0 ;
    S3(1,i+15) = 1.0 ;
  }

}

void didday_U()
{
  nslDiff udiff;

  //  u.print("u");
  //  weight_mask.print("weight_mask");
  //  S3.print("S3");
  udiff.eq(u,tu) = -u + nslConvZero(weight_mask,S2); 



  U = melSigmoid(u,3,0.5);
  //U=u;

  //  u.print ("u");
  //  U.print ("U");
}

void conv_img_out()
{
  nslDiff odiff;

  printf("conv_img_out()\n");

  //  u.print("u");
  //  weight_mask.print("weight_mask");
  //  S3.print("S3");
  odiff.eq(img_out,to) = -img_out + nslConvZero(img_mask2,img); 


  //  IMG_OUT = img;
  //  IMG_OUT = melSigmoid(img_out,3,4);
  IMG_OUT = melSigmoid(img_out,1.0,0.75);
}

void didday_graphics()
{
  int i,j,k;
  PLFLT x, y ;

  x = (PLFLT) sim->clock() ;

  for (k=1; k<=10; ++k) {
    pladv(k); 

    y = u(1,k) ;

    //    cout << "x: " << x << endl ;
    // cout << "u(" << k << ")" << y << endl ;
    //pls.col(Red);
    plvsta();
    plwind( 0.0, 20.0, -2.0, 2.0 );

    //pls.col(Red);
    plpoin(1, &x, &y, 1);
  }
}

void gfx_init()
{
  plinit();
  plenv(0.0,20.0,   -2.0,2.0,      1,1);
}

void gfx()
{

  matrix m = u ;

  int i, j;
  PLFLT *x, *y, **z;
  PLFLT
    xmin2d =  0.0,
    xmax2d = 20.0,
    ymin2d = -2.0,
    ymax2d =  2.0,
   
    basex  =  2.0,
    basey  =  4.0,
    height =  3.0,

    xmin   =  0.0,
    xmax   = 11.0,
    ymin   =  0.0,
    ymax   = 11.0,
    zmin   = -2.0,
    zmax   =  2.0,

    alt    = 45.0,
    az     = 30.0;

  int
    side   = 1;

  x =  (PLFLT *) malloc (m.nCols() * sizeof(PLFLT));
  y =  (PLFLT *) malloc (m.nCols() * sizeof(PLFLT));
  z = (PLFLT **) malloc (m.nCols() * sizeof(PLFLT *));

  for (i = 0; i < m.nCols(); ++i) {
    z[i] = (PLFLT *) malloc (m.nRows() * sizeof(PLFLT)); // crt col
    cout << z[i][0] << endl;
    x[i] = (PLFLT) i ;
    y[i] = (PLFLT) i ;
    cout << "----\n";
  }

  cout << "rows? " << m.nRows() << endl;
  cout << "cols? " << m.nCols() << endl;


  for (i = 0; i < m.nRows(); ++i) 
    {
      for (j = 0; j < m.nCols(); ++j) 
        {
          cout << "i: " << i << " j: " << j << endl;
          cout << u(i+1,j+1) << endl;
          cout << z[j][i] << endl;
          z[j][i] = u(i+1,j+1);
        }
    }



  pleop();
  plbop();

  plcol(1);
  plw3d(basex,basey,height,xmin,xmax,ymin,ymax,zmin,zmax,alt,az);
  plbox3("bnstu","x axis",0.0,0,
           "bnstu","y axis",0.0,0,
           "bcdmnstuv","z axis",0.0,0);
  plot3d(x, y, z, u.nCols(), u.nRows(), 3, side);

}


application::application(int argc,char** argv) : session(argc,argv,"didday")
{
  cout << "didday" << endl;
/*
  pls.MergeOpts(options,"x01c options", notes);
  pls.ParseOpts(&argc, argv, PL_PARSE_FULL);
*/
}

int application::main()
{
  sim = new simulation();

  nslModule *m ;
  nslInitModule *n;

  delta = 0.1 ;

  n = new nslInitModule("didday_init_variables",didday_init_variables, 
NSL_SIM->delta());
  //      n = new 
nslInitModule("didday_init_S1graphics",didday_init_S1graphics, 
NSL_SIM->delta());
  // n = new nslInitModule("didday_init_S2graphics",didday_init_S2graphics, 
NSL_SIM->delta());
  //   n = new nslInitModule("didday_init_S3graphics",didday_init_S3graphics, 
NSL_SIM->delta());
  n = new nslInitModule("init_grayscale_graphics",init_grayscale_graphics, 
NSL_SIM->delta());
  n = new nslInitModule("didday_grayscale_graphics",didday_grayscale_graphics, 
NSL_SIM->delta());
  n = new nslInitModule("init_imgout_graphics",init_imgout_graphics, 
NSL_SIM->delta());
  // n = new nslInitModule("didday_init_Ugraphics",didday_init_Ugraphics, 
NSL_SIM->delta());

  //  n = new nslInitModule("gfx",gfx_init, NSL_SIM->delta());
  // n = new nslInitModule("didday_S1",didday_S1, NSL_SIM->delta());
  // n = new nslInitModule("didday_S2",didday_S2, NSL_SIM->delta());
  //  n = new nslInitModule("didday_S3",didday_S3, NSL_SIM->delta());

  NSL_SIM->duration(20.0);

  m = new nslModule("conv_img_out",conv_img_out, NSL_SIM->delta());

  //  m = new nslModule("didday_S",didday_S, NSL_SIM->delta());
  // m = new nslModule("didday_U",didday_U, NSL_SIM->delta());


  // m = new nslModule("didday_S1graphics",didday_S1graphics, NSL_SIM->delta());

  // m = new nslModule("didday_S2graphics",didday_S2graphics, NSL_SIM->delta());
  // m = new nslModule("didday_S3graphics",didday_S3graphics, NSL_SIM->delta());
  // m = new nslModule("didday_Ugraphics",didday_Ugraphics, NSL_SIM->delta());
  m = new nslModule("didday_imgout_graphics",didday_imgout_graphics, 
NSL_SIM->delta());

  //  m = new nslModule("gfx",gfx, NSL_SIM->delta());

  printf ("running....\n");


  NSL_SIM->run(20.0);
  plend1() ;
}

int main(int argc,char** argv)
{
  session* s = new application(argc,argv);
  s -> run();
  exit(0);
}

}

@End @SubSection
@EndSubSections



@End @Section


-- 
  Terrence Brannon * address@hidden * http://quake.usc.edu/~brannon
     USC, HNB, 3614 Way, Los Angeles, CA 90089-2520 * (213) 740-3397