class CIRCS_IN_CIRCLE
creation
  go
feature

  go is
  local
    x, y, r, theta, radius, radscale : REAL
    i, count : INTEGER
    rand : STD_RAND
    pair : GBN_KEYED_PAIR [REAL, GBN_PAIR [REAL, REAL] ]
    yrad : GBN_PAIR [REAL, REAL]
    heap : GBN_HEAP [ GBN_KEYED_PAIR [REAL, GBN_PAIR [REAL, REAL] ] ]
    mc : MATH_CONSTANTS
    twopi : REAL
  do
	-- this part is the nasty part

    if (argument_count < 1 or argument_count > 3) or else
	(not argument(1).is_integer) or else
	(argument_count >= 2 and then
	  not argument(2).is_real) or else
	(argument_count = 3 and then
	  not argument(3).is_integer)
    then
      std_error.put_string(argument(0) + 
        " expects integer args: count, optional rad bound, optional seed%N")
    else
      radscale := 0.05
      count := argument(1).to_integer
      if argument_count >= 2 then
        radscale := argument(2).to_real
      end

      if argument_count = 3 then
	!! rand . with_seed ( argument(3).to_integer )
      else
	!! rand . make
      end

	-- this part is the nice part

      !! heap . make
      twopi := ( 2 * mc.Pi).to_real

      from
	i := 1
      until
	i > count
      loop
	rand . next
	r := rand . last_real . sqrt . to_real
	rand . next
	theta := rand . last_real
	theta := theta * twopi
	x := 0.5 + 0.5 * r * ( theta.cos.to_real )
	y := 0.5 + 0.5 * r * ( theta.sin.to_real )
	rand . next
	radius := ( rand . last_real . abs ) * radscale ;

	!! pair . make ( x )
	!! yrad . make ( y, radius )
	pair . put ( yrad )
	heap . add ( pair, Void )
        i := i + 1
      end

      from
	io . put_integer ( heap.count )
	io . put_new_line
      until
        heap . is_empty
      loop
	pair := heap . min
	io . put_real ( pair . key )
	io . put_character (' ')
	io . put_real ( pair . item . x )
	io . put_character (' ')
	io . put_real ( pair . item . y )
	io . put_new_line
	heap . delete_min
      end
    end -- if valid arguments
  end -- routine go
end -- class CIRCS_IN_CIRCLE