ePolyglot: Examination and development of multilanguage programming using Eiffel, Python, and Haskell | ||
---|---|---|

Prev | Chapter 13. Haskell from Eiffel | Next |

We'll walk through our sample program in somewhat more detail this time, because the process of getting Haskell to play nicely with Eiffel was a slight bit more complex than the Eiffel/Python interactivity earlier. First, the problem.

The Software Engineering Institute's Personal Software Process training program contains several exercises, most having to do with statistical analysis and prediction. The program we're going to do as a sample is that of linear regression, program 4a in the PSP curriculum:

Write a program to calculate the linear regression size-estimating parameters for
a set of | ||

--Humphrey95 |

Essentially, this just requires reading pairs of numbers from a file and doing a regression analysis to find the Beta-0 and Beta-1 parameters for linear regression. In terms of multilanguage programming, we'll divide the problem thusly: Eiffel, with its strong typing and program control, will handle the logic and flow; Python, with its powerful string and file manipulation facilities, will handle the reading of data from the data file, and Haskell, with its superior functional approach, will handle the actual calculation.

Note:This is, of course, a demonstration program. When we finish it in the next section, the final executable will be 2.1 megabytes before stripping, and 875k afterward--a far cry from the 30k or 21k from the pure Eiffel or C++ versions of this program!

To show why Haskell is a good language for this sort of analysis,
it's interesting to compare similar code in C++ and Eiffel. In C++, the code
to calculate the regression parameters looks something like
this, where `m_xs` and `m_ys` are
linked lists holding the data for analysis, and supporting functions
(such as the `x_mean` and `y_mean`
functions) are not listed for clarity:

**Example 13-1. C++ code for the regression parameters**

double paired_number_list::beta_1_numerator( void ) const { double Result = 0; list<double>::const_iterator x_iter; list<double>::const_iterator y_iter; for( x_iter = m_xs.begin(), y_iter = m_ys.begin(); (x_iter != m_xs.end()) && (y_iter != m_ys.end()); ++x_iter, ++y_iter ) { Result += (*x_iter)*(*y_iter); } Result -= static_cast<double>(entry_count())*x_mean()*y_mean(); return Result; } double paired_number_list::beta_1_denominator( void ) const { double Result = 0; list<double>::const_iterator x_iter; list<double>::const_iterator y_iter; for( x_iter = m_xs.begin(), y_iter = m_ys.begin(); (x_iter != m_xs.end()) && (y_iter != m_ys.end()); ++x_iter, ++y_iter ) { Result += (*x_iter)*(*x_iter); } Result -= static_cast<double>(entry_count())*x_mean()*x_mean(); return Result; } double paired_number_list::beta_1( void ) const { return beta_1_numerator() / beta_1_denominator(); } double paired_number_list::beta_0( void ) const { return y_mean() - beta_1() * x_mean(); } |

The equivalent code in Eiffel looks something like this:

**Example 13-2. Eiffel code for the linear regression analysis**

beta_1_numerator : DOUBLE is local index : INTEGER do Result := 0 from index := xs.lower until not ( xs.valid_index( index ) and ys.valid_index( index ) ) loop Result := Result + xs.item(index) * ys.item( index ) index := index + 1 end Result := Result - entry_count.to_double * x_mean * y_mean end beta_1_denominator : DOUBLE is local index : INTEGER do Result := 0 from index := xs.lower until not ( xs.valid_index( index ) and ys.valid_index( index ) ) loop Result := Result + xs.item(index) * xs.item( index ) index := index + 1 end Result := Result - entry_count.to_double * x_mean * x_mean end beta_1 : DOUBLE is do Result := beta_1_numerator / beta_1_denominator end beta_0 : DOUBLE is do Result := y_mean - beta_1 * x_mean end |

In contrast, the Haskell code for the same is not only much more terse, but also surprisingly readable and understandable once you get past a few small hurdles:

**Example 13-3. Equivalent code in Haskell**

beta_1 :: [Double] -> [Double] -> Double beta_1 xs ys = top / bottom where top = sum( mult_terms xs ys ) - dcount xs * average xs * average ys bottom = sum ( map square xs) - dcount xs * square ( average xs ) beta_0 :: [Double] -> [Double] -> Double beta_0 xs ys = average ys - beta_1 xs ys * average xs |

The above beta_1 and beta_0 functions are those we'd like to use from Haskell--they are clean and straightforward, each taking two lists of double-precision values ("[Double]" in the function signature) and returning a double-precision value as a result. Our sample program in this chapter will use static arrays of numbers in order to avoid the extra hassle of reading the numbers from a file with Python; that happens next chapter.