A Genetic Algorithm for Optimizing Hierarchical Menus

3

A Genetic Algorithm for Optimizing Hierarchical Menus

Shouichi Matsui and Seiji Yamada Central Research Institute of Electric Power Industry & National Institute of Informatics

Japan

1. Introduction

Hierarchical menus are one of the primary controls for issuing commands in GUIs. These menus have submenus as menu items and display submenus off to the side when they are selected. Cellular phones that have only small displays show submenus as new menus, as shown in Fig. 1. The performance of the menu, i.e., the average selection time of menu items, depends on many factors, including its structure, layout, and colours. There have been many studies on novel menus (e.g., Ahlström, 2005; Beck et al., 2006; Findlater & McGrenere, 2004), but there has been little work improving the performance of a menu by changing its structure (Amant et al., 2004; Francis, 2000; Francis & Rash, 2002; Liu et al., 2002; Quiroz et al., 2007). A very simple search method gave a fairly good improvement (Amant et al., 2004); therefore, we can expect further performance improvements by optimizing the structure.

Fig. 1. Example of hierarchical menu for a cellular phone

There have been many studies on menu design, menu layout from the standpoint of the user interface. Francis et al. were the first to optimize a multi-function display that was essentially the same as a hierarchical menu by using Simulated Annealing (SA) (Francis, 2000; Francis & Rash, 2002). Quiroz et al. proposed an interactive evolution of a non-hierarchical menu using an interactive evolutionary computation (IEC) approach (Quiroz et al., 2007). O

pen

Acc

ess

Dat

abas

e w

ww

.inte

chw

eb.o

rg

Source: Evolutionary Computation, Book edited by: Wellington Pinheiro dos Santos, ISBN 978-953-307-008-7, pp. 572, October 2009, I-Tech, Vienna, Austria

www.intechopen.com

Evolutionary Computation

46

Liu et al. applied a visual search model of to menu design (Liu et al., 2002). They used the Guided Search (GS) model to develop menu designs. They defined a GS simulation model for a menu search task, and estimated the model parameters that would provide the best fit between model predictions and experimental data. Then they used an optimization algorithm to identify the menu design that minimized the predicted search times according to predefined search frequencies of different menu items, and they tested the design. Their results indicate that the GS model has the potential to be part of a system for predicting or automating the design of menus. Amant et al. showed the concepts to support the analysis of cellular phone menu hierarchies (Amant et al., 2004). They proposed a model-based evaluation of cellular phone menu interaction, gathered data and evaluated three models: Fitts’ law model, GOMS, and ACT-R. They concluded that the prediction by GOMS was the best among the three models. They also tried to improve menu selection time by using a simple best-first search algorithm and got over 30% savings in selection time. This chapter shows an algorithm based on the genetic algorithm (GA) for optimizing the performance of menus. The algorithm aims to minimize the average selection time of menu items by considering the user’s pointer movement and search/decision time (Matsui & Yamada, 2008a; Matsui & Yamada, 2008b). We will show results on a static hierarchical menu of a cellular phone as an example for a device with a small screen and limited input capability.

2. Formulation of the problem

2.1 Overview

The optimization problem of hierarchical menus can be considered as one dealing with placing menu items on the nodes of a tree. Let us assume a tree where the maximum depth is D, the maximum number of children that a node has is W, the root is the initial state, and menu items are on nodes. An example of a hierarchical menu in tree structure is shown in Fig. 2. As shown in the figure, some menu items have children; i.e. some menu items have submenus. The time to select the target item is the time to traverse from the root to the target node. The problem is to minimize the average traversal time with respect to the given search frequencies of menu items. We cannot arbitrarily arrange the menu purely for efficiency. We must respect the semantic relationships between the items. That is, “Ringer Volume” is under the “Settings” category rather than vice versa for good reason. To cope with the difficulties of representing and reasoning about menu item semantics, we introduce two metrics, functional similarity and menu granularity. Functional similarity is a metric that represents the similarity of two menu items in terms of their functions. We assume that the functional similarity takes a value between 0 and 1; 0 means that the two items have no similarity, and 1 means that the two items have very high similarity. For example, it is very natural to assume that “Create New Mail” and “Favorite Web Site” have low similarity and that “Create New Mail” and “Inbox of Mail” have high similarity. We use this metric to avoid placing items with low similarity on the same submenu of a node. If items with low similarity are put on the same submenu, it becomes difficult for a user to remember the menu layout. The formal definition will be given later. Menu granularity is a metric that reflects the number of submenus a node has as its descendants. We introduce this metric to avoid placing an item that has many children and

www.intechopen.com


47

an item that has no child as children of the same node. The formal definition will be given later.

level 0

level 1

levelm

V00

V01

V11

V1

V1

V0m

V1

V V

W -1

W -1

W -2

W -2m m m

....

.... .... .... ....

Search/

Decison

time

Up to

children

Pointing

time

W

t sd0

t p0

t p1

tpW-1

....

Fig. 2. Tree structure of a hierarchical menu

The problem of minimizing the average traversal time is a very difficult one because of the following constraints;

• The traversal time from a node to its children is not constant; it varies depending on the starting and ending nodes.

• Menu items usually belong to groups, and they have hierarchical constraints.

• We should consider the functional similarity and the menu granularity of each item from the standpoint of usability.

2.2 Formulation 2.2.1 Notation

Let l be the level number, i be the ordering number in siblings, and l

iv be a node of a tree

(Fig. 2). Moreover, let ( )= ,M V E be a tree where { }= l

iV v denotes the nodes and

{ }=ij

E e denotes the edges. We call the leaf nodes that correspond to generic functions

“terminal nodes.” There are two kinds of menu item or node in M. One type is terminal nodes that correspond to generic functions, and the other is intermediate nodes. The terminal nodes cannot have children.

Let iI represent a menu item and the total number of items be N ; i.e., there are

( 1 )= , ,AiI i N menu items. Items that correspond to generic functions are less than N and

some items/nodes are intermediate items/nodes that have submenu(s) as a child or

children. We assume that a menu item iI is assigned to a nodel

iv ; therefore, we use iI and l

iv interchangeably. We also assume that the selection probability of the terminal

node/generic function is represented by iPr .

2.2.2 Selection time

The selection time l

it of a menu item/node l

iv on the hierarchical level l can be expressed

using the search/decision time sd

it and the pointing time p

it as follows (Cockburn et al.

2007):

= + .l sd p

i i it t t (1)

www.intechopen.com


48

We also consider the time to reach level l ; therefore, the whole selection time iT of a node l

iv on level l can be expressed as follows:

1

0

−

== + .∑

j

lj l

i i i

j

T t t (2)

Thus, the average selection time avgT is defined as follows:

1=

= .∑Navg i i

i

T PrT (3)

2.2.3 Pointing time

As Silfverberg et al. (Silfverberg et al., 2000) and Cockburn (Cockburn et al., 2007) reported,

the pointing time p

it can be expressed by using the Fitts’ law as follows:

2

log ( 1)= + / + ,p

i i it a b A W (4)

where the coefficients a and b are determined empirically by regressing the observed

pointing time, iA is the distance moved, and iW is the width of the target. Fitts’ law describes the time taken to acquire, or point to, a visual target. It is based on the amount of information that a person must transmit through his/her motor system to move to an item – small, distant targets demand more information than large close ones, and

consequently they take longer to acquire. Therefore the term 2

log ( 1)/ +i iA W is called the

index of difficulty (ID),

2.2.4 Search/decision time

We assume that the search/decision time sd

it can be expressed as follows (Cockburn et al.,

2007).

• For an inexperienced user, the time required for a linear search is as follows:

= + ,sd sd l sd

it b n a (5)

where ln is the number of items that a level l node has, and the coefficients

sda and sdb

are determined empirically by regressing the observed search time.

• For an expert, we can assume that the time sd

it obeys Hick-Hyman’s law.

= + ,sd sd sd

i it b H a (6)

2

log (1 )= / ,l

i iH Pr (7)

where the coefficients sda and

sdb are determined empirically by regressing the observed

search time. If we can assume that all items are equally probable, the following equation holds.

2

log ( ) iff 1= ∀ = / .l l l

iH n Pr n (8)

www.intechopen.com


49

2.2.5 Functional similarity

Toms et al. reported the result of generating a menu hierarchy from functional descriptions

using cluster analysis (Toms et al., 2001). However, this approach is time consuming;

therefore, we choose to use another one.

We represent the functional similarity of item xI and

yI by using a function ( ),

x ys I I

which takes a value between 0 and 1. Let us assume that generic function of each item iI

can be specified by some words 0 1{ }= , ,Aiwl w w , and let =WL ∪ i

i

wl be the whole

words. Let us also assume that an intermediate node can be characterized by the words by

which the children are specified. Let x be a vector in which element ix represents the

frequency of the i -th word in its specification, and let y be a vector of node y . Then, the

functional similarity ( )x ys I I, is defined as follows:

( )⋅, = | || |x y

x yx y

s I I (9)

Let us consider a node l

iv that has m children. The penalty of functional similarity l

i

s

vP of

node l

iv is defined as follows:

1 1

0 0

(1 ( ))− −

= == − , .∑ ∑l

i

m m

s

i jv

i j

P s I I (10)

And the total penalty sP is defined as follows:

0

0∈

= .∑ l

il

i

s s

v

v {V v }

P PT

(11)

2.2.6 Menu granularity

The menu granularity l

ivg of a node

l

iv is defined as the total number of descendants. If

node l

iv is a terminal node, then 0=l

ivg . Moreover, if node

l

iv has m children

(1

0 1+ , = , , −Al

jv j m ) whose menu granularities are

1( 0 1)+ , = , , −A

l

jvg j m , then

l

ivg is

defined as follows:

1

1

0

+

−

== .∑l l

i j

m

v v

j

g g (12)

The penalty of menu granularity l

i

g

vP of node

l

iv is defined as follows:

1 1

0 0

− −

= == | − | .∑ ∑l l l

i i j

m m

g

v v v

i j

P g g (13)

www.intechopen.com


50

And the total penalty gP is defined as follows:

0

0∈

= .∑ l

il

i

g g

v

v {V v }

P PT

(14)

2.2.7 Objective function

The problem is to minimize the following objective function:

α β= + + ,s g

avgf T P P (15)

where α and β are the constants that control the preference of functional similarity and

menu granularity.

2.3 Local/partial optimization 2.3.1 Placing Items as children of a node

Let us consider a node l

iv on level l that has ≤n W children 1( 0 1)

+ = , , −Al

jv j n and

represent the traversal time from l

iv to 1l

jv+

, i.e., the pointing time for 1l

jv+

, by l

jt . When

we want to place ( 0 1), = , , −AjI j n menu items whose selection probabilities are

represented by j

Pr as the children of thel

iv , the average pointing timel

ivT ,

1

0

−

== ,∑l

i

n

l

j jv

j

T Pr t (16)

is minimized as follows:

1. Sort iI using

iPr as the sort key in descending order, and let the result be

( 0 1)= , , −′ Ai i nI ,

2. Sort 1+l

iv using

l

it as the sort key in ascending order, and let the results be

( 1)( 0 1)

′ + = , , −Al

iv i n

3. Placing ′iI on the node ( 1)′ +l

iv gives the minimum average pointing time from node

l

iv .

2.3.2 Optimization problem

When menu items that are placed as the children of a node V are given, the placement that

minimizes the average pointing time is straightforward. Therefore, the problem is to find the

best assignment of menu items to nodes of a tree that minimizes Equation (15), where nodes

have a fixed capacity of W items. There should be at least = /⎡ ⎤⎢ ⎥L N W nodes in the tree,

and N items placed on some node. The first node has W items chosen from N items, and

the second node has W items chosen from −N W items, and so on, so the search space of

the problem is roughly ( )− −× × × = ! / !A L

N W N W W N LW WC C C N W ; therefore, the problem is a

difficult combinatorial optimization problem. For instance, consider the case of 200=N ,

10=W . The search space is roughly20 243

200 ((10 ) ) 10! / ! ∼ .

www.intechopen.com


51

3. Genetic algorithm

3.1 Basic strategy

Previous studies showed that breadth was preferable to depth (Kiger, 1984; Larson & Czerwinski, 1998; Schultz & Curran, 1986; Zaphiris, 2000; Zaphiris et al. 2003). Schultz and Curran reported that menu breadth was preferable to depth (Schultz & Curran, 1986). Larson and Czerwinski reported the results of depth and breadth tradeoff issues in the design of GUIs (Larson & Czerwinski, 1998). Their results showed that, while increased depth did harm search performance on the web, a medium condition of depth and breadth outperformed the broadest shallow web structure overall. Zaphiris studied the effect of depth and breadth in the arrangement of web link hierarchies on user preference, response time, and errors (Zaphiris, 2000). He showed that previous menu depth/breath tradeoff procedures applied to the web link domain. He also showed that task completion time increased as the depth of the web site structure increased. Zaphiris et al. also showed the results of the study investigating age-related differences as they relate to the depth versus breadth tradeoff in hierarchical online information systems (Zaphiris et al. 2003). They showed that shallow hierarchies were preferred to deep hierarchies, and seniors were slower but did not make more errors than their younger counterparts when browsing web pages. Because the previous studies showed that breadth was preferable to depth, we use a kind of breadth-first search algorithm (shown later), as the core of the proposed GA.

3.2 Chromosome and mapping from genotype to phenotype

A simple way to represent a solution of the problem is a tree. But there is a problem that

genetic operators such as crossover or mutation may generate an infeasible solution; i.e., the

tree does not contain all the generic functions. There are two ways to cope with this

problem. The first way is to convert an infeasible solution into a feasible one and modify the

chromosome. The other way is to use a chromosome representation that does not generate

infeasible solutions. We base the proposed algorithm on the latter approach.

Since breadth is preferable to depth, an algorithm that places menu items iI one by one on

a usable node that has the smallest node number can find a good solution. We number each

node from root to bottom and from left to right. We use an algorithm that assigns iI to a

node as follows:

1. A chromosome of the GA is a sequence of iI ; i.e., a chromosome can be represented as a

permutation of numbers.

2. According to the permutation, assign menu items iI one by one to vacant positions of

the node that has the smallest node number. 3. If a generic function is assigned to a node, then the number of children that the node

can have is decreased by 1. If we have a sufficient number of intermediate nodes, we can search enough space to find the optimal solution.

Two examples of assignment according to permutation are depicted in Fig.3, where W is 4.

In the figure, numbers with underline (1, 2, 3) represent the intermediate nodes. Let us

consider “Permutation 1”. In this case, we can assign “10”, “5”, and “11” to the root node.

But we cannot assign “7” to the root node, because the root node cannot have any children if

we did. Therefore, we should assign “7” to the next level node, and the remaining position

www.intechopen.com


52

of the root node should be an intermediate node. Because there is an intermediate node in

the root node, we can assign “1” to the root node.

In the case of “Permutation 2”, the mapping is straightforward. The first number “1” is an intermediate node, so we assign it to the root node, and the number of vacant positions in the tree is incremented by 4. The next number “10” can be assigned to the root node, and “3” and “5” can be assigned to the root node. The remaining numbers are assigned to the children of the root nodes.

Fig. 3. Mapping a permutation to a tree structure

3.3 Local search

We use a local search method to improve the performance of GA. The method finds an

unused nodel

iv , i.e., finds an intermediate node that has no child, and swaps l

iv with a

node that is the sibling’s child1l

jv+

. Figure 4 shows an example of this procedure. In the left

tree, the intermediate node “int2” has no child, so it is swapped with “func3”, and the result

is the right part.

root

func1

func2

int1

int2

func3

func4

func5

func6

root

func1

func2

func3

int1

func4

func5

func6 left: before local search right: after local search

Fig. 4. Local search

3.4 Crossover and mutation

We use a crossover operator that does not generate an invalid chromosome. As described above, a chromosome is a permutation of numbers; therefore, we use crossover operators that are developed for the representation. Based on the results of preliminary experiments, we chose CX (Cycle Crossover) for the crossover operator.

We use the swap mutation as the mutation operator. Randomly chosen genes at position p

and q are swapped.

www.intechopen.com


53

The crossover and mutation operators do not generate invalid chromosomes; i.e., offspring are always valid permutations.

3.5 Other GA parameters

The selection of the GA is tournament selection of size 2. The initial population is generated by random initialization, i.e., a chromosome is a random permutation of numbers. We use a steady state GA, for which the population size is 100, and the mutation rate is one swap per chromosome.

4. Numerical experiments

We conducted numerical experiments to confirm the effectiveness of the proposed algorithm. The target was a cellular phone that is used by one of the authors. The phone (KDDI, 2006) has 24 keys as shown in Fig. 5. The target phone has hardware keys for “E-mail”, “EZweb”, “Phone book”, and “Application”. And there is a “Shortcut”key (cursor down). The root menu thus has the four submenus corresponding to the hardware keys.

Fig. 5. Key Layout of the Target Cellular Phone.

4.1 Experimental data 4.1.1 Pointing time and decision time

The index of difficulty for 24×24 key pairs was calculated as follows. We measured the relative coordinates of the center (x,y) of each key and measured the width and height of each key. We calculated the index of difficulty to an accuracy of one digit after the decimal point. This gave us 28 groups of indexes of difficulty as shown in Table 1. We named each key, from top to bottom and left to right, as follows: “App”, “Up”, “Phone book”, “Left”, “Center”, “Right”, “Mail”, “Down”, “Web”, “Call”, “Clear”, “Power”, “1”, thru “9”, “*”, “0”, and “#”. We measured the pointing time of one-handed thumb users for the above 28 groups by recording the tone produced by each key press (Amant et al., 2004). There are two ways to measure the pointing time. Silfverberg et al. measured the time by counting the number of characters generated by key presses in 10 seconds (Silfverberg et al., 2000). Amant et al. measured the time by recording the tone produced by each key press (Amant et al., 2004). Because the target has keys that do not generate any character, such as cursor keys, we measured the time by recording the tone.

www.intechopen.com


54

Unpaid volunteers participated in the experiment. We prepared 28 tasks corresponding to the 28 groups. The “Read Email Message” function of the phone was used during the tasks, except for the one task (ID=1.4, “2” to “Clear”). For the exceptional case, the “write memo” function (with number mode selected) was used. The participants repeated the task of pressing the “From” key and the “To” key 10 times for each task. The pointing time was calculated by subtracting the starting time of the tone of “From” from the starting time of tone of “To.” We got the following equation for predicting the pointing time, and the equation is very similar to the one reported by Silfverberg et al.(Silfverberg et al., 2000)1

2

192 63log ( 1)(ms)= + / + .p

i i it A W (17)

Although the target phone has the ability to select a menu item by pressing a key that is prefixed to item title, we assumed that all selections were done by cursor movements. The target of this experiment was an expert; therefore, we used the following equation for the search/decision time (Cockburn et al. 2007)2:

2

80 log ( ) 240(ms)= + .sd l

it n (18)

Example of pairs Example of pairs group #

ID from to

# of pairs

group#

ID from to

# of pairs

1 3.7 * Up 2 15 2.3 1 3 33

2 3.6 0 Up 3 16 2.2 2 Center 20

3 3.5 9 Up 6 17 2.1 1 8 25

4 3.4 8 Up 8 18 2.0 2 Call 17

5 3.3 8 Right 17 19 1.9 1 7 21

6 3.2 9 Down 22 20 1.8 Mail Call 7

7 3.1 8 Down 25 21 1.7 1 5 50

8 3.0 6 Right 28 22 1.6 1 2 16

9 2.9 1 Up 29 23 1.4 2 Clear 9

10 2.8 8 Center 29 24 1.3 Right Up 12

11 2.7 1 * 33 25 1.2 1 4 21

12 2.6 2 Right 29 26 1.1 Center Down 4

13 2.5 1 9 29 27 0.8 Right Center 4

14 2.4 1 0 53 28 0.0 1 1 24

Table 1. Index of Difficulty for the Target Phone (24 keys)

1 2

176 64 log ( 1)= + / +p

i i it A W (ms).

2The equation is derived from experiments conducted for a computer display, and is not for a cellular phone.

www.intechopen.com


55

4.1.2 Usage frequency data

We gathered usage frequency data as follows. The first author recorded the daily usage of

each function for two months, and we generated the usage frequency data from the record.

There were 129 terminal nodes in the data.

4.1.3 Similarity

We assigned three to five words to each generic function according to the users’ manual of

the target phone (KDDI, 2006).

4.2 Results

We conducted the following experiments.

• Case 1: Typical Usage: This experiment was conducted to assess the typical improvement by the GA. The maximum width W was 16.

• Case 2: Limited Breadth: Although breadth is preferable to depth, pressing a far key or pressing a “Down” key many times is sometimes tedious. This experiment was conducted to see the effects of limiting the breadth. In this case, we set W to 12, 9, and 6.

Because GA is a stochastic algorithm, we conducted 50 runs for every test case, and the

results shown in Table 2 and Table 3 are averages over 50 runs. The two parameters for

weights were set to 10 0α = . and 1 0β = . . The maximum number of fitness evaluations was

100,000.

Case aveT (ms) (%) sP gPOriginal 3331 0.0 454 793

Local Move 2812 15.5 454 793

Case 1 (W =16) 2036 38.9 727 1259

Case 2 (W =12) 1998 40.0 541 856

Case 2 (W =9) 1959 41.2 402 291

Case 2 (W =6) 2237 32.8 279 173

Table 2. Improvement in average selection time

In Table 2, “Local Move” shows the results of a local modification that places menu items

according to their frequency, i.e., the most frequently used item is placed as the top item,

and so on. As the table shows, the proposed algorithm can generate menu with shorter

average selection time. Moreover, limiting the breadth gives better menus. This is partly

because the search/decision time is proportional to log2 (n), where n is the number of items.

As the number of items increases, the search/decision time increases; therefore, the average

selection time increases. Limiting the breadth to 6 gave a longer selection time and smaller

penalties.

The original menu (Tave=3331 (ms)) and the best menu of Case 2 (9 keys) (Tave =1913 (ms)) are

shown in Fig. 7. In the two figures, items and intermediate nodes are shown in boxes and

the vertical ordering shows the placement in a single level menu. The box is omitted for low

usage frequency items/intermediate nodes for the sake of saving space.

www.intechopen.com


56

In Fig. 7, items with high usage frequency are placed on a smaller level and on an upper

position. For example, the most frequently used “Inbox folder 2” which is placed under the

“Inbox” menu in the original menu, is placed as a child of “E-Mail” in the optimized menu.

Note also that “Shortcut” is not used in the original menu, but it is fully utilized in the

optimized menu; frequently used URLs are placed in “Shortcut”.

4.3 Effects of weights

We introduced two weights for the penalties of functional similarity and of menu

granularity. Table 3 shows the results of different weights settings for the case 9=W . The

average selection time increased as we increasedα . The table also shows that the difference

in average selection time was larger than that of the penalty factor ofsP . Setting them to

zero gave a shorter selection time, but the penalties were larger. There is a tradeoff among the average selection time, functional similarity, and menu

granularity; therefore, a multi-objective approach might be a more natural formulation.

α β aveT (ms) (%) sP gP

0.0 0.0 1837 44.9 584 448

5.0 1.0 1935 41.9 405 278

10.0 1.0 1959 41.2 402 291

20.0 1.0 1990 40.3 396 300

40.0 1.0 2066 38.0 395 309

20.0 5.0 2011 39.6 397 274

20.0 10.0 2028 39.1 405 260

Table 3. Effect of weights

4.4 Convergence speed

Figure 6 shows fitness, average selection time, and two penalty terms in the best case

( 9=W ). GA found a fairly good solution within 50,000 fitness evaluations. The penalty

term of “Functional Similarity” decreased almost monotonically, but the term of “Menu

Granularity” oscillated in the early stage. The average selection time initially decreased

rapidly, but sometimes increased in the middle of iteration because of the penalty terms.

5. Discussion and future work

The experiments show that the proposed algorithm can generate better menu hierarchies for

the target phone. Because our targets of are not limited to cellular phones, and the

preliminary results are promising, we will apply the algorithm to wider varieties of targets

such as Web browser bookmarks.

In this paper, we focused on a static menu as the target; adaptive/dynamic menu (e.g., Ahlström, 2005; Beck et al. 2006; Findlater & McGrenere, 2004) that changes menu contents depending on usage will be a future target. The data used in the experiments, especially selection frequency data, were limited.

Therefore, we should gather a wider variety of usage data and use that to confirm the

effectiveness of the proposed method.

www.intechopen.com


57

31500

32000

32500

33000

33500

34000

0 25000 50000 75000 100000

Fit

nes

s

Generation

1900

1950

2000

2050

2100

2150

2200

2250

2300

2350

2400

0 25000 50000 75000 100000

Aver

age

Sel

ecti

on

Tim

e

Generation

300

350

400

450

500

550

600

0 25000 50000 75000 100000

Pen

alty

Ter

m

Generation

Functional SimilarityMenu Granularity

Fig. 6. Fitness, Average selection time, Penalty terms

www.intechopen.com


58

root

E-Mail

EZweb

Application

Shortcut

Inbox

Check,Mail,New

Folder1

Folder2

Folder3

Folder4

Folder5

Folder0

Favorite Site

Folder1

Folder2

Folder3

URL1-2

URL1-3

URL1-4

URL1-5

URL1-6

URL1-7

URL1-8

URL1-9

URL1-10

URL 1-11

URL1-12

URL1-13 root

E-Mail

Shortcut

EZWeb

Application

Folder2

Folder5

Folder3

INT1

INT2

Folder0

Folder4

Folder1

Check,New,Mail

URL 1-6

URL 1-3

URL 1-4

URL 1-11

URL 1-2

URL 1-9

URL 1-7

URL1-12

FOL DER1

FOL DER2

FOL DER3

URL 1-5

URL1-13

URL 1-8

URL1-10

Left: Original menu Right: Generated Menu

Fig. 7. Original menu and best menu (W=9)

6. Conclusion

We proposed a GA-based algorithm for minimizing the average selection time of menu items that considers the user’s pointer movement time and the decision time. The preliminary results showed that the algorithm can generate a better menu structure. The target of the proposed algorithm is not limited to cellular phones.

7. References

Amant, St.; Horton, T.E. & Ritter, F.E. (2004). Model-based evaluation of cell phone menu

interaction, Proceedings of CHI 2004, pp.343–350, 1-58113-702-8, Vienna, Austria,

ACM Press, New York

Ahlström, D. (2005). Modeling and improving selection in cascading pull-down menus

using Fitts’ law, the steering law and force fields, Proceedings of CHI 2005, pp.61–70,

1-58113-998-5, Portland, Oregon, USA, ACM Press, New York

Beck, J.; Han, S.H. & Park, J. (2006). Presenting a submenu window for menu search on a

cellular phone, Int. J. of Human-Computer Interaction, vol.20, no.3, pp.233–245

www.intechopen.com


59

Cockburn, A.; Gutwin, G. & Greenberg, S. (2007). A predictive model of menu performance,

Proceedings of CHI 2007, pp.627–636, 978-1-59593-593-9, San Jose, California, USA,

ACM Press, New York

Francis, G. (2000). Designing multifunction displays: an optimization approach, International

Journal of Cognitive Ergonomics, vol.4, no.2, pp.107–124

Francis, G. & Rash, C. (2002). MFDTool (version 1.3): a software tool for optimizing

hierarchical information on multifunction displays, USAARL Report No.2002-22

Findlater, L. & McGrenere, J. (2004) A comparison of static, adaptive, and adaptable menus,

Proceedings of CHI 2004, pp.89–96, 1-58113-702-8, Vienna, Austria, ACM Press, New

York

KDDI (2006). Manual for CASIO W43CA http://www.au.kddi.com/torisetsu/pdf/

w43ca/w43ca_torisetsu.pdf,

Kiger, J.I. (1984). The depth/breadth trade-off in the design of menu-driven user interfaces,

International Journal of Man-Machine Studies, vol.20, no.2, pp.201–213

Larson, K. & Czerwinski, M. (1998). Web page design: implication of memory, structure and

scent for information retrieval, Proceedings of CHI 1998, pp.25–32, 0-201-30987-4, Los

Angeles, California, USA, ACM Press/Addison-Wesley Publishing Co., New York

Liu, B.; Francis, G. & Salvendy, G. (2002). Applying models of visual search to menu design,

Int. J. Human-Computer Studies, no.56, pp.307–330

Matsui, S. & Yamada, S. (2008a). Genetic algorithm can optimize hierarchical menus,

Proceedings of CHI 2008, pp.1385–1388, 978-1-60558-011-1, Florence, Italy ACM

Press, New York

Matsui, S. & Yamada, S. (2008b). A genetic algorithm for optimizing hierarchical menus, Proceedings of Evolutionary Computation, 2008, CEC 2008. (IEEE World Congress on

Computational Intelligence 2008)., pp.2851–2858, 978-1-4244-1822-0, Hong Kong,

IEEE, New York

Quiroz, J.C.; Louis, S.J. & Dascalu, S.M. (2007). Interactive evolution of XUL user interfaces,

Proceedings of GECCO 2007, pp.2151–2158, 978-1-59593-697-4, London, England,

ACM Press, New York

Silfverberg, M.; MacKenzie, I.S. & Kauppinen, T. (2000). Predicting text entry speed on

mobile phones, Proceedings of CHI 2000, pp.9–16, 1-58113-216-6, The Hague, The

Netherlands, ACM Press, New York

Schultz, E.E. Jr. & Curran, P.S. (1986). Menu structure and ordering of menu selection:

independent or interactive effects?, SIGCHI Bull.,vol.18, no.2, pp.69–71

Toms, M.L.; Cummings-Hill, M.A.; Curry, D.G. & Cone, S.M. (2001). Using cluster analysis

for deriving menu structures for automotive mobile multimedia applications, SAE

Technical Paper Series 2001-01-0359, SAE

Zaphiris, P. (2000). Depth vs breadth in the arrangement of web links, Proceedings of 44th

Annual Meeting of the Human Factors and Ergonomics Society, pp.139–144, San Diego,

California, USA, Human Factors and Ergonomics Society, Santa Monica

Zaphiris, P.; Kurniawan, S.H.& Ellis, R.D. (2003). Age related difference and the depth vs.

breadth tradeoffs in hierarchical online information systems, Proceedings of User

Interfaces for All, LNCS 2615, pp. 23–42, 978-3-540-00855-2, Paris, France, Springer,

Berlin/Heidelberg

www.intechopen.com


60

Ziefle, M. & Bay, S. (2004). Mental models of a cellular phone menu. Comparing older and

younger novice users, Proceedings of MobileHCI 2004, LNCS 3160, pp.25–37, 978-3-

540-23086-1, Glasgow, UK, Springer, Berlin/Heidelberg.

www.intechopen.com

Evolutionary ComputationEdited by Wellington Pinheiro dos Santos

ISBN 978-953-307-008-7Hard cover, 572 pagesPublisher InTechPublished online 01, October, 2009Published in print edition October, 2009

InTech EuropeUniversity Campus STeP Ri Slavka Krautzeka 83/A 51000 Rijeka, Croatia Phone: +385 (51) 770 447 Fax: +385 (51) 686 166www.intechopen.com

InTech ChinaUnit 405, Office Block, Hotel Equatorial Shanghai No.65, Yan An Road (West), Shanghai, 200040, China

Phone: +86-21-62489820 Fax: +86-21-62489821

This book presents several recent advances on Evolutionary Computation, specially evolution-basedoptimization methods and hybrid algorithms for several applications, from optimization and learning to patternrecognition and bioinformatics. This book also presents new algorithms based on several analogies andmetafores, where one of them is based on philosophy, specifically on the philosophy of praxis and dialectics. Inthis book it is also presented interesting applications on bioinformatics, specially the use of particle swarms todiscover gene expression patterns in DNA microarrays. Therefore, this book features representative work onthe field of evolutionary computation and applied sciences. The intended audience is graduate,undergraduate, researchers, and anyone who wishes to become familiar with the latest research work on thisfield.

How to referenceIn order to correctly reference this scholarly work, feel free to copy and paste the following:

Shouichi Matsui and Seiji Yamada (2009). A Genetic Algorithm for Optimizing Hierarchical Menus, EvolutionaryComputation, Wellington Pinheiro dos Santos (Ed.), ISBN: 978-953-307-008-7, InTech, Available from:http://www.intechopen.com/books/evolutionary-computation/a-genetic-algorithm-for-optimizing-hierarchical-menus

© 2009 The Author(s). Licensee IntechOpen. This chapter is distributedunder the terms of the Creative Commons Attribution-NonCommercial-ShareAlike-3.0 License, which permits use, distribution and reproduction fornon-commercial purposes, provided the original is properly cited andderivative works building on this content are distributed under the samelicense.

https://creativecommons.org/licenses/by-nc-sa/3.0/

A Genetic Algorithm for Optimizing Hierarchical Menus

Documents

Transcript of A Genetic Algorithm for Optimizing Hierarchical Menus