Difference: AMPLSyntax (1 vs. 9)

Revision 92008-04-02 - MichaelOSullivan

Line: 1 to 1
 
META TOPICPARENT name="AMPLGuide"
<-- Ready to Review - done - Lauren-->

The AMPL Syntax Guide

Line: 16 to 16
 
  1. Logical Statements
  2. Looping Statements
  3. Displaying and Printing
Changed:
<
<
  1. Miscellaneous AMPL Commands Coming soon!
>
>
  1. Miscellaneous AMPL Commands
 

Commenting

Revision 82008-03-18 - TWikiAdminUser

Line: 1 to 1
 
META TOPICPARENT name="AMPLGuide"
<-- Ready to Review - done - Lauren-->

The AMPL Syntax Guide

Line: 23 to 23
 The # is used for commenting, any characters on a line after the # are ignored by AMPL.

Examples

Changed:
<
<
The Whiskas Cat Food Problem
# The set of all possible ingredients for the cat food set INGREDIENTS; 
>
>
The Whiskas Cat Food Problem

# The set of all possible ingredients for the cat food set INGREDIENTS; 
  The Surfboard Production Problem
Added:
>
>
 

Changed:
<
<
param Resin {SURFBOARDS} >= 0; # Amount of resin (in kilos) needed for a board param TotalResin >= 0; # Total amount of resin available
>
>
param Supply {MATERIALS}; # The supply of each raw material

param Recipe {MATERIALS, SURFBOARDS}; # The "recipe" for making surfboards

 

Using =symbolic

Revision 72008-03-18 - TWikiAdminUser

Line: 1 to 1
 
META TOPICPARENT name="AMPLGuide"
<-- Ready to Review - done - Lauren-->

The AMPL Syntax Guide

Line: 13 to 13
 
  1. Expressions
  2. Objective Functions
  3. Constraints
Changed:
<
<
  1. Logical Statements Coming soon!
>
>
  1. Logical Statements
 
  1. Looping Statements
  2. Displaying and Printing
  3. Miscellaneous AMPL Commands Coming soon!

Revision 62008-03-18 - TWikiAdminUser

Line: 1 to 1
 
META TOPICPARENT name="AMPLGuide"
<-- Ready to Review - done - Lauren-->

The AMPL Syntax Guide

Line: 13 to 13
 
  1. Expressions
  2. Objective Functions
  3. Constraints
Changed:
<
<
  1. Logical Statements Fix this link - Lauren
  2. Looping Statements Fix this link - Lauren
>
>
  1. Logical Statements Coming soon!
  2. Looping Statements
 
  1. Displaying and Printing
Changed:
<
<
  1. Miscellaneous AMPL Commands Fix this link - Lauren
>
>
  1. Miscellaneous AMPL Commands Coming soon!
 

Commenting

Revision 52008-03-11 - MichaelOSullivan

Line: 1 to 1
 
META TOPICPARENT name="AMPLGuide"
<-- Ready to Review - done - Lauren-->

The AMPL Syntax Guide

Line: 18 to 18
 
  1. Displaying and Printing
  2. Miscellaneous AMPL Commands Fix this link - Lauren
Changed:
<
<

Commenting Fix stacking on this page - Lauren

>
>

Commenting

  The # is used for commenting, any characters on a line after the # are ignored by AMPL.
Line: 26 to 26
 The Whiskas Cat Food Problem
# The set of all possible ingredients for the cat food set INGREDIENTS; 

The Surfboard Production Problem

Changed:
<
<
param Resin {SURFBOARDS} >= 0; # Amount of resin (in kilos) needed for a board param TotalResin >= 0; # Total amount of resin available 
>
>
param Resin {SURFBOARDS} >= 0; # Amount of resin (in kilos) needed for a board
param TotalResin >= 0; # Total amount of resin available
 

Using =symbolic

The symbolic keyword is used to create parameters that represent character strings. Usually they are used to represent members of 1-dimensional sets or part of a tuple for multi-dimensional sets. However, they can also be used to represent file names or to automatically build labels (for entry in a set, for example).

Example. Searching a 1-Dimensional set

Changed:
<
<
param gotcha symbolic within SET; for {s in SET} {   if  then     let gotcha := s; } # gotcha now contains the (last) element in SET that satisfies the condition 
>
>
param gotcha symbolic within SET;
for {s in SET} {
   if  then
     let gotcha := s;
} # gotcha now contains the (last) element in SET that satisfies the condition
 

Example. Searching a 2-Dimensional Set

Changed:
<
<
set SET1; set SET2;  set TWO_D_SET within SET1 cross SET2;  param got_one symbolic within SET1; param got_two symbolic within SET2;  for {(s, t)  in TWO_D_SET} {   if  then {     let got_one := s;     let got_two := t;   } } # (got_one, got_two) now contains the (last) element in TWO_D_SET # that satisfies the condition 
>
>
set SET1;
set SET2;

set TWO_D_SET within SET1 cross SET2;

param got_one symbolic within SET1;
param got_two symbolic within SET2;

for {(s, t)  in TWO_D_SET} {
   if  then {
     let got_one := s;
     let got_two := t;
   }
} # (got_one, got_two) now contains the (last) element in TWO_D_SET # that satisfies the condition
  To build labels for set elements you need a symbolic parameter and the parts of the label. You can then "glue" the parts of the label together by enclosing the label within ( and ) and joining the parts with &. The parts can be set elements, strings or numbers. Numbers are converted to strings using the %g format from printf .
Added:
>
>
 

Example. Dynamically Building a Set

Changed:
<
<
param name symbolic;  let SUPPLY_NODES := {}; for {s in SUPPLY_LOCATIONS} {   let name := (s & '-Woodchips');   let SUPPLY_NODES := SUPPLY_NODES union {name};   let Supply[name] := MaterialSupply[s, 'Woodchips'];   let {d in DEMAND_NODES} Cost[name, d] := TransportationCost[s, d];   let dummyDemandCost[name] := DisposalCost['Woodchips']; } 
>
>
param name symbolic;

let SUPPLY_NODES := {};

for {s in SUPPLY_LOCATIONS} {
   let name := (s & '-Woodchips');
   let SUPPLY_NODES := SUPPLY_NODES union {name};
   let Supply[name] := MaterialSupply[s, 'Woodchips'];
   let {d in DEMAND_NODES} Cost[name, d] := TransportationCost[s, d];
   let dummyDemandCost[name] := DisposalCost['Woodchips'];
}
  -- MichaelOSullivan - 27 Feb 2008

Revision 42008-03-09 - LaurenJackson

Line: 1 to 1
 
META TOPICPARENT name="AMPLGuide"
Changed:
<
<
<-- Ready to Review -->
>
>
<-- Ready to Review - done - Lauren-->
 

The AMPL Syntax Guide

Disclaimer This is a guide to the AMPL syntax only. For a comprehensive reference to the AMPL language see AMPL: A Modeling Language for Mathematical Programming.

  1. Commenting
Changed:
<
<
  1. Using symbolic
>
>
  1. Using symbolic
 
  1. Sets
  2. Variables
  3. Parameters
  4. Expressions
  5. Objective Functions
  6. Constraints
Changed:
<
<
  1. Logical Statements
  2. Looping Statements
>
>
  1. Logical Statements Fix this link - Lauren
  2. Looping Statements Fix this link - Lauren
 
  1. Displaying and Printing
Changed:
<
<
  1. Miscellaneous AMPL Commands
>
>
  1. Miscellaneous AMPL Commands Fix this link - Lauren
 
Changed:
<
<

Commenting

>
>

Commenting Fix stacking on this page - Lauren

  The # is used for commenting, any characters on a line after the # are ignored by AMPL.

Examples

Changed:
<
<
The Whiskas Cat Food Problem
# The set of all possible ingredients for the cat food
set INGREDIENTS;

The Surfboard Production Problem

param Resin {SURFBOARDS} >= 0; # Amount of resin (in kilos) needed for a board
param TotalResin >= 0; # Total amount of resin available
>
>
The Whiskas Cat Food Problem
# The set of all possible ingredients for the cat food set INGREDIENTS; 

The Surfboard Production Problem

param Resin {SURFBOARDS} >= 0; # Amount of resin (in kilos) needed for a board param TotalResin >= 0; # Total amount of resin available 
 

Using =symbolic

The symbolic keyword is used to create parameters that represent character strings. Usually they are used to represent members of 1-dimensional sets or part of a tuple for multi-dimensional sets. However, they can also be used to represent file names or to automatically build labels (for entry in a set, for example).

Example. Searching a 1-Dimensional set

Changed:
<
<
param gotcha symbolic within SET;
for {s in SET} {
  if  then
    let gotcha := s;
}
# gotcha now contains the (last) element in SET that satisfies the condition
>
>
param gotcha symbolic within SET; for {s in SET} {   if  then     let gotcha := s; } # gotcha now contains the (last) element in SET that satisfies the condition 
 

Example. Searching a 2-Dimensional Set

Changed:
<
<
set SET1;
set SET2;

set TWO_D_SET within SET1 cross SET2;

param got_one symbolic within SET1;
param got_two symbolic within SET2;

for {(s, t)  in TWO_D_SET} {
  if  then {
    let got_one := s;
    let got_two := t;
  }
}
# (got_one, got_two) now contains the (last) element in TWO_D_SET
# that satisfies the condition
>
>
set SET1; set SET2;  set TWO_D_SET within SET1 cross SET2;  param got_one symbolic within SET1; param got_two symbolic within SET2;  for {(s, t)  in TWO_D_SET} {   if  then {     let got_one := s;     let got_two := t;   } } # (got_one, got_two) now contains the (last) element in TWO_D_SET # that satisfies the condition 
 
Changed:
<
<
To build labels for set elements you need a symbolic parameter and the parts of the label. You can then "glue" the parts of the label together by enclosing the label within ( and ) and joining the parts with &. The parts can be set elements, strings or numbers. Numbers are converted to strings using the %g format from printf .
>
>
To build labels for set elements you need a symbolic parameter and the parts of the label. You can then "glue" the parts of the label together by enclosing the label within ( and ) and joining the parts with &. The parts can be set elements, strings or numbers. Numbers are converted to strings using the %g format from printf .
 

Example. Dynamically Building a Set

Changed:
<
<
param name symbolic;

let SUPPLY_NODES := {};
for {s in SUPPLY_LOCATIONS} {
  let name := (s & '-Woodchips');
  let SUPPLY_NODES := SUPPLY_NODES union {name};
  let Supply[name] := MaterialSupply[s, 'Woodchips'];
  let {d in DEMAND_NODES} Cost[name, d] := TransportationCost[s, d];
  let dummyDemandCost[name] := DisposalCost['Woodchips'];
}
>
>
param name symbolic;  let SUPPLY_NODES := {}; for {s in SUPPLY_LOCATIONS} {   let name := (s & '-Woodchips');   let SUPPLY_NODES := SUPPLY_NODES union {name};   let Supply[name] := MaterialSupply[s, 'Woodchips'];   let {d in DEMAND_NODES} Cost[name, d] := TransportationCost[s, d];   let dummyDemandCost[name] := DisposalCost['Woodchips']; } 
  -- MichaelOSullivan - 27 Feb 2008

Revision 32008-02-27 - MichaelOSullivan

Line: 1 to 1
 
META TOPICPARENT name="AMPLGuide"
Added:
>
>
<-- Ready to Review -->
 

The AMPL Syntax Guide

Changed:
<
<
Disclaimer This is a guide to the AMPL syntax only. For a comprehensive reference to the AMPL language see AMPL: A Modeling Language for Mathematical Programming.
>
>
Disclaimer This is a guide to the AMPL syntax only. For a comprehensive reference to the AMPL language see AMPL: A Modeling Language for Mathematical Programming.
 
  1. Commenting
  2. Using symbolic
Changed:
<
<
  1. Sets
  2. Variables
  3. Parameters
  4. Expressions
  5. Objective Functions
  6. Constraints
  7. Logical Statements
  8. Looping Statements
  9. Displaying and Printing
>
>
  1. Sets
  2. Variables
  3. Parameters
  4. Expressions
  5. Objective Functions
  6. Constraints
  7. Logical Statements
  8. Looping Statements
  9. Displaying and Printing
 
  1. Miscellaneous AMPL Commands

Commenting

Line: 22 to 23
 The # is used for commenting, any characters on a line after the # are ignored by AMPL.

Examples

Changed:
<
<
The Whiskas Cat Food Problem
# The set of all possible ingredients for the cat food set INGREDIENTS; 
The Surfboard Production Problem
param Resin {SURFBOARDS} >= 0; # Amount of resin (in kilos) needed for a board param TotalResin >= 0; # Total amount of resin available 
>
>
The Whiskas Cat Food Problem
# The set of all possible ingredients for the cat food
set INGREDIENTS;

The Surfboard Production Problem

param Resin {SURFBOARDS} >= 0; # Amount of resin (in kilos) needed for a board
param TotalResin >= 0; # Total amount of resin available
 

Using =symbolic

The symbolic keyword is used to create parameters that represent character strings. Usually they are used to represent members of 1-dimensional sets or part of a tuple for multi-dimensional sets. However, they can also be used to represent file names or to automatically build labels (for entry in a set, for example).

Example. Searching a 1-Dimensional set

Changed:
<
<
param gotcha symbolic within SET; for {s in SET} {   if  then     let gotcha := s; } # gotcha now contains the (last) element in SET that satisfies the condition 
>
>
param gotcha symbolic within SET;
for {s in SET} {
  if  then
    let gotcha := s;
}
# gotcha now contains the (last) element in SET that satisfies the condition
 

Example. Searching a 2-Dimensional Set

Changed:
<
<
set SET1; set SET2;  set TWO_D_SET within SET1 cross SET2;  param got_one symbolic within SET1; param got_two symbolic within SET2;  for {(s, t)  in TWO_D_SET} {   if  then {     let got_one := s;     let got_two := t;   } } # (got_one, got_two) now contains the (last) element in TWO_D_SET # that satisfies the condition 
>
>
set SET1;
set SET2;

set TWO_D_SET within SET1 cross SET2;

param got_one symbolic within SET1;
param got_two symbolic within SET2;

for {(s, t)  in TWO_D_SET} {
  if  then {
    let got_one := s;
    let got_two := t;
  }
}
# (got_one, got_two) now contains the (last) element in TWO_D_SET
# that satisfies the condition
 
Changed:
<
<
To build labels for set elements you need a symbolic parameter and the parts of the label. You can then "glue" the parts of the label together by enclosing the label within ( and ) and joining the parts with &. The parts can be set elements, strings or numbers. Numbers are converted to strings using the =%g= format from =printf= .
>
>
To build labels for set elements you need a symbolic parameter and the parts of the label. You can then "glue" the parts of the label together by enclosing the label within ( and ) and joining the parts with &. The parts can be set elements, strings or numbers. Numbers are converted to strings using the %g format from printf .
 

Example. Dynamically Building a Set

Changed:
<
<
param name symbolic;  let SUPPLY_NODES := {}; for {s in SUPPLY_LOCATIONS} {   let name := (s & '-Woodchips');   let SUPPLY_NODES := SUPPLY_NODES union {name};   let Supply[name] := MaterialSupply[s, 'Woodchips'];   let {d in DEMAND_NODES} Cost[name, d] := TransportationCost[s, d];   let dummyDemandCost[name] := DisposalCost['Woodchips']; } 
>
>
param name symbolic;

 
Changed:
<
<

Sets in AMPL

Variables

Parameters

Expressions

Objective Function

Constraints

Logical Statements

Looping Statements

Displaying and Printing

Miscellaneous AMPL Commands

>
>
let SUPPLY_NODES := {}; for {s in SUPPLY_LOCATIONS} { let name := (s & '-Woodchips'); let SUPPLY_NODES := SUPPLY_NODES union {name}; let Supply[name] := MaterialSupply[s, 'Woodchips']; let {d in DEMAND_NODES} Cost[name, d] := TransportationCost[s, d]; let dummyDemandCost[name] := DisposalCost['Woodchips']; }
  -- MichaelOSullivan - 27 Feb 2008

Revision 22008-02-27 - MichaelOSullivan

Line: 1 to 1
 
META TOPICPARENT name="AMPLGuide"

The AMPL Syntax Guide

Changed:
<
<
Disclaimer This is a *guide* to the AMPL syntax only. For a comprehensive reference to the AMPL language see AMPL: A Modeling Language for Mathematical Programming.
>
>
Disclaimer This is a guide to the AMPL syntax only. For a comprehensive reference to the AMPL language see AMPL: A Modeling Language for Mathematical Programming.
 
Changed:
<
<
  1. Commenting
  2. Using {\tt symbolic}
  3. Sets
  4. Variables
  5. Parameters
  6. Expressions
  7. Objective Functions
  8. Constraints
  9. Logical Statements
  10. Looping Statements
  11. Displaying and Printing
  12. Miscellaneous AMPL Commands

Commenting

The {\tt #} is used for commenting, any characters after the {\tt #} are ignored by AMPL.

Examples

The Whiskas Cat Food Problem

\begin{verbatim} var x1 >= 0; # Percentage chicken meat used in 100g of cat food (= g) \end{verbatim}

The Surfboard Production Problem

\begin{verbatim} param Resin {SURFBOARDS} >= 0; # Amount of resin (in kilos) needed for a board param TotalResin >= 0; # Total amount of resin available \end{verbatim}

Using {\tt symbolic}

The {\tt symbolic} keyword is used to create parameters that represent character strings. Usually they are used to represent members of 1-dimensional sets or part of a tuple for multi-dimensional sets. However, they can also be used to represent file names or to automatically build labels (for entry in a set, for example).

Example. Searching a 1-Dimensional set

\begin{verbatim} param gotcha symbolic within SET; for {s in SET} { if then let gotcha := s; } # gotcha now contains the (last) element in SET that satisfies the condition \end{verbatim}

Example. Searching a 2-Dimensional Set

\begin{verbatim} set SET1; set SET2;

set TWO_D_SET within SET1 cross SET2;

param got_one symbolic within SET1; param got_two symbolic within SET2;

for {(s, t) in TWO_D_SET} { if then { let got_one := s; let got_two := t; } } # (got_one, got_two) now contains the (last) element in TWO_D_SET # that satisfies the condition \end{verbatim}

To build labels for set elements you need a {\tt symbolic} parameter and the parts of the label. You can then "glue" the parts of the label together by enclosing the label within {\tt (} and {\tt )} and joining the parts with {\tt &}. The parts can be set elements, strings or numbers. Numbers are converted to strings using the {\tt %g} format from {\tt printf}.

Example. Dynamically Building a Set

\begin{verbatim} param name symbolic;

let SUPPLY_NODES := {}; for {s in SUPPLY_LOCATIONS} { let name := (s & '-Woodchips'); let SUPPLY_NODES := SUPPLY_NODES union {name}; let Supply[name] := MaterialSupply[s, 'Woodchips']; let {d in DEMAND_NODES} Cost[name, d] := TransportationCost[s, d]; let dummyDemandCost[name] := DisposalCost['Woodchips']; } \end{verbatim}

Sets

Variables

Parameters

Expressions

Objective Function

Constraints

>
>
  1. Commenting
  2. Using symbolic
  3. Sets
  4. Variables
  5. Parameters
  6. Expressions
  7. Objective Functions
  8. Constraints
  9. Logical Statements
  10. Looping Statements
  11. Displaying and Printing
  12. Miscellaneous AMPL Commands
 
Changed:
<
<
Logical Statements
>
>

Commenting

 
Changed:
<
<
Looping Statements
>
>
The # is used for commenting, any characters on a line after the # are ignored by AMPL.
 
Changed:
<
<
Displaying and Printing
>
>

Examples

The Whiskas Cat Food Problem
# The set of all possible ingredients for the cat food set INGREDIENTS; 
The Surfboard Production Problem
param Resin {SURFBOARDS} >= 0; # Amount of resin (in kilos) needed for a board param TotalResin >= 0; # Total amount of resin available 
 
Changed:
<
<
Miscellaneous AMPL Commands
>
>

Using =symbolic

The symbolic keyword is used to create parameters that represent character strings. Usually they are used to represent members of 1-dimensional sets or part of a tuple for multi-dimensional sets. However, they can also be used to represent file names or to automatically build labels (for entry in a set, for example).

Example. Searching a 1-Dimensional set

param gotcha symbolic within SET; for {s in SET} {   if  then     let gotcha := s; } # gotcha now contains the (last) element in SET that satisfies the condition 

Example. Searching a 2-Dimensional Set

set SET1; set SET2;  set TWO_D_SET within SET1 cross SET2;  param got_one symbolic within SET1; param got_two symbolic within SET2;  for {(s, t)  in TWO_D_SET} {   if  then {     let got_one := s;     let got_two := t;   } } # (got_one, got_two) now contains the (last) element in TWO_D_SET # that satisfies the condition 

To build labels for set elements you need a symbolic parameter and the parts of the label. You can then "glue" the parts of the label together by enclosing the label within ( and ) and joining the parts with &. The parts can be set elements, strings or numbers. Numbers are converted to strings using the =%g= format from =printf= .

Example. Dynamically Building a Set

param name symbolic;  let SUPPLY_NODES := {}; for {s in SUPPLY_LOCATIONS} {   let name := (s & '-Woodchips');   let SUPPLY_NODES := SUPPLY_NODES union {name};   let Supply[name] := MaterialSupply[s, 'Woodchips'];   let {d in DEMAND_NODES} Cost[name, d] := TransportationCost[s, d];   let dummyDemandCost[name] := DisposalCost['Woodchips']; } 

Sets in AMPL

Variables

Parameters

Expressions

Objective Function

Constraints

Logical Statements

Looping Statements

Displaying and Printing

Miscellaneous AMPL Commands

  -- MichaelOSullivan - 27 Feb 2008

Revision 12008-02-27 - MichaelOSullivan

Line: 1 to 1
Added:
>
>
META TOPICPARENT name="AMPLGuide"

The AMPL Syntax Guide

Disclaimer This is a *guide* to the AMPL syntax only. For a comprehensive reference to the AMPL language see AMPL: A Modeling Language for Mathematical Programming.

  1. Commenting
  2. Using {\tt symbolic}
  3. Sets
  4. Variables
  5. Parameters
  6. Expressions
  7. Objective Functions
  8. Constraints
  9. Logical Statements
  10. Looping Statements
  11. Displaying and Printing
  12. Miscellaneous AMPL Commands

Commenting

The {\tt #} is used for commenting, any characters after the {\tt #} are ignored by AMPL.

Examples

The Whiskas Cat Food Problem

\begin{verbatim} var x1 >= 0; # Percentage chicken meat used in 100g of cat food (= g) \end{verbatim}

The Surfboard Production Problem

\begin{verbatim} param Resin {SURFBOARDS} >= 0; # Amount of resin (in kilos) needed for a board param TotalResin >= 0; # Total amount of resin available \end{verbatim}

Using {\tt symbolic}

The {\tt symbolic} keyword is used to create parameters that represent character strings. Usually they are used to represent members of 1-dimensional sets or part of a tuple for multi-dimensional sets. However, they can also be used to represent file names or to automatically build labels (for entry in a set, for example).

Example. Searching a 1-Dimensional set

\begin{verbatim} param gotcha symbolic within SET; for {s in SET} { if then let gotcha := s; } # gotcha now contains the (last) element in SET that satisfies the condition \end{verbatim}

Example. Searching a 2-Dimensional Set

\begin{verbatim} set SET1; set SET2;

set TWO_D_SET within SET1 cross SET2;

param got_one symbolic within SET1; param got_two symbolic within SET2;

for {(s, t) in TWO_D_SET} { if then { let got_one := s; let got_two := t; } } # (got_one, got_two) now contains the (last) element in TWO_D_SET # that satisfies the condition \end{verbatim}

To build labels for set elements you need a {\tt symbolic} parameter and the parts of the label. You can then "glue" the parts of the label together by enclosing the label within {\tt (} and {\tt )} and joining the parts with {\tt &}. The parts can be set elements, strings or numbers. Numbers are converted to strings using the {\tt %g} format from {\tt printf}.

Example. Dynamically Building a Set

\begin{verbatim} param name symbolic;

let SUPPLY_NODES := {}; for {s in SUPPLY_LOCATIONS} { let name := (s & '-Woodchips'); let SUPPLY_NODES := SUPPLY_NODES union {name}; let Supply[name] := MaterialSupply[s, 'Woodchips']; let {d in DEMAND_NODES} Cost[name, d] := TransportationCost[s, d]; let dummyDemandCost[name] := DisposalCost['Woodchips']; } \end{verbatim}

Sets

Variables

Parameters

Expressions

Objective Function

Constraints

Logical Statements

Looping Statements

Displaying and Printing

Miscellaneous AMPL Commands

-- MichaelOSullivan - 27 Feb 2008

 
This site is powered by the TWiki collaboration platform Powered by PerlCopyright © 2008-2020 by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding TWiki? Send feedback