                 ------------------------------------------
                 The Fuzzy-C Development System Version 2.3
                 ------------------------------------------

Togai InfraLogic has released version 2.3 of the Fuzzy-C Development System.
New features in version 2.3 include a new debugger and generated C code that
is more efficient.

New Debugger
------------

The debugger included with the Fuzzy-C Development System has been completely
rewritten to provide more capabilities and features.  Using the new debugger,
you can:

o Automatically generate C programs which test the response of your fuzzy
  expert system against a given set of inputs.

o Automatically generate input values into your fuzzy expert system from a
  variety of sources.

o Store inputs, outputs, local variables, membership levels, and rule
  activation levels in a file for later analysis.

o Interface easily to spreadsheet programs or graphing programs to analyze the
  output data.

o Use the TILChart graphical analysis tool to analyze the output data.

o Trace embedded systems and store the results in a memory buffer and
  optionally a TILChart compatible file.

The advantage of the new debugger is that little or no manual C programming is
required.  In most cases, the Fuzzy-C Compiler generates all the C code needed
automatically, including the procedure main( ).  All you have to do is specify
a command line option and optional VAR options, and the Fuzzy-C Compiler does
the rest for you.

The new debugger supports several different techniques for generating input
values for your fuzzy expert system.  Inputs can be typed by the user, read
from a text file, calculated from C expressions or generated by a loop covering
a subset of all possible values of the input variable.  Depending on how you
combine the different input sources, you can test your system several ways.  

For example, if you are prompted for each input, you can interactively feed
inputs into the system and examine the results.  

To analyze the effects of varying one or more input variables while holding
others constant, you can use C expressions to set some variables to constants,
then use a loop to generate a subset of all possible values for the variables
you want to change.  Alternatively, you can be prompted for the values of the
variables you want to change.

To test the effects of changes made to the membership functions and rules in
your fuzzy expert system, you can define a series of test vectors in a file,
then input the values from the file after each set of changes you make.

Using a combination of C expressions and functions defined in a SOURCE object,
you can write a simple simulation of your system.  Use C functions in the
SOURCE to calculate each input, then specify each input as a call to one of
the functions in your SOURCE.

To plot a control surface, you can use loops to generate all possible
combinations of input variables and then use your favorite graphing program to
plot the results.

In each of these examples, the new debugger helps to cut down on the amount of
work you have to do, and in some cases, all of the code required is generated
automatically.

Analyzing the Results
---------------------

After running the test program, you can send the results to a file for
analysis.  A very simple way to do this is by visually inspecting the results.
Another way would be to import the output data into your spreadsheet or
graphing program.  The new debugger includes several options to produce data
files easily read by most spreadsheets and graphing programs.  Finally, if you
don't already have a spreadsheet or graphing program, you can use the TILChart
Graphical Analysis Tool.

TILChart is a stand alone program that runs on IBM PCs and compatibles under
Microsoft Windows 3.0, as well as on the Macintosh.  We now ship TILChart with
the Fuzzy-C Development System.
  
TILChart is a graphical analysis tool which provides a way to graphically view
the inputs, outputs, local variables, membership levels and rule activation
levels of a fuzzy expert system.  It takes as input the data file resulting
from the execution of an FPL file compiled with the -g command line option and
produces the charts (graphs) you specify from the data values.  TILChart
remembers the charts you have defined and stores them in a chart file which you
can edit.  TILChart will graph strip charts, multiple strip charts,
correlations and multiple correlations.

The Chart Editor, shown in Figure 1 [not included in this text-only version],
makes it very easy to create charts.  Two list boxes (one for the horizontal
axis and one for the vertical axis) allow you to select the variables you want
to graph on each axis.  You simply click on the variables you want to graph,
give the chart a title, and click OK.  TILChart then graphs the chart you have
created as in Figure 2 [not included in this text-only version].

All object names as well as the hierarchical structure of your fuzzy expert
system are carried over into TILChart from the Fuzzy-C Development System.
When selecting which variables to graph on the X and Y axes, you know which
membership function belongs to which variable, and which rule belongs to which
fuzzy, etc.
  
More Efficient Output C Code
----------------------------

Release 2.3 of the Fuzzy-C Development System also generates more efficient C
code.  In some cases the default behavior of the compiler was changed, and in
other cases, new command line options were added to activate optional
optimizations.  The following improvements were made:

o Changed the compiler to do common input member factoring by default.  If
  common input members are used in rule premises, the emitted code evaluates
  these members once, stores the result in a temporary variable, and then uses
  the temporary variable where ever the input member was used.  Depending on
  the how often input members are reused, this improvement can have major
  impacts on the performance of your fuzzy expert system.  This optimization
  can be turned off using the -XC option.

o Added the -XI command line option to disable IF's on rule right hand sides.
  By default, the code the Fuzzy-C Compiler emits for the conclusion of each
  rule has an IF test that prevents the rule from modifying the running moment
  and area totals when the rule activation level is 0.  The idea is to not
  waste time doing multiplication by 0.  However, on some processors, it is
  faster to multiply than to do a jump which can cause a pipe break.  If you
  want to disable ifs on rule right hand sides, use the -XI option.

o Changed the compiler to do rule premise merging by default.  When your fuzzy
  expert system has common rule right hand sides, this optimization saves
  extra additions and multiplications by summing the rule activation levels
  and then updating the running moment and area totals only once instead of
  once for each rule.  This optimization can be turned off using the -XM
  option.

o Added the -XS command line option to disable scaling of output membership
  functions.  This does not result in a performance increase, but it makes the
  emitted C code easier to read and modify in order to tune output membership
  functions.

Contact Togai InfraLogic for information on how to upgrade your Fuzzy-C
Development System to version 2.3 or for ordering information.
--
Copyright (c) Togai InfraLogic, 1992.  All rights reserved.
Permission to freely distribute this document, provided that it remains
complete and intact, is hereby granted.
