X-Envelope-to: csg-l@UIUCVMD.BITNET
X-VMS-To: IN%"csg-l@uiucvmd.bitnet"
X-VMS-Cc: ELEMHANS
Content-type: TEXT/PLAIN; CHARSET=US-ASCII
Content-transfer-encoding: 7BIT
Mime-Version: 1.0
Newsgroups: bit.listserv.csg-l
Date:         Mon, 7 Sep 1992 15:49:40 +0100
From:         HANS BLOM <ELEMHANS@URC.TUE.NL>
Subject:      replies and a demo

[From Hans Blom (920907)]

Some replies and remarks. Sorry for the delay. My modem broke down and I had to
    wait
for a new one.


Avery Andrews 920901.0957

>The anesthesia monitoring systems sounds like an instructive integration
>of thought and action - is there a comprehensive writeup anywhere?

Expert control of the  arterial blood pressure during surgery.  International Jo
   urnal
of Clinical Monitoring and Computing 8: 25-34, 1991.


Rick Marken (920831.1100)

>Right. "The test for the controlled variable" is how you determine whether
>or not control is involved in any observed behavior.

I agree. But... This isn't  always feasable. Please run my coli  simulation (inc
   luded
below). Now 'The  Test', in  my opinion, would  mean to  pick up coli,  put him
    down
somewhere else,  observe its  behavior and  check whether the  change in  positi
   on is
resisted or undone. I  do not see resistance. I do not see behavior that is diff
   erent
from coli's normal behavior. Or is it there, but is the problem that I cannot se
   e it?
As I see it, coli is too primitive to be able to control. At most  it _tries to_
   , but
doesn't quite succeed. Maybe, in its environment, this is optimal?

>> Two:  what do  we  mean by 'control'?

>Production of consistent results in the face of disturbnce.

I  do not  recognize consistency  of results  when there  is so little  regulari
   ty in
behavior in the first place.

>By the way. Your description of your e. coli model was somewhat puzzling.
>When, for example, does your e. coli model change to a new direction?

At every step, i.e. every new run of the simulation.

>What is the criterion for change?

There is no criterion for  change. That would require a memory, which  I do not
   think
coli has. Every decision is new, based on the current observation only.

>In our models, a "counter" is set after each tumble. The rate at which it
>counts down depends on the currently experienced gradient of attractant.

In my model, coli has  neither a counter (memory) nor a sensor  to sense gradien
   ts. I
assume it is too primitive for either.

program e_coli;       { simulation of E. coli behavior }
{ written in Turbo Pascal for IBM-PC or compatible

  simulation ends     1. when a key is pressed
                      2. when coli escapes into infinity
                         (which so far it always did, eventually)
}

uses
  crt, graph;

const
  scale =  1.4;       {graphics scaling; adjust to zoom in/out}
  rad0 =  50.0;       {initial radius; coli is let go here}
  radx = 100.0;       {influence radius; outside this radius sensor no good}
  radw =  10.0;       {optimum feeding radius}
  rmax = 500.0;       {beyond this radius coli is considered lost}

var
  x, y, r:            real;        {current coordinates and radius}
  xm, ym, xxm, yym:   integer;     {screen pixel sizes}
  xs, ys:             real;        {scaling constants}
  c:                  char;        {stop simulation?}

procedure grinit; {initialize graphics stuff}
var
  driver, mode: integer;
begin
  detectgraph (driver, mode);
  initgraph (driver, mode, '');
  if graphresult <> grok then
    begin writeln ('cannot find graphics driver'); halt end;
  xm := getmaxx; ym := getmaxy;
  xxm := xm div 2; yym := ym div 2;
  xs := scale * xm / 200.0; ys := scale * ym / 150.0;
  { plot circles of radii 10, 50 and 100 }
  ellipse (xxm, yym, 0, 360, round ( 10.0 * xs), round ( 10.0 * ys));
  ellipse (xxm, yym, 0, 360, round ( 50.0 * xs), round ( 50.0 * ys));
  ellipse (xxm, yym, 0, 360, round (100.0 * xs), round (100.0 * ys))
end;

procedure move; {take one step}
var
  s, u, dx, dy : real;
  t: string [12];
begin
  {calculate response strength}
  s := r; if r > radx then s := radx;          {s = 0 .. radx}
  s := 0.2 * abs (s - radw);                   {step size, but ...}
  if s < 0.1 then s := 0.1;                    { ... minimum step size}

  {calculate random direction unit vector}
  dx := 2 * random - 1; dy := 2 * random - 1;  {select random direction}
  u := sqrt (dx * dx + dy * dy);
  dx := dx / u; dy := dy / u;                  {random unit vector}

  {do one move of length s}
  x := x + s * dx; y := y + s * dy;            {update position}
  r := sqrt (x * x + y * y);                   {compute new radius}

  {plot position as a pixel}
  putpixel (xxm + round (xs * x), yym + round (ys * y), white);

  {print radius in upper left corner}
  setviewport (1, 10, 60, 20, true); clearviewport;
  str (r:6:0, t); outtext (t);
  setviewport (0, 0, xm, ym, true)
end;

begin
  randomize;                                   {initialize random generator}
  grinit;                                      {initialize graphics}
  x := sqrt (0.5 * rad0 * rad0); y := x;       {initialize position}
  r := sqrt (x * x + y * y);
  repeat
    move                                       {take one step }
  until (abs (r - radw) > rmax) or keypressed; {till coli lost or you tired}
  c := readkey;
  closegraph
end.
Comments: Gated by NETNEWS@AUVM.AMERICAN.EDU