### Table 3. Measured ultrasonic velocities (Wang and Nur, 1991) of six multicomponent hydrocarbon mixtures at 20 C compared to velocities computed using Wood apos;s formula, the time average equation, and a simple mixing rule. Data required for computing Wood apos;s estimate may be found in Table 1. Units of all velocities are km/s.

"... In PAGE 4: ... The signi cance of this observation is unclear however, since the wavelengths are long compared to the expected scale of the mixed uid microstructure. Table3 compares the measured velocities of multicomponent hydrocarbon mix- tures to the same three velocity estimates. All three estimates are again within 1 % of the measured values, but now the volume average estimate is not always the one closest to that observed.... ..."

### Table 3. Measured ultrasonic velocities [1,12] of six multicomponent hydrocarbon mixtures at 20 C compared to velocities computed using Wood apos;s formula, the time average equation, and a simple mixing rule. Fractional subscripts in chemical formulas refer to volume fractions. Data required for computing Wood apos;s estimate may be found in Table 1. Units of all velocities are km/s.

"... In PAGE 5: ... The signi cance of this observation is unclear however, since we believe the wavelengths to be long compared to the size of the uid microstructure. Table3 compares the measured velocities of multicomponent hydrocarbon mixtures to the same three velocity estimates. (Note that the last mixture in this table contains both 2% of the alkene 1-octene | with chemical formula C8H16 | and 6 % of the naphthene cyclooctane | having the same formula C8H16, but a di erent structure and density.... ..."

### Table 1: The speci cation rules of a simple language

2000

"... In PAGE 2: ... Each rule r 2 R; r : A0 = t0A1t1 : : : tn?1Antn is interpreted as an algebraic oper- ation [r] : [A1] : : : [An] ! [A0] which constructs the elements w0 2 [A0] from the elements wi 2 [Ai], 1 i n, by the rule: [r](w1; w2; : : : wn) = w0 = t0w1t1w2 : : : tn?1wntn. We illustrate this de nition with the speci cation rules in Table1 . The syntax interpretation... In PAGE 2: ...Table 1: The speci cation rules of a simple language of the parameters used in these rules is de ned by the equations in Table 2. The syntax algebra of the language speci ed by the rules in Table1 is Syn(R) = hf [Id], [Ex], [T p], [St],... In PAGE 7: ... If w does not create (destroy) types and variable bindings and Tw coincide with the prede ned types then the computation is expressed by a transition of the form f(Dw; quot; w) w 7! (Dw; w #)g. [[St]] = 8w 2 [St] if w = id:= e then [[St]] [ (D; quot; id := e) := 7! (D0; id := e #) where 0(x) = (x) if x 6 = id else [[e]] 8w 2 [St] if w = if e then s1 else s2 and [[e]] = true then [[St]] [ ((D; quot; if e then s1 else s2 fi) e 7! (D0; if e then quot; s1 else s2) (D0; if e then quot; s1 elses2 fi) s1 7! (D00; if e then s1 # else s2 fi) (D00; if e then s1 # else s2 fi) 7! (D00; if e then s1 else s2 fi quot;)) 8w 2 [St] if w = if e then s1 else s2 and [[e]] = false then [[St]] [ ((D; quot; if e then s1 else s2 fi) e 7! (D0; if e then s1 else quot; s2 fi) (D0; if e then s1 else quot; s2 fi) s2 7! (D00; if e then s1 else s2 # fi) (D00; if e then s1 else s2 # fi) 7! (D00; if e then s1 else s2 fi quot;)) 8w 2 [St] if w = while e do s od and [[e]] = true then [[St]] [ ((D; quot; while e do s od) e 7! (D0; while e do quot; s od) (D0; while e do quot; s od) s 7! (D00; while e do s # od) (D00; while e do s # od) 7! (D00; quot; while e do s od) 8w 2 [St] if w = while e do s od and [[e]] = false then [[St]] [ ((D; quot; while e do s od) e 7! (D0; while e do s # od) (D0; while e do s # od) 7! (D0; while e do s od quot;) Table 4: Semantic domain speci cation We illustrate the construction of the algebra Sem(R) using the speci cation rules given in Table1 , assuming that [[Id]] is the universe of names, [[Ex]] is the universe of values, and [[T p]] is the set of types. For x 2 [Id], e 2 [Ex] and t 2 [T p] we denote with x, e, and t, respectively, the corresponding transitions in [[Id]], [[Ex]], [[T p]], respectively.... In PAGE 7: ...[e]] 2 [[Ex]] is the value of the expression e computed in the current state, i.e., replacing each variable that occur in e with its value in the current state; [[St]] is shown in Table 4; [[Sl]], [[Dc]], [[Dl]], [[Bl]] are shown in Table 5. The semantics algebra of the language speci ed by the rules in Table1 is Sem(R) = hf[[Id]],[[Ex]],[[T p]],[[St]],[[Sl]],[[Dc]],[[Dl]],[[Bl]]g;f[[r1]],[[r2]],[[r3]],[[r4]],[[r5]],[[r6]],[[r7]],[[r8]],[[r9]],[[r10]], , gi, where the operations [[r1]] through [[r10]] are in Table 6. Fact 3: Sem(R) is embedded in the semigroup hf[[A]]jA 2 Ng; ; i by derived operations.... ..."

Cited by 2

### Table 5. Average test set error rates for the five fixed rules described in Sect. 2. S.A. denotes the simple average rule.

2002

"... In PAGE 5: ...940 9.835 The average test set error rates obtained using the five fixed rules are reported in Table5 , while Table 6 shows the results of the two trained rules. We remark that the optimal weights of the weighted averaging rule were computed by exhaustive search on the test set.... In PAGE 5: ... Therefore, the related results represent the ideal performance of these rules. Table5 shows that simple average outperforms the best individual classifier only for the balanced Ensemble 1. The performances of the majority voting rule are significantly good.... ..."

Cited by 7

### Table 6: General Inference Rules

1991

"... In PAGE 12: ...7 Given a signature for the programming language, let be the signature for the metalanguage with the same base types and a function p: 1 ! T 2 for each command p: 1 * 2 in . The translation from programs over to terms over is de ned by induction on raw programs: x [x]T (let x1(e1 in e2) (letT x1(e1 in e2 ) p(e1) (letT x(e1 in p(x)) [e] [e ]T (e) (letT x(e in x) The inference rules for deriving equivalence and existence assertions of the simple programming language can be partitioned as follows: general rules (see Table6 ) for terms denoting computations, but with variables ranging over values; these rules replace those of Table 2 for many sorted monadic equational logic rules capturing the properties of type- and term-constructors (see Table 7) after interpretation of the programming language; these rules replace the additional rules for the metalanguage given in Table 4.... ..."

Cited by 585

### Table 4: Inference Rules of the Simple Metalanguage

1991

Cited by 585

### Table 1: Comparison for Simple Computations

"... In PAGE 27: ... Each element only performs part of the calculation and only by looking at the whole can we describe the role of each component. The comparison results are shown in Table1 on page 27. The Noema performs worse when compared with the traditional computation with re-... ..."

### Table 3. Rules and Measures

1999

"... In PAGE 5: ... For the analysis on the synthetic computer performance dataset, we decided to continue using the variable partition of Variable1(Time) versus the other five variables. Table3 is an example of the top positively valued simple relati onships and their measures using mean and median for determining the threshold set.... ..."

Cited by 1

### Table 1: Simplification Rules

"... In PAGE 3: ... 3. SIMPLIFICATION RULES To determine equality of a program and its restructured version, the compiler uses a table similar to the one shown in Table1 (a). To verify legality of a transformation shown in the first column, the Commute function is invoked on appropriate instantiations of pro- gram statements as shown in the second column of this table.... In PAGE 4: ... Our implementa- tion of this method is discussed in Section 4. On the other hand, if these program fragments are not simple enough, it applies the rules shown in Table1 (b) to simplify the programs recursively till the programs are simple enough to be analyzed symbolically. As with the rules shown in Table 1(a), the rules in Table 1(b) are easy to understand if the restructuring is viewed incrementally.... In PAGE 4: ... On the other hand, if these program fragments are not simple enough, it applies the rules shown in Table 1(b) to simplify the programs recursively till the programs are simple enough to be analyzed symbolically. As with the rules shown in Table1 (a), the rules in Table 1(b) are easy to understand if the restructuring is viewed incrementally. Note that exactly one of the rules in Table 1(b) can be applied at each simpli- fication step, resulting in a deterministic simplification procedure.... In PAGE 4: ... As with the rules shown in Table 1(a), the rules in Table 1(b) are easy to understand if the restructuring is viewed incrementally. Note that exactly one of the rules in Table1 (b) can be applied at each simpli- fication step, resulting in a deterministic simplification procedure. 3.... In PAGE 4: ... 3.1 Proof of Correctness of Simplification Rules The validity of the legality conditions in Table1 follows from the following result, many variations of which have appeared in the literature [11]. THEOREM 1.... In PAGE 4: ... Intuitively, Theorem 1 allows us to reformulate the problem of checking legality of a transformation as a problem of verifying commutativity of statement instances that are reordered by that transformation. The validity of the rules given in Table1 follows directly from this result. 3.... In PAGE 4: ... 3.2 Reduction Example An interesting example of the use of the rules in Table1 is pro- vided by the reduction example shown in Figure 7. The loop inter- change shown in Figures 7(a,b) is legal if we assume that addition is commutative and associative, but every iteration of the loop nest reads and writes variable k, so dependences are violated by the restructuring.... In PAGE 8: ... A high level view of the steps of this process is shown in Figure 16. To verify the legality of the loop distribu- tion step, our compiler consults Table1 (a) and determines that it must check if B1(l) commutes with B2(m) where jB m lt; l jB + B ; 1, as shown in Figure 17. However, these sim- pler programs are not simple enough ; the loop that computes the pivot in B1.... In PAGE 8: ...b(l) is a recurrence that cannot be handled by our core symbolic comparison engine, as we discussed in Section 4. Therefore, these programs are simplified again using the rule for statement sequences in Table1 (b). This requires the compiler to test whether B2(m) commutes with the five subblocks in B1(l).... In PAGE 10: ... The intuition behind fractal symbolic analysis is to view a program transformation as a process which transforms the initial program incrementally to the final program. In gen- eral, there are many incremental processes that achieve the effect of a given transformation, and Table1 shows just one such way for the transformations listed there. Given a program and its transformation, fractal symbolic anal- ysis may succeed in proving the correctness of some of these processes, but it may fail conservatively for others.... ..."