# Direct Calculations on Tables and Timetables

*Since R2023a*

You can perform calculations directly on tables and timetables without extracting their data by indexing. To perform direct calculations with the same syntaxes used for arrays, your tables and timetables must meet several conditions:

All variables of your tables and timetables must have data types that support calculations.

If you perform an operation where only one operand is a table or timetable, then the other operand must be a numeric or logical array.

If you perform an operation where both operands are tables or timetables, then they must have compatible sizes.

This example shows how perform operations without indexing into your tables and timetables. You can also call common mathematical and statistical functions, such as `sum`

, `mean`

, and `cumsum`

. This example also shows how to perform operations on tables and timetables when their rows and variables are in different orders but have matching names (or, in the case of timetables, matching row times). For a complete list of supported functions and operations, as well as related rules for their use, see Rules for Table and Timetable Mathematics.

Before R2023a, or for tables and timetables that have a mix of numeric and nonnumeric variables, see Calculations When Tables Have Both Numeric and Nonnumeric Data.

### Multiply Table by Scale Factors

A simple arithmetic operation is to scale a table by a constant. If all your table variables support multiplication, then you can scale your table without extracting data from it.

For example, read data from a CSV (comma-separated values) file, `testScoresNumeric.csv`

, into a table by using the `readtable`

function. The sample file contains 10 test scores for each of three tests.

`testScores = readtable("testScoresNumeric.csv")`

`testScores=`*10×3 table*
Test1 Test2 Test3
_____ _____ _____
90 87 93
87 85 83
86 85 88
75 80 72
89 86 87
96 92 98
78 75 77
91 94 92
86 83 85
79 76 82

The test scores are based on a 100-point scale. To convert them to scores on a 25-point scale, multiply the table by `0.25`

. To multiply tables and timetables, use the `times`

operator, `.*`

.

scaledScores = testScores .* 0.25

`scaledScores=`*10×3 table*
Test1 Test2 Test3
_____ _____ _____
22.5 21.75 23.25
21.75 21.25 20.75
21.5 21.25 22
18.75 20 18
22.25 21.5 21.75
24 23 24.5
19.5 18.75 19.25
22.75 23.5 23
21.5 20.75 21.25
19.75 19 20.5

If different tests have different scales, then you can multiply the table by a vector. When you perform operations where one operand is a table or timetable, then the other operand must be a scalar, vector, matrix, table, or timetable that has a compatible size.

For example, use a row vector to weight each test by a different factor.

weightedScores = testScores .* [0.2 0.3 0.5]

`weightedScores=`*10×3 table*
Test1 Test2 Test3
_____ _____ _____
18 26.1 46.5
17.4 25.5 41.5
17.2 25.5 44
15 24 36
17.8 25.8 43.5
19.2 27.6 49
15.6 22.5 38.5
18.2 28.2 46
17.2 24.9 42.5
15.8 22.8 41

### Calculate Sum and Mean of Table

Tables also support common mathematical and statistical functions. For example, calculate the sum of the weighted test scores across each row of the table. To sum across rows, specify the second dimension of the table when you call `sum`

.

sumScores = sum(weightedScores,2)

`sumScores=`*10×1 table*
sum
____
90.6
84.4
86.7
75
87.1
95.8
76.6
92.4
84.6
79.6

To calculate the mean score of each test, use the `mean`

function. By default, `mean`

calculates along the variables, the first dimension of the table.

meanScores = mean(weightedScores)

`meanScores=`*1×3 table*
Test1 Test2 Test3
_____ _____ _____
17.14 25.29 42.85

### Calculate Cumulative Sum of Timetable

Timetables support the same operations and mathematical and statistical functions that tables support.

For example, load a timetable that records the main shock amplitude of an earthquake over a period of 50 seconds, sampled at 200 Hz. The three timetable variables correspond to three directional components of the shockwave as measured by an accelerometer.

```
load quakeData
quakeData
```

`quakeData=`*10001×3 timetable*
Time EastWest NorthSouth Vertical
_________ ________ __________ ________
0.005 sec 5 3 0
0.01 sec 5 3 0
0.015 sec 5 2 0
0.02 sec 5 2 0
0.025 sec 5 2 0
0.03 sec 5 2 0
0.035 sec 5 1 0
0.04 sec 5 1 0
0.045 sec 5 1 0
0.05 sec 5 0 0
0.055 sec 5 0 0
0.06 sec 5 0 0
0.065 sec 5 0 0
0.07 sec 5 0 0
0.075 sec 5 0 0
0.08 sec 5 0 0
⋮

Calculate the propagation speed of the shockwave. First, multiply the timetable by the gravitational acceleration.

quakeData = 0.098 .* quakeData

`quakeData=`*10001×3 timetable*
Time EastWest NorthSouth Vertical
_________ ________ __________ ________
0.005 sec 0.49 0.294 0
0.01 sec 0.49 0.294 0
0.015 sec 0.49 0.196 0
0.02 sec 0.49 0.196 0
0.025 sec 0.49 0.196 0
0.03 sec 0.49 0.196 0
0.035 sec 0.49 0.098 0
0.04 sec 0.49 0.098 0
0.045 sec 0.49 0.098 0
0.05 sec 0.49 0 0
0.055 sec 0.49 0 0
0.06 sec 0.49 0 0
0.065 sec 0.49 0 0
0.07 sec 0.49 0 0
0.075 sec 0.49 0 0
0.08 sec 0.49 0 0
⋮

Then calculate the propagation speed by integrating the acceleration data. You can approximate the integration by calculating the cumulative sum of each variable. Scale the cumulative sums by the time step of the timetable. The `cumsum`

function returns a timetable that has the same size and the same row times as the input.

speedQuake = (1/200) .* cumsum(quakeData)

`speedQuake=`*10001×3 timetable*
Time EastWest NorthSouth Vertical
_________ ________ __________ ________
0.005 sec 0.00245 0.00147 0
0.01 sec 0.0049 0.00294 0
0.015 sec 0.00735 0.00392 0
0.02 sec 0.0098 0.0049 0
0.025 sec 0.01225 0.00588 0
0.03 sec 0.0147 0.00686 0
0.035 sec 0.01715 0.00735 0
0.04 sec 0.0196 0.00784 0
0.045 sec 0.02205 0.00833 0
0.05 sec 0.0245 0.00833 0
0.055 sec 0.02695 0.00833 0
0.06 sec 0.0294 0.00833 0
0.065 sec 0.03185 0.00833 0
0.07 sec 0.0343 0.00833 0
0.075 sec 0.03675 0.00833 0
0.08 sec 0.0392 0.00833 0
⋮

Calculate the means of the scaled cumulative sums. The `mean`

function returns the output as a one-row table.

meanQuake = mean(speedQuake)

`meanQuake=`*1×3 table*
EastWest NorthSouth Vertical
________ __________ ________
4.6145 -11.51 -7.2437

Center the scaled cumulative sums by subtracting the means. The output is a timetable with the propagation speeds for each component.

speedQuake = speedQuake - meanQuake

`speedQuake=`*10001×3 timetable*
Time EastWest NorthSouth Vertical
_________ ________ __________ ________
0.005 sec -4.6121 11.511 7.2437
0.01 sec -4.6096 11.513 7.2437
0.015 sec -4.6072 11.514 7.2437
0.02 sec -4.6047 11.515 7.2437
0.025 sec -4.6023 11.516 7.2437
0.03 sec -4.5998 11.517 7.2437
0.035 sec -4.5974 11.517 7.2437
0.04 sec -4.5949 11.518 7.2437
0.045 sec -4.5925 11.518 7.2437
0.05 sec -4.59 11.518 7.2437
0.055 sec -4.5876 11.518 7.2437
0.06 sec -4.5851 11.518 7.2437
0.065 sec -4.5827 11.518 7.2437
0.07 sec -4.5802 11.518 7.2437
0.075 sec -4.5778 11.518 7.2437
0.08 sec -4.5753 11.518 7.2437
⋮

### Operations with Rows and Variables in Different Orders

Tables and timetables have variables, and the variables have names. Table rows can also have row names. And timetable rows always have row times. When operating on two tables or timetables, their variables and rows must meet these conditions:

Both operands must have the same size, or one of them must be a one-row table.

Both operands must have variables with the same names. However, the variables in each operand can be in a different order.

If both operands are tables and have row names, then their row names must be the same. However, the row names in each operand can be in a different order.

If both operands are timetables, then their row times must be the same. However, the row times in each operand can be in a different order.

For example, create two tables and add them. These tables have variable names but no row names. The variables are in the same order.

A = table([1;2],[3;4],VariableNames=["V1","V2"])

`A=`*2×2 table*
V1 V2
__ __
1 3
2 4

B = table([1;3],[2;4],VariableNames=["V1","V2"])

`B=`*2×2 table*
V1 V2
__ __
1 2
3 4

C = A + B

`C=`*2×2 table*
V1 V2
__ __
2 5
5 8

Now create two tables that have row names and variables in different orders.

A = table([1;2],[3;4],VariableNames=["V1","V2"],RowNames=["R1","R2"])

`A=`*2×2 table*
V1 V2
__ __
R1 1 3
R2 2 4

B = table([4;2],[3;1],VariableNames=["V2","V1"],RowNames=["R2","R1"])

`B=`*2×2 table*
V2 V1
__ __
R2 4 3
R1 2 1

Add the tables. The result is a table that has variables and rows in the same orders as the variables and rows of the first table in the expression.

C = A + B

`C=`*2×2 table*
V1 V2
__ __
R1 2 5
R2 5 8

Similarly, add two timetables. The result is a timetable with variables and row times in the same orders as in the first timetable.

A = timetable(seconds([15;30]),[1;2],[3;4],VariableNames=["V1","V2"])

`A=`*2×2 timetable*
Time V1 V2
______ __ __
15 sec 1 3
30 sec 2 4

B = timetable(seconds([30;15]),[4;2],[3;1],VariableNames=["V2","V1"])

`B=`*2×2 timetable*
Time V2 V1
______ __ __
30 sec 4 3
15 sec 2 1

C = A + B

`C=`*2×2 timetable*
Time V1 V2
______ __ __
15 sec 2 5
30 sec 5 8