APL-Journal - APL Germany e. V.

APL-Journal
We want to access the data for Texas. To do this, we need
to first access the location matrix. This is conceptually a two
column matrix (in the following 4 means integers):
// Path to location matrix
pathm = pathj + „LocMatrix.sma“;
// Declare location matrix an array
LocMat = SmArray.fileArrayRead(pathm,4);
// Determine number of rows in location matrix
int rows = LocMat.getCount() / 2;
// Reshape to a matrix
LocMat = LocMat.reshapeBy(rows,2);
Assume locations are identified by a code and that Texas
is 1 and Anyplace else is 0. The selection of location probably
comes from a user interface but we set it explicitly to
Texas:
// Select location Texas
int loc = 1;
The location matrix together with the location tells us what
part of the data files need to be declared as arrays.
Here is code to determine the first item of data needed and the
number of items:
// Determine start location and extent
start = LocMat.index(loc, 0).getInt();
extent = SmArray.vector(LocMat.index(loc, 1));
We don’t need the coverage data because we want all coverages.
We do need the risk data, accident quarter, pay quarter
and pay amount. Here is the code to access this data only
for the desired location:
// Access risk data
pathm = path + „cov.sma“;
Risk = SmArray.fileArrayRead(pathm, 4, extent, start);
// Access accident quarter
pathm = path + „accqtr.sma“;
ACQTR = SmArray.fileArrayRead(pathm, 4, extent, start);
// Access pay quarter
pathm = path + „payqtr.sma“;
PayQTR = SmArray.fileArrayRead(pathm, 4, extent, start);
// Access pay amount
pathm = path + „paid.sma“;
Paid = SmArray.fileArrayRead(pathm, 5, extent, start);
For each of the data arrays, we want only the items that
correspond to Cobol programmers. Here is a mask with 1
wherever the Risk is „Cob“ (assuming the data is encoded
with Cobol 0, C++1, SmartArrays 2):
// Select Cobol programmers
mask = Risk.eq(0);
Select only data for Cobol programmers:
// Select only data for Cobol programmers
ACQTR = mask.compress(ACQTR);
PayQTR = mask.compress(PayQTR);
Paid = mask.compress(Paid);
For each accident quarter and pay quarter we want to sum
the losses. In the following code, the numbers (4,4) could
be computed values. In this example, it is known that there
are 4 quarters of data. „selectUpdateBySubscript(Sm.plus“
is a „Group by sum“ operation.
SmArray forsum = SmArray.vector(ACQTR, PayQTR);
SmArray LossT = SmArray.scalar(0).reshapeBy(4,4);
LossT.selectUpdateBySubscript(Sm.plus, Paid, forsum);
„LossT“ is the desired Loss triangle shown previously
LossT.show();
979 1661 1823 1853
0 4151 5250 5295
0 0 2314 2710
0 0 0 335
As was said before, this is not a numerically intensive computation
(although SmartArrays loves big computations). It
is only a computation on big data. Using some forethought
in data organization and using the SmartArrays feature that
allows you to declare part of a file as an array means that you
can greatly reduce the amount of data that is ever looked at
and achieve almost instantaneous results even with a hundred
million rows of data.
You could write this computation in many languages using
the recipe discussed here but the array paradigm of SmartArrays
allowed it to be written in very few lines of code – a
few lines to access the data, some selection lines using compress
to select he desired data, selectUpdateBySubscript to
sum by groups. A compact program that is close to the description
of the problem is easier to write, easier to read,
easier to maintain, easier to enhance, and easier to understand.
In this, SmartArrays emulates APL.
Conclusion
APL was the first real array processing language and it
began the Online Analytical Processing (OLAP) industry.
APL2 extended this paradigm to more complicated collections
of data. SmartArrays captures and extends the APL
22 APL - Journal 2006, 25. Jg., Heft 1/2