Cybersearch2

Information Connects

Expression Pattern Language (eXPL)

Introduction » eXPL Reference » Axiom Choice

Axiom Choice

Axiom choice is one of two selection artifacts, the second being term choice. A term choice selects a single term value, while an axiom choice selects one axiom from a collection. An axiom choice is a hybrid template and axiom collection combination which is used to select a data set for use in generating a solution based on query criteria.

Format

The axiom choice format is similar to that of a literal axiom collection, except keyword axiom is replaced with choice, anonymous terms are not allowed and each row contains a hybrid combination of a match term followed by one or more literals:

choice name( term-names ) { match-term, literals } ...

The match term is unique to axiom choice and it provides the logic on which a selection is made. A match term can be one of two types, both of which involve a match variable indicated by the first name in the term names header:

Literal value which is compared to the match variable
Boolean expression containing the match variable which is evaluated at the time the selection is made

Usage

Axiom choice is versatile in that it can be placed in a query chain or used in a calculator like a conditional branch. There are subtle differences in behaviour to be pointed out later. The format for using an axiom choice in a calculator is simple. The axiom choice is referenced by name and an optional comma-delimited parameter list can follow:

choice name [( parameters )]

An axiom choice declaration may be several lines long, so is not allowed to be attached to a template as this would be confusing. However, when referenced by a calculator, the axiom choice is automatically incorporated in the calculator and a set of variables is provided to hold the selection when it is made. As the axiom choice is in a term position, it must return a value, which in this case is a selection index. Values range from zero upwards, and if no match is found, the returned value is -1.

Axiom choice allows selection based on value ranges. The following example shows an axiom choice named "bracket" used to find the stamp duty applicable to a real estate transaction:

choice bracket

(amount,       threshold,     base, percent)
{amount < 12000,      0,     0.00, 1.00}
{amount < 30000, 12000,   120.00, 2.00}
{amount < 50000, 30000,   480.00, 3.00}
{amount < 100000, 50000, 1080.00, 3.50}
{amount < 200000, 100000, 2830.00, 4.00}
{amount < 250000, 200000, 6830.00, 4.25}
{amount < 300000, 250000, 8955.00, 4.75}
{amount < 500000, 300000, 11330.00, 5.00}
{amount > 500000, 500000, 21330.00, 5.50};

There are several important details about how the bracket axiom choice is applied:

All the choice terms are named. The first, "amount", identifies the match variable.
Each match term contains a boolean expression which compares the match variable to a literal value
There is no default selection as the last option is open ended.

If a default selection is needed as a "catch-all" last option, then the keyword unknown is used as the last match term.

Choice as a Query Chain

The selection term is set by unifying with the incoming axiom. The result of the axiom choice is placed in the solution. If no match occurs, then the query step is short circuited. This allows cases to be filtered from the query results based on certain criteria. Note that when a match occurs, the selection index is also placed int the solution as a term with the same name as the choice.

Choice Default

One choice match strategy is to use keyword unknown as the last match term. This selects the default when no other alternatives match. Application ColorSwatch of tutorial10 demonstrates a this strategy with a query chain choice that translates a color expressed as a hex value to a color axiom with terms color, red, green and blue, In this case, there is no simple match term to express all the other excluded hex values except "unknown".

choice swatch (hex, color, red, green, blue)

{0x00FFFF, "aqua", 0, 255, 255}
{0x000000, "black", 0, 0, 0}
{0x0000FF, "blue", 0, 0, 255}
{0xFFFFFF, "white", 255, 255, 255}
{unknown, "unknown", 0, 0, 0};

axiom shade (hex) : parameter;

query<term> color_query (shade : swatch);

The solution for unexpected hex value of "0x77ffff" (7,864,319) is:

rgb = 7864319, color = unknown, red = 0, green = 0, blue = 0

A related issue is where an "out-of-range" match term is available, but then there seems to be no suitable selection value for that alternative. This is particularly an issue when selecting numbers where all values are valid. Literal value NaN (not-a-number) can be used as the selection value in this case and application PerfectMatch of tutorial10 gives an example. This is an application for a dating site which uses important criteria such as age and zodiac sign to determine compatibilty.

axiom person (name, sex, age, starsign)

{"John", "m", 23, "gemini"}
...
{"Bill", "m", 19, "virgo"};

choice age_rating

(age, age_weight)
{age > 29, 0.3}
{age > 25, 0.6}
{age >= 20, 1.0}
{age <= 19, NaN};

calc perfect_match
(

Name = name,
Age = age,
Starsign = starsign,
. choice age_rating,
Rating = age_weight.format

);

query<axiom> star_people(person : perfect_match);

An axiom choice is used to determine people's age rating - a number between 0.3 and 1. People 19 years old and younger are not allowed to participate, so a an age rating of NaN is applied. When the age rating is formatted, NaN is converted to "unknown". NaN has a fact status of "false", so if something different is to be displayed, a conditional branch can be implemented to use a different word or show it as blank.

It is also possible to append to the axiom choice heading, the names of any terms from the incoming axiom to pass through to the solution. An example of this can be seen in the following example.

Stamp Duty Example

Application StampDuty of tutorial10 demonstrates use of the "bracket" axiom choice as a chain query. In this case, a term name of "id" has been added to allow the "id" axiom value to transfer to the following chained calculator. The application determines the stamp duty payable on $123,458 for transaction id 100078:

choice bracket

(amount, threshold, base, percent, id)
...;

axiom transacton_amount (id, amount) : parameter;

calc payable(id, duty = base +
(amount - threshold) * (percent / 100));

query<term> stamp_duty_query (transacton_amount : bracket)
-> (payable);

The solution is:

stamp_duty(id=100078, duty=3768.32)

Axiom Choice in Calculator

When used in a calculator, an axiom choice has features not available in a query chain:

Choice variables can be declared in front of the choice for type conversion
Choice variables can also be declared in front of the choice to assign a default value for the case of no match
The selection index value of -1 is available in the case no match occurs and can be used to trigger a default condition

The first two of these features can be observed in the next example.

Stamp Duty Calculator

The StampDuty2 Application of tutorial10 is similar to the previous chain query example, but the first difference to notice is that the tax scales are reversed, so the $500,000 and above range is the first alternative. This has been done so a floor amount of $5,000 can be set below which a fixed duty of $20 applies, and for which no match will occur. The next thing of note is that there is a declaration of 2 variables used by the choice and a default value set for the duty amount:

Variable amount is declared as a $US currency type so the amount will be formatted accordingly
Variable percent is assigned a value 0.0
Variable duty is assigned a default value of 20.0 which applies when the percent value after the choice is 0.0

The application runs with 4 different transaction amounts, the first being below the floor amount and which is charged USD20.00 as expected. The index value for each transaction is printed out and you can see that the first transaction has a value of -1 for "no match"

Next: Choice Default and Parameters ...

Skip to Regular Expressions ...

Choice Parameters

An axiom choice in a calculator can have one or more parameters placed after the choice name in parentheses. Most likely this would be to set the match variable value. However match expressions may contain terms that need to be set by parameters. Annonymous literal terms are matched by position to the choice term names, though going beyond the first, which identifies the match variable, is probably not useful. An expression can be used as a parameter but must be named by assigning it to an identifier. An example of such an expression can be seen in the following example.

Parameter Example

The AgeDiscrimination application of tutorial10, like PerfectMatch, uses an axiom choice to allocate an age rating to people, this time using "star age" instead of age. Star age is calculated by taking a person's age and adding a "zodiac" fraction, which is a number between 0 and 11 determined by star sign divided by 12. A parameter must be used for the choice in this case because the supplied data does not provide the match value.

This is the choice:

choice age_rating

(star_age , age_weight)
{star_age > 28.5, 0.3}
{star_age > 24.9, 0.6}
{star_age > 19.5, 1.0};

Here is the calculator choice term. It has a parameter which evaluates the star age given a person's age and zodiac number (fraction):

choice age_rating(star_age = age + (fraction / 12.0))

A short circuit expression follows, checking for a "no match" selection index value which indicates the person is too young to participate:

? age_rating != -1,

Prev: Format, Usage ...

Next: Regular Expressions ...