[Boost-commit] svn:boost r51197 - in sandbox/numeric_bindings/libs/numeric/bindings/tools: . templates templates/computational templates/driver templates/test

Subject: [Boost-commit] svn:boost r51197 - in sandbox/numeric_bindings/libs/numeric/bindings/tools: . templates templates/computational templates/driver templates/test
From: rutger_at_[hidden]
Date: 2009-02-11 09:02:00

Author: rutger
Date: 2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
New Revision: 51197
URL: http://svn.boost.org/trac/boost/changeset/51197

Log:
Added the Python generator scripts for the BLAS and LAPACK bindings 

Added:
   sandbox/numeric_bindings/libs/numeric/bindings/tools/README.txt   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/bindings.py   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/blas_generator.py   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/lapack_generator.py   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/netlib.py   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/blas.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/bdsdc.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/bdsqr.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/gebrd.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/gelqf.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/hetr.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/hgeqz.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/larz.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/opmtr.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/org.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/orm.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/stedc.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/un.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/cgesv.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gbsv.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gbsvx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gees.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/geesx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/geev.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/geevx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gegv.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gels.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gelsd.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gelss.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gelsy.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gesdd.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gesvd.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gesvx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gges.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/ggesx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/ggev.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/ggevx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/ggglm.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gglse.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hbev.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hbevd.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hbevx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hbgv.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hbgvd.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hbgvx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/heev.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/heevd.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/heevr.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/heevx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hegv.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hegvd.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hegvx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hesv.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hesvx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpev.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpevd.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpevx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpgv.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpgvd.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpgvx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpsv.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpsvx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/lalsd.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/pbsv.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/pbsvx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/ppsv.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/ppsvx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sbev.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sbevd.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sbevx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sbgv.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sbgvd.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sbgvx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spev.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spevd.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spevx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spgv.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spgvd.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spgvx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spsv.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spsvx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/stev.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/stevd.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/stevr.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/syev.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/syevd.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/syevr.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/syevx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sygv.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sygvd.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sygvx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sysv.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sysvx.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/lapack.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/singleton_blas.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/singleton_lapack.hpp   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/test/
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/test/CMakeLists.txt   (contents, props changed)
   sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/test/test_case.cpp   (contents, props changed)

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/README.txt
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/README.txt	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,25 @@
+
+Using the Python Generator
+----
+To test the python generator, you will need the lapack sources. Make sure the path to your lapack sources is also set in the lapack_parser.py file; look for the variable lapack_src_path.
+
+On a debian-based system, acquiring the sources of BLAS and LAPACK may be achieved by 
+
+$ cd tools
+$ apt-get source blas lapack
+
+this will give you a subdirectory called 'blas-X.X' and 'lapack-X.X.X'. Running the generator may be done by
+
+$ ./lapack_generator
+$ ./blas_generator
+
+from within the tools directory.
+
+To use the compile_test, you need cmake. Please do a 
+
+$ mkdir build
+$ cd build
+$ cmake ..
+$ make
+
+to try to compile all test files. ]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/bindings.py
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/bindings.py	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,121 @@
+#!/usr/bin/python
+#
+#  Copyright (c) 2008 Thomas Klimpel and Rutger ter Borg
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+#
+
+import re
+
+#
+# This routine actually does what it's named after :-).
+# Changes: 
+# * used regex matching on delimiter instead of .find
+#
+def proper_indent( input_string ):
+  max_chars = 80
+  all_results = []
+  find_delim = re.compile( "([\,\+/]|\|\||>=|std::log\(|work\()[ ]*" )
+  for input_line in input_string.splitlines():
+    result = ''
+    # extra indentation size is 8
+    indentation = len(input_line) - len(input_line.lstrip() ) + 8
+
+    #print "indentation: ", indentation
+
+    indentation_string = ''
+    for i in range(indentation ):
+      indentation_string += ' '
+    #cur_index = input_line.find( ",", 0, -1 ) + 1
+
+    match_delim = find_delim.search( input_line, 0, len(input_line) )
+    if match_delim != None:
+      #print match_delim.end( 0 )- match_delim.start( 0 )
+      cur_index = match_delim.end( 0 )
+    else:
+      cur_index = 0
+
+    prev_index = 0
+    prev_slice = 0
+    prev_indentation = 0
+    while cur_index != 0:
+      if ( (cur_index - prev_slice) > (79-prev_indentation) ):
+        result = result + input_line[ prev_slice : prev_index ].rstrip() + '\n' + indentation_string
+        prev_indentation = indentation
+        prev_slice = prev_index
+      prev_index = cur_index
+      if cur_index != len(input_line):
+        match_delim = find_delim.search( input_line, cur_index+1, len(input_line) )
+        if match_delim != None:
+          #print match_delim.end( 0 )- match_delim.start( 0 )
+          cur_index = match_delim.end( 0 )
+        else:
+          cur_index = 0
+        #cur_index = input_line.find( ",", cur_index+1, -1 ) + 1
+        if cur_index == 0:
+          cur_index = len(input_line)
+      else:
+        cur_index = 0
+    cur_index = len( input_line )
+    result = result + input_line[ prev_slice : cur_index ]
+    all_results += [ result ]
+
+  return "\n".join( all_results ) + "\n"
+
+
+
+#
+# Write the blas.h/lapack_names.h file.
+#
+def write_names_header( global_info_map, group, template_map, dest_file ):
+  parsermode = template_map[ 'PARSERMODE' ].lower()
+  group_keys = group.keys()
+  group_keys.sort()
+  content = ''
+  for g in group_keys:
+    content += '// Variants of ' + g.lower() + '\n'
+    for k in group[ g ]:
+      template = template_map[ parsermode + '_names.h_function' ]
+      template = template.replace( '$SUBROUTINE', k )
+      template = template.replace( '$subroutine', k.lower() )
+      content += template
+    content += '\n'
+
+  result = template_map[ parsermode + '_names.h' ]
+  result = result.replace( "$CONTENT", content )
+  #//result = result.replace( "$PARSERMODE", template_map[ "PARSERMODE" ] )
+
+  open( dest_file, 'wb' ).write( result )
+
+
+#
+# Write the blas.h/lapack.h file
+#
+def write_header( global_info_map, group, template_map, dest_file ):
+  parsermode = template_map[ 'PARSERMODE' ].lower()
+  group_keys = group.keys()
+  group_keys.sort()
+  content = ''
+  for g in group_keys:
+    content += '$INDENT// Variants of ' + g.lower() + '\n'
+    for k in group[ g ]:
+
+      template = template_map[ parsermode + '.h_function' ]
+      arg_list = []
+      for arg in global_info_map[ k ][ 'arguments' ]:
+        arg_list += [ global_info_map[ k ][ 'argument_map' ][ arg ][ 'code' ][ 'lapack_h' ] ]
+
+      template = template.replace( "$SUBROUTINE", k )
+      template = template.replace( "$ARGUMENTS", ", ".join( arg_list ) )
+      content += proper_indent( template )
+
+    content += '\n'
+
+  result = template_map[ parsermode + '.h' ]
+  result = result.replace( "$CONTENT", content )
+  result = result.replace( '$INDENT', '    ' )
+  #result = result.replace( "$PARSERMODE", template_map[ "PARSERMODE" ] )
+
+  open( dest_file, 'wb' ).write( result )

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/blas_generator.py
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/blas_generator.py	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,823 @@
+#!/usr/bin/python
+#
+#  Copyright (c) 2008 Thomas Klimpel and Rutger ter Borg
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+#
+
+import netlib
+import bindings
+
+import re, os.path, copy
+from types import StringType
+
+# for debugging purposes
+import pprint
+
+
+global_type_map = { 
+  'CHARACTER': 'char',
+  'LOGICAL': 'logical_t', 
+  'INTEGER': 'integer_t',
+  'REAL': 'float', 
+  'DOUBLE PRECISION': 'double' }
+  
+templates = {}
+
+
+  
+def c_type( name, properties ):
+  m_type_map = global_type_map
+  m_type_map[ 'COMPLEX' ] = 'fcomplex_t'
+  m_type_map[ 'COMPLEX*16' ] = 'dcomplex_t'
+
+  result = m_type_map[ properties[ 'value_type' ] ];
+  if properties[ 'io' ] == [ 'input' ]:
+    result += ' const'
+  result += '*'
+  result += ' ' + name.lower()  # is this really needed?
+  
+  return result
+  
+  
+def cpp_type( name, properties ):
+  m_type_map = global_type_map
+  m_type_map[ 'COMPLEX' ] = 'traits::complex_f'
+  m_type_map[ 'COMPLEX*16' ] = 'traits::complex_d'
+  
+  result = m_type_map[ properties[ 'value_type' ] ]
+  
+  if properties[ 'type' ] == 'scalar':
+    if properties[ 'io' ] == [ 'input' ]:
+      result += ' const'
+    elif properties[ 'io' ] == [ 'external procedure' ]:
+      result += '*'
+    else:
+      result += '&'
+    
+  if properties[ 'type' ] == 'vector' or properties[ 'type' ] == 'matrix':
+    result += '*'
+    
+  result += ' ' + name.lower()
+    
+  return result
+  
+def call_c_type( name, properties ):
+  result = ''
+  if properties[ 'type' ] == 'vector' or properties[ 'type' ] == 'matrix':
+    if properties[ 'value_type' ][ 0:7] == 'COMPLEX':
+      result = 'traits::complex_ptr(' + name.lower() + ')'
+    else:
+      result = name.lower()
+  elif properties[ 'type' ] == 'scalar':
+    if properties[ 'value_type' ][ 0:7] == 'COMPLEX':
+      result = 'traits::complex_ptr(&' + name.lower() + ')'
+    else:
+      result = '&' + name.lower()
+  
+  return result
+  
+
+def call_level0_type( name, properties, arg_map ):
+  result = ''
+  if properties[ 'type' ] == 'matrix':
+    result = "traits::matrix_storage(" + name.lower() + ")"
+  elif properties[ 'type' ] == 'vector':
+    my_name = name.lower()
+    if 'workspace' in properties[ 'io' ]:
+      my_name = 'work.select(' + workspace_type( name, properties ) + '())'
+    result = "traits::vector_storage(" + my_name + ")"
+  elif properties.has_key( 'trait_type' ):
+    if properties[ 'trait_type' ] == 'lda':
+      result = "traits::leading_dimension(" + properties[ 'trait_of' ].lower() + ")"
+    if properties[ 'trait_type' ] == 'num_columns':
+      result = "traits::matrix_size2(" + properties[ 'trait_of' ].lower() + ")"
+    if properties[ 'trait_type' ] == 'num_rows':
+      result = "traits::matrix_size1(" + properties[ 'trait_of' ].lower() + ")"
+    if properties[ 'trait_type' ] == 'size':
+      my_name = properties[ 'trait_of' ].lower()
+      referring_to_properties = arg_map[ properties[ 'trait_of' ] ]
+      if 'workspace' in referring_to_properties[ 'io' ]:
+        my_name = 'work.select(' + workspace_type( properties[ 'trait_of' ].lower(), referring_to_properties ) + \
+                  '())'
+      result = "traits::vector_size(" + my_name + ")"
+    if properties[ 'trait_type' ] == 'uplo':
+      result = "traits::matrix_uplo_tag(" + properties[ 'trait_of' ].lower() + ")"
+  else:
+    result = name.lower()
+  return result
+
+
+def level1_type( name, properties ):
+  result = None
+  if not properties.has_key( 'trait_of' ) and 'workspace' not in properties[ 'io' ]:
+    if properties[ 'type' ] == 'matrix':
+      result = "Matrix" + name + "& " + name.lower()
+    elif properties[ 'type' ] == 'vector':
+      result = "Vector" + name + "& " + name.lower()
+    else:
+      result = cpp_type( name, properties )
+      if properties[ 'value_type' ] == 'REAL':
+        result = result.replace( "float", "real_type" )
+      if properties[ 'value_type' ] == 'DOUBLE PRECISION':
+        result = result.replace( "double", "real_type" )
+  return result
+
+
+def level2_type( name, properties ):
+  result = level1_type( name, properties )
+  if name == 'INFO' and 'output' in properties[ 'io' ]:
+    result = None
+
+  if result != None:
+    if properties[ 'value_type' ] == 'REAL' or properties[ 'value_type' ] == 'DOUBLE PRECISION':
+      result = result.replace( "real_type", "typename traits::$TYPEOF_FIRST_TYPENAME" + \
+        "_traits< $FIRST_TYPENAME >::value_type" )
+
+  return result
+
+
+def level1_typename( name, properties ):
+  result = None
+  if 'workspace' not in properties[ 'io' ]:
+    if properties[ 'type' ] == 'matrix':
+      result = "typename Matrix" + name
+    if properties[ 'type' ] == 'vector':
+      result = "typename Vector" + name
+  return result
+
+
+
+def nested_list_args( arg ):
+  print "finding nested list arguments of", arg
+  if type( arg ) == StringType:
+    if re.compile( '^[A-Z]+$' ).match( arg ) == None:
+      return [ None ]
+    else:
+      return [ arg.upper() ]
+  
+  # we are dealing with a list-type, e.g., 
+  # [ '*', [ 'A', 'B' ] ]
+  # [ 'A', 'B' ]
+  result = []
+  if re.compile( '^[A-Z]+$' ).match( arg[0] ) == None:
+    for a in arg[1]:
+      sub_result = nested_list_args( a )
+      if sub_result != [ None ]:
+        for r in sub_result:
+          if r not in result:
+            result.append( r )
+
+  else:
+    for a in arg:
+      result.append( a )
+
+  print "returning ",result
+  return result
+
+
+
+
+def expand_nested_list( arg, arg_map, use_arg_map = True ):
+
+  print "Expanding nested list: ", arg, len(arg)
+  if type( arg ) == StringType:
+    print "Type is string"
+    # .....
+    if re.compile( '^[A-Z]+$' ).match( arg ) == None:
+      return arg
+    else:
+      if use_arg_map:
+        if not arg_map.has_key( arg ):
+          return '?' + arg.upper()
+        else:
+          return arg_map[ arg ][ 'code' ][ 'call_level_0' ]
+      else:
+        return arg.lower()
+    
+  if arg[0] == '()':
+    result = '(' + expand_nested_list( arg[1], arg_map, use_arg_map ) + ')'
+    return result
+    
+  if arg[0] == 'max' or arg[0] == 'min':
+    print "arg1: ", arg[1]
+    result = 'std::' + arg[0] + '('
+    i = 0
+    for a in arg[1]:
+      result += expand_nested_list( a, arg_map, use_arg_map )
+      i += 1
+      if i != len(arg[1]):
+        result += ","
+    result += ')'
+    return result
+  
+  if arg[0] == '*' or arg[0] == '/' or arg[0] == '+' or arg[0] == '-':
+    print "arg1: ", arg[1]
+    arg_list = []
+    for a in arg[1]:
+      arg_list += [ expand_nested_list( a, arg_map, use_arg_map ) ]
+    result = arg[0].join( arg_list )
+    return result
+  
+  print "ERROR: Don't know what to do!!"
+  return 'ERROR'
+
+def level1_assert( name, properties, arg_map ):
+  result = None
+  
+  if properties.has_key( 'assert_char' ):
+    result = "assert( "
+    result_array = []
+    for char in properties[ 'assert_char' ]:
+      result_array += [ call_level0_type( name, properties, arg_map ) + ' == \'' + char + '\'' ]
+    result += " || ".join( result_array )
+    result += " );"
+    
+  if properties.has_key( 'assert_ge' ) and not properties.has_key( 'workspace_query_for' ):
+    result = "assert( " + call_level0_type( name, properties, arg_map ) + " >= " + expand_nested_list( properties[ 'assert_ge' ], arg_map ) + ' );'
+      
+  if 'workspace' in properties[ 'io' ]:
+    min_workspace_call = min_workspace_call_type( name, properties, arg_map )
+    if min_workspace_call == None:
+      min_workspace_call = '$CALL_MIN_SIZE'
+    result = 'assert( traits::vector_size(work.select(' + workspace_type( name, properties ) + '()) >= ' + \
+             'min_size_' + name.lower() + '( ' + min_workspace_call + ' )));'
+  
+  elif properties.has_key( 'assert_size' ):
+    result = "assert( traits::vector_size(" + call_level0_type( name, properties, arg_map ) + ") >= " + \
+      expand_nested_list( properties[ 'assert_size' ], arg_map ) + ' );'
+  
+  return result
+
+
+def call_level1_type( name, properties ):
+  result = None
+  if level1_type( name, properties ) != None:
+    result = name.lower()
+  return result
+
+
+def workspace_type( name, properties ):
+  result = None
+  if 'workspace' in properties[ 'io' ]:
+    if properties[ 'value_type' ] == 'INTEGER':
+      result = 'integer_t'
+    elif properties[ 'value_type' ] == 'LOGICAL':
+      result = 'bool'
+    elif properties[ 'value_type' ] == 'REAL' or properties[ 'value_type' ] == 'DOUBLE PRECISION':
+      result = 'real_type'
+    else: 
+      result = 'value_type'
+  return result
+
+
+
+
+def opt_workspace_pre_type( name, properties, arg_map ):
+  result = None
+  if 'workspace' in properties[ 'io' ]:
+    if properties.has_key( 'workspace_query_by' ):
+      result = workspace_type( name, properties ) + ' opt_size_' + name.lower() + ';'
+    else:
+      min_workspace_call = min_workspace_call_type( name, properties, arg_map )
+      if min_workspace_call == None:
+        min_workspace_call = '$CALL_MIN_SIZE'
+      result = 'traits::detail::array< ' + workspace_type( name, properties ) + ' >' + \
+               ' tmp_' + name.lower() + '( min_size_' + name.lower() + '( ' + min_workspace_call + ' ) );'
+  return result
+
+
+def opt_workspace_post_type( name, properties ):
+  result = None
+  if 'workspace' in properties[ 'io' ]:
+    if properties.has_key( 'workspace_query_by' ):
+      if properties['value_type'] == 'INTEGER':
+        result = 'traits::detail::array< ' + workspace_type( name, properties ) + ' >' + \
+               ' tmp_' + name.lower() + '( opt_size_' + name.lower() + ' );'
+      else:
+        result = 'traits::detail::array< ' + workspace_type( name, properties ) + ' >' + \
+               ' tmp_' + name.lower() + '( traits::detail::to_int( opt_size_' + name.lower() + ' ) );'
+  return result
+
+
+
+def opt_workspace_query_type( name, properties, arg_map ):
+  result = None
+  if properties.has_key( 'workspace_query_for' ):
+    result = '-1'
+  elif 'workspace' in properties[ 'io' ]:
+    if properties.has_key( 'workspace_query_by' ):
+      result = '&opt_size_' + name.lower();
+    else:
+      result = 'traits::vector_storage(tmp_' + name.lower() + ')'
+  else:
+    result = call_level0_type( name, properties, arg_map )
+  return result
+
+
+def min_workspace_size_type( name, properties, arg_map ):
+  result = None
+  if 'workspace' in properties[ 'io' ] and properties.has_key( 'assert_size' ):
+    result = expand_nested_list( properties[ 'assert_size' ], arg_map, False );
+  return result
+
+
+def min_workspace_arg_type( name, properties, arg_map ):
+  result = None
+  if 'workspace' in properties[ 'io' ] and properties.has_key( 'assert_size_args' ):
+    code_result = []
+    for arg in properties[ 'assert_size_args' ]:
+      if arg_map.has_key( arg ):
+        code_result += [ cpp_type( arg, arg_map[ arg ] ) ]
+      else:
+        code_result += [ '?' + arg.upper() ]
+    result = ", ".join( code_result )
+  return result
+
+
+def min_workspace_call_type( name, properties, arg_map ):
+  result = None
+  if 'workspace' in properties[ 'io' ] and properties.has_key( 'assert_size_args' ):
+    code_result = []
+    for arg in properties[ 'assert_size_args' ]:
+      if arg_map.has_key( arg ):
+        code_result += [ call_level0_type( arg, arg_map[ arg ], arg_map ) ]
+      else:
+        code_result += [ '?' + arg.upper() ]
+      
+    result = ", ".join( code_result )
+  return result
+
+
+def user_defined_type( name, properties, arg_map ):
+  result = None
+  if properties.has_key( 'user_defined' ):
+    result = properties[ 'user_defined' ]
+  return result
+
+
+
+#
+#
+#
+#
+def match_formulae( text_field ):
+  find_start = re.compile( '([A-Z]+)\s?(>=|is\sat\sleast)\s?(.*)the\scode\swill', re.M | re.S ).findall( text_field )
+  for element in find_start:
+    print element
+
+
+
+#
+# Split string using a list of delimiters
+# Delimiters may be substrings of length 1 or 2 (may be increased if necessary)
+#
+def split_delim( s, delim = [','] ):
+  result = []
+  parentheses = 0
+  cur_pos = 0
+  prev_pos = 0
+  for index in range( 0, len(s) ):
+    if s[ index ] == '(': 
+      parentheses += 1
+    elif s[ index ] == ')':
+      parentheses -= 1
+    for length in range( 1, 3 ):
+      if index >= (length-1) and parentheses == 0:
+        c = s[ index-(length-1): index+1 ]
+        if c in delim:
+          result += [ s[ prev_pos:(index-(length-1)) ] ]
+          prev_pos = index+1
+          
+  result += [ s[ prev_pos:len(s) ] ]
+  return result
+
+
+
+#
+# Look for implicit products, like 5N, and replace with 5*N
+#
+def replace_implicit_products( text_field ):
+  result = re.sub( '([0-9])+([A-Z]+)', '\\1*\\2', text_field )
+  return result
+
+
+
+
+def decompose_formula( text_field ):
+  text_field = text_field.strip()
+  print "Decompose: ", text_field
+  
+  if text_field[0] == '(' and text_field[-1] == ')':
+    result = text_field[ 1:-1 ]
+    return [ '()', decompose_formula( result ) ]
+  
+  if len( split_delim( text_field, [ ',' ] ) ) > 1:
+    print "ERROR! (in BLAS?)"
+    return [ 'ERROR' ]
+  
+  #
+  # Detect leaf: if text_field equals a argument (like N), or a number
+  #  
+  if re.compile( '^([a-zA-Z]+|[0-9]+)$' ).match( text_field ):
+    print "decompose: at leaf: '" + text_field + "'"
+    return text_field.upper()
+  
+  
+  if len( split_delim( text_field, [ '**' ] ) ) > 1:
+    print 'decompose: inserting pow'
+    arguments = split_delim( text_field, [ '**' ] )
+    print arguments
+    result = []
+    for arg in arguments:
+      result.append( decompose_formula( arg ) )
+    return [ 'pow', result ]
+  
+  for operator in [ '*', '/', '+', '-' ]:
+    if len( split_delim( text_field, [ operator ] ) ) > 1:
+      print 'decompose: inserting ' + operator
+      arguments = split_delim( text_field, operator )
+      print arguments
+      result = []
+      for arg in arguments:
+        result.append( decompose_formula( arg ) )
+      return [ operator, result ]
+    
+  
+  if (text_field[ 0:4 ] == 'max(' or text_field[ 0:4 ] == 'MAX(') and \
+    text_field[ -1 ] == ')':
+    print "decompose: inserting max"
+    arguments = split_delim( text_field[ 4:-1 ] )
+    print arguments, len(arguments)
+    # keep max a binary function ... :-)
+    if len( arguments ) > 2:
+      return [ 'max', [ decompose_formula( arguments[0] ), decompose_formula( 'max(' + ",".join( arguments[1:] ) + ')' ) ] ]
+    else:  
+      result = []
+      for arg in arguments:
+        result.append( decompose_formula( arg ) )
+      #result = [ decompose_formula( arguments[0] ), decompose_formula( arguments[1] ) ]
+      return [ 'max', result ]
+  
+
+  if (text_field[ 0:4 ] == 'min(' or text_field[ 0:4 ] == 'MIN(') and \
+    text_field[ -1 ] == ')':
+    print "decompose: inserting min"
+    arguments = split_delim( text_field[ 4:-1 ] )
+    print arguments, len(arguments)
+    # keep max a binary function ... :-)
+    if len( arguments ) > 2:
+      return [ 'min', [ decompose_formula( arguments[0] ), decompose_formula( 'min(' + ",".join( arguments[1:] ) + ')' ) ] ]
+    else:  
+      result = []
+      for arg in arguments:
+        result.append( decompose_formula( arg ) )
+      #result = [ decompose_formula( arguments[0] ), decompose_formula( arguments[1] ) ]
+      return [ 'min', result ]
+  
+
+#
+#
+def match_assert_ge( argument_map, text_field ):
+  #print "Match assert GE..."
+  match_it = re.compile( ' +[A-Z]+[ ]{0,3}(>=|must be at least)[ ]{0,3}([0-9]|(min|max|MIN|MAX|[\(\)\,0-9A-Z\+\*\-])+)' ).findall( text_field )
+  if len( match_it ) == 1:
+    print "Match assert GE:", match_it
+    #print match_it
+    #if len( match_it[ 0 ][ 2 ] ) > 0:
+    return decompose_formula( match_it[ 0 ][ 1 ] )
+  else:
+    print "nr of matches: ", len( match_it )
+    return None
+  
+
+
+
+
+# try different keys, return the one that exists, if any
+
+def my_has_key( key_name, template_map ):
+  # try, e.g., gelsd.all.
+  m_all_key = key_name.replace( ".complex", ".all" ).replace( ".real", ".all" )
+  if template_map.has_key( key_name ):
+    print "using key ", key_name
+    return key_name
+  if template_map.has_key( m_all_key ):
+    print "using key ", m_all_key
+    return m_all_key
+  print "tried keys ", key_name, "and", m_all_key,", no results"
+  return None
+
+
+
+#
+# Default user-defined arg is of type scalar INTEGER
+#
+def add_user_defined_args( arg, argument_map, template_map, base_name ):
+  print "Trying to add user-defined argument definitions for", arg
+
+  argument_map[ arg ] = {}
+
+  base_key = base_name.lower() + '.' + arg
+  print "base_key",base_key
+
+  if my_has_key( base_key + '.value_type', template_map ) != None:
+    argument_map[ arg ][ 'value_type' ] = template_map[ my_has_key( base_key + '.value_type', template_map ) ].strip()
+  else:
+    argument_map[ arg ][ 'value_type' ] = 'INTEGER'
+
+  if my_has_key( base_key + '.type', template_map ) != None:
+    argument_map[ arg ][ 'type' ] = template_map[ my_has_key( base_key + '.type', template_map ) ].strip()
+  else:
+    argument_map[ arg ][ 'type' ] = 'scalar'
+
+  if my_has_key( base_key + '.init', template_map ) != None:
+    argument_map[ arg ][ 'user_defined' ] = template_map[ my_has_key( base_key + '.init', template_map ) ].strip()
+  else:
+    argument_map[ arg ][ 'user_defined' ] = 'UNDEFINED'
+
+  argument_map[ arg ][ 'io' ] = [ 'input' ]
+
+  return
+
+
+
+#
+# Desired order of routines in C++ code: float, double, single complex, double complex
+#
+def routine_cmp( a, b ):
+  letter_a = a[0]
+  letter_b = b[0]
+  value_map = { 'S': 0, 'D': 1, 'C': 2, 'Z': 3 }
+  result = 0
+  if value_map[ a[0] ] < value_map[ b[ 0] ]:
+    result = -1
+  if value_map[ a[0] ] > value_map[ b[ 0] ]:
+    result = 1
+  return result
+    
+
+#
+# Group subroutines on their name, with the first character removed. This will 
+# group them in the same .hpp file as well. Sort these subroutines based on 
+# routine_cmp above.
+#
+def group_by_value_type( global_info_map ):
+  group_map = {}
+  for i in global_info_map.keys():
+    short_name = i[ 1: ]
+    if not group_map.has_key( short_name ):
+      group_map[ short_name ] = []
+    group_map[ short_name ] += [ i ]
+  for value in group_map.values():
+    value.sort( routine_cmp )
+  return group_map
+  
+
+
+ 
+#
+# Write the (many) driver routine file(s).
+#
+def write_functions( info_map, group, template_map, base_dir ):
+  #
+  # group.keys() is a vector of different grouped function names
+  # like gees, dgesv, etc.
+  #
+  for group_name, subroutines in group.iteritems():
+
+    filename = group_name.lower() + '.hpp'
+    includes = [ '#include <cassert>',
+      '#include <boost/numeric/bindings/traits/traits.hpp>',
+      '#include <boost/numeric/bindings/traits/type_traits.hpp>', 
+      '#include <boost/numeric/bindings/blas/blas.h>' ]
+      
+    if template_map.has_key( group_name.lower() + '.includes' ):
+      includes += template_map[ group_name.lower() + '.includes' ].splitlines()
+
+    #
+    # LEVEL 0 HANDLING
+    #  
+    overloads = ''
+    for subroutine in subroutines:
+      sub_template = template_map[ 'blas_overloads' ]
+      # add the argument list here
+      arg_list = []
+      lapack_arg_list = []
+      for arg in info_map[ subroutine ][ 'arguments' ]:
+        arg_list += [ info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'level_0' ] ]
+        lapack_arg_list += [ info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'call_c_header' ] ]
+      sub_template = sub_template.replace( "$LEVEL0", ", ".join( arg_list ) )
+      sub_template = sub_template.replace( "$CALL_C_HEADER", ", ".join( lapack_arg_list ) )
+      sub_template = sub_template.replace( "$SUBROUTINE", subroutine )
+      sub_template = sub_template.replace( '$groupname', group_name.lower() )
+      
+      overloads += bindings.proper_indent( sub_template )
+  
+    cases = {}
+    # first, see what kind of functions we have
+    # needed for argument check etc.
+    for subroutine in subroutines:
+      if subroutine[0] == 'S' or subroutine[0] == 'D':
+        if not cases.has_key( 'real' ):
+          cases[ 'real' ] = {}
+          cases[ 'real' ][ 'subroutines' ] = []
+        cases[ 'real' ][ 'subroutines' ] += [ subroutine ]
+      if subroutine[0] == 'C' or subroutine[0] == 'Z':
+        if not cases.has_key( 'complex' ):
+          cases[ 'complex' ] = {}
+          cases[ 'complex' ][ 'subroutines' ] = []
+        cases[ 'complex' ][ 'subroutines' ] += [ subroutine ]
+
+    #
+    # LEVEL 1 and 2 HANDLING
+    #
+    level1_map = {}
+    level2_map = {}
+    for value_type, case_map in cases.iteritems():
+      level1_template = ''
+      level2_template = ''
+      level1_template = template_map[ 'blas_level1' ]
+
+      level0_arg_list = []
+      level1_arg_list = []
+      call_level1_arg_list = []
+      level1_type_arg_list = []
+      level1_assert_list = []
+      for arg in info_map[ subroutine ][ 'arguments' ]:
+        level0_arg_list += [ info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'call_level_0' ] ]
+        if info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'level_1' ] != None:
+          level1_arg_list += [ info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'level_1' ] ]
+        if info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'call_level_1' ] != None:
+          call_level1_arg_list += [ info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'call_level_1' ] ]
+        if info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'level_1_type' ] != None and \
+          info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'level_1_type' ] not in level1_type_arg_list:
+          level1_type_arg_list += [ info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'level_1_type' ] ]
+        if info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'level_1_assert' ] != None:
+          level1_assert_list += [ info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'level_1_assert' ] ]
+
+      # Level 1 replacements
+      level1_template = level1_template.replace( "$CALL_LEVEL0", ", ".join( level0_arg_list ) )
+      level1_template = level1_template.replace( "$CALL_LEVEL1", ", ".join( call_level1_arg_list ) )
+      level1_template = level1_template.replace( "$LEVEL1", ", ".join( level1_arg_list ) )
+      level1_template = level1_template.replace( "$TYPES", ", ".join( level1_type_arg_list ) )
+      level1_template = level1_template.replace( "$ASSERTS", "\n        ".join( level1_assert_list ) )
+
+      level1_map[ value_type ] = bindings.proper_indent( level1_template )
+
+    #
+    # LEVEL 1 and 2 FINALIZATION
+    #
+    for mapping in [ level1_map, level2_map ]:
+      if len(mapping) > 1:
+        # compare real and complex cases
+        all_keys = mapping.keys()
+        if mapping[ all_keys[0] ] == mapping[ all_keys[1] ]:
+          print "literally everything is the same!!, falling back to 1 case"
+          del mapping[ all_keys[ 1 ] ]
+
+    level1 = ''
+    for value_type in level1_map.keys():
+      level1 += level1_map[ value_type ]
+
+    #
+    # handle addition of includes
+    #
+    includes_code = ''
+    unique_includes = []
+    for include in includes:
+      if include not in unique_includes:
+        unique_includes += [ include ]
+    sorted_includes = sorted( unique_includes, lambda x, y: cmp( x.lower(), y.lower() ) )
+    if len( sorted_includes ) > 0:
+      includes_code = "\n".join( sorted_includes )
+
+    result = template_map[ 'blas.hpp' ]
+    result = result.replace( '$INCLUDES', includes_code )
+    result = result.replace( '$OVERLOADS', overloads )
+    result = result.replace( '$LEVEL1', level1 )
+    result = result.replace( '$GROUPNAME', group_name )
+    result = result.replace( '$groupname', group_name.lower() )
+
+    # replace the global variables as last (this is convenient)
+    #result = result.replace( '$INDENT', '    ' )
+    #result = result.replace( '$groupname', group_name.lower() )
+    #result = result.replace( '$DESCRIPTION', info_map[ group[g][0] ][ 'description' ] )
+
+    open( os.path.join( base_dir, filename ), 'wb' ).write( result )
+
+
+#
+# Write the (many) driver routine test cases to cpp files.
+#
+def write_test_case( info_map, group, template_map, base_dir, level_name ):
+
+  for group_name, subroutines in group.iteritems():
+
+    filename = group_name.lower() + '.cpp'
+    result = template_map[ 'test_case.cpp' ]
+    result = result.replace( '$groupname', group_name.lower() )
+    result = result.replace( '$levelname', level_name.lower() )
+
+    open( os.path.join( base_dir, filename ), 'wb' ).write( result )
+
+def write_cmakefile( level_properties, template_map, base_dir ):
+  
+  entries = '' 
+  for problem_type, problem_properties in level_properties.iteritems():
+    if problem_properties.has_key( 'routines_by_value_type' ):
+      group = problem_properties[ 'routines_by_value_type' ]
+      for group_name, subroutines in group.iteritems():
+        sub_result = template_map[ 'CMakeLists.entry' ]
+        sub_result = sub_result.replace( '$groupname', group_name.lower() )
+        entries += sub_result
+
+  filename = 'CMakeLists.txt'
+  result = template_map[ 'CMakeLists.txt' ]
+  result = result.replace( '$ENTRIES', entries )
+  open( os.path.join( base_dir, filename ), 'wb' ).write( result )
+
+
+def read_templates( template_file ):
+  file_contents = open( template_file ).read()
+  split_regex = re.compile( '^\$TEMPLATE\[([^\]]+)\]\s', re.M | re.S )
+  split_templates = split_regex.split( file_contents )[ 1:-1 ]
+  result = {}
+  for index in range(len(split_templates)/2):
+    print "Adding template", split_templates[ index*2 ]
+    result[ split_templates[ index*2 ] ] = split_templates[ index*2 + 1 ]
+  return result
+
+lapack_src_path = './blas-1.2/src'
+template_src_path = './templates'
+bindings_target_path = '../../../../boost/numeric/bindings/blas/'
+test_target_path = '../test/lapack/'
+
+templates = {}
+templates[ 'PARSERMODE' ] = 'BLAS'
+for root, dirs, files in os.walk( template_src_path ):
+  right_file = re.compile( '^.+\.(cpp|h|hpp|txt)$' )
+  for template_file in files:
+    if right_file.match( template_file ) != None:
+      path_to_template_file = os.path.join( root, template_file )
+      print "Reading template file", path_to_template_file
+      templates.update( read_templates( path_to_template_file ) )
+
+function_info_map = {}
+for lapack_file in os.listdir( lapack_src_path ):
+  right_file = re.compile( '^[cdsz].+\.f$' )
+  if right_file.match( lapack_file ) != None:
+    print "Parsing", lapack_file, "..."
+    key, value = netlib.parse_file( os.path.join( lapack_src_path, lapack_file ), templates )
+    if key != None and value != None:
+      print "Adding LAPACK subroutine", key
+      function_info_map[ key ] = value
+
+print "Grouping subroutines..."
+
+value_type_groups = {}
+value_type_groups = group_by_value_type( function_info_map )
+
+routines = {}
+routines[ 'level_1' ] = {}
+routines[ 'level_1' ][ 'endings' ] = [ 'ROTG', 'OTMG', 'ROT', 'ROTM', 'SWAP', 'SCAL', 'COPY', 'AXPY', 'DOT', 'DOTU', 'DOTC', 'NRM2', 'ASUM', 'AMAX' ]
+
+routines[ 'level_2' ] = {}
+routines[ 'level_2' ][ 'endings' ] = [ 'MV', 'SV', 'GER', 'GERU', 'GERC', 'HER', 'HPR', 'HER2', 'HPR2', 'SYR', 'SPR', 'SYR2' ]
+
+routines[ 'level_3' ] = {}
+routines[ 'level_3' ][ 'endings' ] = [ 'MM', 'RK', 'R2K', 'SM' ]
+
+for name in value_type_groups.keys():
+  found = False
+  for level, level_properties in routines.iteritems():
+      if name[ -2: ] in level_properties[ 'endings' ] or \
+         name[ -3: ] in level_properties[ 'endings' ] or \
+         name[ -4: ] in level_properties[ 'endings' ]:
+        print name, "is in " + level
+        if not level_properties.has_key( 'routines_by_value_type' ):
+          level_properties[ 'routines_by_value_type' ] = {}
+        level_properties[ 'routines_by_value_type' ][ name ] = value_type_groups[ name ]
+        found = True
+  if found == False:
+    print name, "is in {??}"
+
+print routines 
+
+
+bindings.write_names_header( function_info_map, value_type_groups, templates, bindings_target_path + 'blas_names.h' )
+bindings.write_header( function_info_map, value_type_groups, templates, bindings_target_path + 'blas.h' )
+
+for level, level_properties in routines.iteritems():
+  target_path = bindings_target_path + level
+  if not os.path.exists( target_path ):
+    print "Creating directory " + target_path
+    os.mkdir( target_path )
+
+  print level_properties
+
+  if level_properties.has_key( 'routines_by_value_type' ):
+    print "has key..." 
+    write_functions( function_info_map, level_properties[ 'routines_by_value_type' ], templates, target_path )

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/lapack_generator.py
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/lapack_generator.py	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,1052 @@
+#!/usr/bin/python
+#
+#  Copyright (c) 2008 Thomas Klimpel and Rutger ter Borg
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+#
+
+import netlib
+import bindings
+
+import re, os.path, copy
+from types import StringType
+
+# for debugging purposes
+import pprint
+
+
+global_type_map = { 
+  'CHARACTER': 'char',
+  'LOGICAL': 'logical_t', 
+  'INTEGER': 'integer_t',
+  'REAL': 'float', 
+  'DOUBLE PRECISION': 'double' }
+  
+templates = {}
+
+
+  
+def c_type( name, properties ):
+  m_type_map = global_type_map
+  m_type_map[ 'COMPLEX' ] = 'fcomplex_t'
+  m_type_map[ 'COMPLEX*16' ] = 'dcomplex_t'
+
+  result = m_type_map[ properties[ 'value_type' ] ];
+  if properties[ 'io' ] == [ 'input' ]:
+    result += ' const'
+  result += '*'
+  result += ' ' + name.lower()  # is this really needed?
+  
+  return result
+  
+  
+def cpp_type( name, properties ):
+  m_type_map = global_type_map
+  m_type_map[ 'COMPLEX' ] = 'traits::complex_f'
+  m_type_map[ 'COMPLEX*16' ] = 'traits::complex_d'
+  
+  result = m_type_map[ properties[ 'value_type' ] ]
+  
+  if properties[ 'type' ] == 'scalar':
+    if properties[ 'io' ] == [ 'input' ]:
+      result += ' const'
+    elif properties[ 'io' ] == [ 'external procedure' ]:
+      result += '*'
+    else:
+      result += '&'
+    
+  if properties[ 'type' ] == 'vector' or properties[ 'type' ] == 'matrix':
+    result += '*'
+    
+  result += ' ' + name.lower()
+    
+  return result
+  
+def call_c_type( name, properties ):
+  result = ''
+  if properties[ 'type' ] == 'vector' or properties[ 'type' ] == 'matrix':
+    if properties[ 'value_type' ][ 0:7] == 'COMPLEX':
+      result = 'traits::complex_ptr(' + name.lower() + ')'
+    else:
+      result = name.lower()
+  elif properties[ 'type' ] == 'scalar':
+    if properties[ 'value_type' ][ 0:7] == 'COMPLEX':
+      result = 'traits::complex_ptr(&' + name.lower() + ')'
+    else:
+      result = '&' + name.lower()
+  
+  return result
+  
+
+def call_level0_type( name, properties, arg_map ):
+  result = ''
+  if properties[ 'type' ] == 'matrix':
+    result = "traits::matrix_storage(" + name.lower() + ")"
+  elif properties[ 'type' ] == 'vector':
+    my_name = name.lower()
+    if 'workspace' in properties[ 'io' ]:
+      my_name = 'work.select(' + workspace_type( name, properties ) + '())'
+    result = "traits::vector_storage(" + my_name + ")"
+  elif properties.has_key( 'trait_type' ):
+    if properties[ 'trait_type' ] == 'lda':
+      result = "traits::leading_dimension(" + properties[ 'trait_of' ].lower() + ")"
+    if properties[ 'trait_type' ] == 'num_columns':
+      result = "traits::matrix_size2(" + properties[ 'trait_of' ].lower() + ")"
+    if properties[ 'trait_type' ] == 'num_rows':
+      result = "traits::matrix_size1(" + properties[ 'trait_of' ].lower() + ")"
+    if properties[ 'trait_type' ] == 'size':
+      my_name = properties[ 'trait_of' ].lower()
+      referring_to_properties = arg_map[ properties[ 'trait_of' ] ]
+      if 'workspace' in referring_to_properties[ 'io' ]:
+        my_name = 'work.select(' + workspace_type( properties[ 'trait_of' ].lower(), referring_to_properties ) + \
+                  '())'
+      result = "traits::vector_size(" + my_name + ")"
+    if properties[ 'trait_type' ] == 'uplo':
+      result = "traits::matrix_uplo_tag(" + properties[ 'trait_of' ].lower() + ")"
+  else:
+    result = name.lower()
+  return result
+
+
+def level1_type( name, properties ):
+  result = None
+  if not properties.has_key( 'trait_of' ) and 'workspace' not in properties[ 'io' ]:
+    if properties[ 'type' ] == 'matrix':
+      result = "Matrix" + name + "& " + name.lower()
+    elif properties[ 'type' ] == 'vector':
+      result = "Vector" + name + "& " + name.lower()
+    else:
+      result = cpp_type( name, properties )
+      if properties[ 'value_type' ] == 'REAL':
+        result = result.replace( "float", "real_type" )
+      if properties[ 'value_type' ] == 'DOUBLE PRECISION':
+        result = result.replace( "double", "real_type" )
+  return result
+
+
+def level2_type( name, properties ):
+  result = level1_type( name, properties )
+  if name == 'INFO' and 'output' in properties[ 'io' ]:
+    result = None
+
+  if result != None:
+    if properties[ 'value_type' ] == 'REAL' or properties[ 'value_type' ] == 'DOUBLE PRECISION':
+      result = result.replace( "real_type", "typename traits::$TYPEOF_FIRST_TYPENAME" + \
+        "_traits< $FIRST_TYPENAME >::value_type" )
+
+  return result
+
+
+def level1_typename( name, properties ):
+  result = None
+  if 'workspace' not in properties[ 'io' ]:
+    if properties[ 'type' ] == 'matrix':
+      result = "typename Matrix" + name
+    if properties[ 'type' ] == 'vector':
+      result = "typename Vector" + name
+  return result
+
+
+
+def nested_list_args( arg ):
+  print "finding nested list arguments of", arg
+  if type( arg ) == StringType:
+    if re.compile( '^[A-Z]+$' ).match( arg ) == None:
+      return [ None ]
+    else:
+      return [ arg.upper() ]
+  
+  # we are dealing with a list-type, e.g., 
+  # [ '*', [ 'A', 'B' ] ]
+  # [ 'A', 'B' ]
+  result = []
+  if re.compile( '^[A-Z]+$' ).match( arg[0] ) == None:
+    for a in arg[1]:
+      sub_result = nested_list_args( a )
+      if sub_result != [ None ]:
+        for r in sub_result:
+          if r not in result:
+            result.append( r )
+
+  else:
+    for a in arg:
+      result.append( a )
+
+  print "returning ",result
+  return result
+
+
+
+
+def expand_nested_list( arg, arg_map, use_arg_map = True ):
+
+  print "Expanding nested list: ", arg, len(arg)
+  if type( arg ) == StringType:
+    print "Type is string"
+    # .....
+    if re.compile( '^[A-Z]+$' ).match( arg ) == None:
+      return arg
+    else:
+      if use_arg_map:
+        if not arg_map.has_key( arg ):
+          return '?' + arg.upper()
+        else:
+          return arg_map[ arg ][ 'code' ][ 'call_level_0' ]
+      else:
+        return arg.lower()
+    
+  if arg[0] == '()':
+    result = '(' + expand_nested_list( arg[1], arg_map, use_arg_map ) + ')'
+    return result
+    
+  if arg[0] == 'max' or arg[0] == 'min':
+    print "arg1: ", arg[1]
+    result = 'std::' + arg[0] + '('
+    i = 0
+    for a in arg[1]:
+      result += expand_nested_list( a, arg_map, use_arg_map )
+      i += 1
+      if i != len(arg[1]):
+        result += ","
+    result += ')'
+    return result
+  
+  if arg[0] == '*' or arg[0] == '/' or arg[0] == '+' or arg[0] == '-':
+    print "arg1: ", arg[1]
+    arg_list = []
+    for a in arg[1]:
+      arg_list += [ expand_nested_list( a, arg_map, use_arg_map ) ]
+    result = arg[0].join( arg_list )
+    return result
+  
+  print "ERROR: Don't know what to do!!"
+  return 'ERROR'
+
+def level1_assert( name, properties, arg_map ):
+  result = None
+  
+  if properties.has_key( 'assert_char' ):
+    result = "assert( "
+    result_array = []
+    for char in properties[ 'assert_char' ]:
+      result_array += [ call_level0_type( name, properties, arg_map ) + ' == \'' + char + '\'' ]
+    result += " || ".join( result_array )
+    result += " );"
+    
+  if properties.has_key( 'assert_ge' ) and not properties.has_key( 'workspace_query_for' ):
+    result = "assert( " + call_level0_type( name, properties, arg_map ) + " >= " + expand_nested_list( properties[ 'assert_ge' ], arg_map ) + ' );'
+      
+  if 'workspace' in properties[ 'io' ]:
+    min_workspace_call = min_workspace_call_type( name, properties, arg_map )
+    if min_workspace_call == None:
+      min_workspace_call = '$CALL_MIN_SIZE'
+    result = 'assert( traits::vector_size(work.select(' + workspace_type( name, properties ) + '()) >= ' + \
+             'min_size_' + name.lower() + '( ' + min_workspace_call + ' )));'
+  
+  elif properties.has_key( 'assert_size' ):
+    result = "assert( traits::vector_size(" + call_level0_type( name, properties, arg_map ) + ") >= " + \
+      expand_nested_list( properties[ 'assert_size' ], arg_map ) + ' );'
+  
+  return result
+
+
+def call_level1_type( name, properties ):
+  result = None
+  if level1_type( name, properties ) != None:
+    result = name.lower()
+  return result
+
+
+def workspace_type( name, properties ):
+  result = None
+  if 'workspace' in properties[ 'io' ]:
+    if properties[ 'value_type' ] == 'INTEGER':
+      result = 'integer_t'
+    elif properties[ 'value_type' ] == 'LOGICAL':
+      result = 'bool'
+    elif properties[ 'value_type' ] == 'REAL' or properties[ 'value_type' ] == 'DOUBLE PRECISION':
+      result = 'real_type'
+    else: 
+      result = 'value_type'
+  return result
+
+
+
+
+def opt_workspace_pre_type( name, properties, arg_map ):
+  result = None
+  if 'workspace' in properties[ 'io' ]:
+    if properties.has_key( 'workspace_query_by' ):
+      result = workspace_type( name, properties ) + ' opt_size_' + name.lower() + ';'
+    else:
+      min_workspace_call = min_workspace_call_type( name, properties, arg_map )
+      if min_workspace_call == None:
+        min_workspace_call = '$CALL_MIN_SIZE'
+      result = 'traits::detail::array< ' + workspace_type( name, properties ) + ' >' + \
+               ' tmp_' + name.lower() + '( min_size_' + name.lower() + '( ' + min_workspace_call + ' ) );'
+  return result
+
+
+def opt_workspace_post_type( name, properties ):
+  result = None
+  if 'workspace' in properties[ 'io' ]:
+    if properties.has_key( 'workspace_query_by' ):
+      if properties['value_type'] == 'INTEGER':
+        result = 'traits::detail::array< ' + workspace_type( name, properties ) + ' >' + \
+               ' tmp_' + name.lower() + '( opt_size_' + name.lower() + ' );'
+      else:
+        result = 'traits::detail::array< ' + workspace_type( name, properties ) + ' >' + \
+               ' tmp_' + name.lower() + '( traits::detail::to_int( opt_size_' + name.lower() + ' ) );'
+  return result
+
+
+
+def opt_workspace_query_type( name, properties, arg_map ):
+  result = None
+  if properties.has_key( 'workspace_query_for' ):
+    result = '-1'
+  elif 'workspace' in properties[ 'io' ]:
+    if properties.has_key( 'workspace_query_by' ):
+      result = '&opt_size_' + name.lower();
+    else:
+      result = 'traits::vector_storage(tmp_' + name.lower() + ')'
+  else:
+    result = call_level0_type( name, properties, arg_map )
+  return result
+
+
+def min_workspace_size_type( name, properties, arg_map ):
+  result = None
+  if 'workspace' in properties[ 'io' ] and properties.has_key( 'assert_size' ):
+    result = expand_nested_list( properties[ 'assert_size' ], arg_map, False );
+  return result
+
+
+def min_workspace_arg_type( name, properties, arg_map ):
+  result = None
+  if 'workspace' in properties[ 'io' ] and properties.has_key( 'assert_size_args' ):
+    code_result = []
+    for arg in properties[ 'assert_size_args' ]:
+      if arg_map.has_key( arg ):
+        code_result += [ cpp_type( arg, arg_map[ arg ] ) ]
+      else:
+        code_result += [ '?' + arg.upper() ]
+    result = ", ".join( code_result )
+  return result
+
+
+def min_workspace_call_type( name, properties, arg_map ):
+  result = None
+  if 'workspace' in properties[ 'io' ] and properties.has_key( 'assert_size_args' ):
+    code_result = []
+    for arg in properties[ 'assert_size_args' ]:
+      if arg_map.has_key( arg ):
+        code_result += [ call_level0_type( arg, arg_map[ arg ], arg_map ) ]
+      else:
+        code_result += [ '?' + arg.upper() ]
+      
+    result = ", ".join( code_result )
+  return result
+
+
+def user_defined_type( name, properties, arg_map ):
+  result = None
+  if properties.has_key( 'user_defined' ):
+    result = properties[ 'user_defined' ]
+  return result
+
+
+
+#
+#
+#
+#
+def match_formulae( text_field ):
+  find_start = re.compile( '([A-Z]+)\s?(>=|is\sat\sleast)\s?(.*)the\scode\swill', re.M | re.S ).findall( text_field )
+  for element in find_start:
+    print element
+
+
+
+#
+# Split string using a list of delimiters
+# Delimiters may be substrings of length 1 or 2 (may be increased if necessary)
+#
+def split_delim( s, delim = [','] ):
+  result = []
+  parentheses = 0
+  cur_pos = 0
+  prev_pos = 0
+  for index in range( 0, len(s) ):
+    if s[ index ] == '(': 
+      parentheses += 1
+    elif s[ index ] == ')':
+      parentheses -= 1
+    for length in range( 1, 3 ):
+      if index >= (length-1) and parentheses == 0:
+        c = s[ index-(length-1): index+1 ]
+        if c in delim:
+          result += [ s[ prev_pos:(index-(length-1)) ] ]
+          prev_pos = index+1
+          
+  result += [ s[ prev_pos:len(s) ] ]
+  return result
+
+
+
+#
+# Look for implicit products, like 5N, and replace with 5*N
+#
+def replace_implicit_products( text_field ):
+  result = re.sub( '([0-9])+([A-Z]+)', '\\1*\\2', text_field )
+  return result
+
+
+
+
+def decompose_formula( text_field ):
+  text_field = text_field.strip()
+  print "Decompose: ", text_field
+  
+  if text_field[0] == '(' and text_field[-1] == ')':
+    result = text_field[ 1:-1 ]
+    return [ '()', decompose_formula( result ) ]
+  
+  if len( split_delim( text_field, [ ',' ] ) ) > 1:
+    print "ERROR! (in LAPACK?)"
+    return [ 'ERROR' ]
+  
+  #
+  # Detect leaf: if text_field equals a argument (like N), or a number
+  #  
+  if re.compile( '^([a-zA-Z]+|[0-9]+)$' ).match( text_field ):
+    print "decompose: at leaf: '" + text_field + "'"
+    return text_field.upper()
+  
+  
+  if len( split_delim( text_field, [ '**' ] ) ) > 1:
+    print 'decompose: inserting pow'
+    arguments = split_delim( text_field, [ '**' ] )
+    print arguments
+    result = []
+    for arg in arguments:
+      result.append( decompose_formula( arg ) )
+    return [ 'pow', result ]
+  
+  for operator in [ '*', '/', '+', '-' ]:
+    if len( split_delim( text_field, [ operator ] ) ) > 1:
+      print 'decompose: inserting ' + operator
+      arguments = split_delim( text_field, operator )
+      print arguments
+      result = []
+      for arg in arguments:
+        result.append( decompose_formula( arg ) )
+      return [ operator, result ]
+    
+  
+  if (text_field[ 0:4 ] == 'max(' or text_field[ 0:4 ] == 'MAX(') and \
+    text_field[ -1 ] == ')':
+    print "decompose: inserting max"
+    arguments = split_delim( text_field[ 4:-1 ] )
+    print arguments, len(arguments)
+    # keep max a binary function ... :-)
+    if len( arguments ) > 2:
+      return [ 'max', [ decompose_formula( arguments[0] ), decompose_formula( 'max(' + ",".join( arguments[1:] ) + ')' ) ] ]
+    else:  
+      result = []
+      for arg in arguments:
+        result.append( decompose_formula( arg ) )
+      #result = [ decompose_formula( arguments[0] ), decompose_formula( arguments[1] ) ]
+      return [ 'max', result ]
+  
+
+  if (text_field[ 0:4 ] == 'min(' or text_field[ 0:4 ] == 'MIN(') and \
+    text_field[ -1 ] == ')':
+    print "decompose: inserting min"
+    arguments = split_delim( text_field[ 4:-1 ] )
+    print arguments, len(arguments)
+    # keep max a binary function ... :-)
+    if len( arguments ) > 2:
+      return [ 'min', [ decompose_formula( arguments[0] ), decompose_formula( 'min(' + ",".join( arguments[1:] ) + ')' ) ] ]
+    else:  
+      result = []
+      for arg in arguments:
+        result.append( decompose_formula( arg ) )
+      #result = [ decompose_formula( arguments[0] ), decompose_formula( arguments[1] ) ]
+      return [ 'min', result ]
+  
+
+#
+#
+def match_assert_ge( argument_map, text_field ):
+  #print "Match assert GE..."
+  match_it = re.compile( ' +[A-Z]+[ ]{0,3}(>=|must be at least)[ ]{0,3}([0-9]|(min|max|MIN|MAX|[\(\)\,0-9A-Z\+\*\-])+)' ).findall( text_field )
+  if len( match_it ) == 1:
+    print "Match assert GE:", match_it
+    #print match_it
+    #if len( match_it[ 0 ][ 2 ] ) > 0:
+    return decompose_formula( match_it[ 0 ][ 1 ] )
+  else:
+    print "nr of matches: ", len( match_it )
+    return None
+  
+
+
+
+
+# try different keys, return the one that exists, if any
+
+def my_has_key( key_name, template_map ):
+  # try, e.g., gelsd.all.
+  m_all_key = key_name.replace( ".complex", ".all" ).replace( ".real", ".all" )
+  if template_map.has_key( key_name ):
+    print "using key ", key_name
+    return key_name
+  if template_map.has_key( m_all_key ):
+    print "using key ", m_all_key
+    return m_all_key
+  print "tried keys ", key_name, "and", m_all_key,", no results"
+  return None
+
+
+
+#
+# Default user-defined arg is of type scalar INTEGER
+#
+def add_user_defined_args( arg, argument_map, template_map, base_name ):
+  print "Trying to add user-defined argument definitions for", arg
+
+  argument_map[ arg ] = {}
+
+  base_key = base_name.lower() + '.' + arg
+  print "base_key",base_key
+
+  if my_has_key( base_key + '.value_type', template_map ) != None:
+    argument_map[ arg ][ 'value_type' ] = template_map[ my_has_key( base_key + '.value_type', template_map ) ].strip()
+  else:
+    argument_map[ arg ][ 'value_type' ] = 'INTEGER'
+
+  if my_has_key( base_key + '.type', template_map ) != None:
+    argument_map[ arg ][ 'type' ] = template_map[ my_has_key( base_key + '.type', template_map ) ].strip()
+  else:
+    argument_map[ arg ][ 'type' ] = 'scalar'
+
+  if my_has_key( base_key + '.init', template_map ) != None:
+    argument_map[ arg ][ 'user_defined' ] = template_map[ my_has_key( base_key + '.init', template_map ) ].strip()
+  else:
+    argument_map[ arg ][ 'user_defined' ] = 'UNDEFINED'
+
+  argument_map[ arg ][ 'io' ] = [ 'input' ]
+
+  return
+
+
+#
+# Desired order of routines in C++ code: float, double, single complex, double complex
+#
+def routine_cmp( a, b ):
+  letter_a = a[0]
+  letter_b = b[0]
+  value_map = { 'S': 0, 'D': 1, 'C': 2, 'Z': 3 }
+  result = 0
+  if value_map[ a[0] ] < value_map[ b[ 0] ]:
+    result = -1
+  if value_map[ a[0] ] > value_map[ b[ 0] ]:
+    result = 1
+  return result
+    
+
+#
+# Group subroutines on their name, with the first character removed. This will 
+# group them in the same .hpp file as well. Sort these subroutines based on 
+# routine_cmp above.
+#
+def group_by_value_type( global_info_map ):
+  group_map = {}
+  for i in global_info_map.keys():
+    short_name = i[ 1: ]
+    if not group_map.has_key( short_name ):
+      group_map[ short_name ] = []
+    group_map[ short_name ] += [ i ]
+  for value in group_map.values():
+    value.sort( routine_cmp )
+  return group_map
+  
+
+
+  
+def indent_lines( source_text, indent_size = 8 ):
+  indent_string = '\n'
+  for i in range(indent_size):
+    indent_string += ' '
+  return indent_string.join( source_text.splitlines() )
+  
+
+  
+#
+# Write the (many) driver routine file(s).
+#
+def write_functions( info_map, group, template_map, base_dir ):
+  #
+  # group.keys() is a vector of different grouped function names
+  # like gees, dgesv, etc.
+  #
+  for group_name, subroutines in group.iteritems():
+    
+    filename = group_name.lower() + '.hpp'
+    includes = [ '#include <cassert>',
+      '#include <boost/numeric/bindings/traits/traits.hpp>',
+      '#include <boost/numeric/bindings/traits/type_traits.hpp>', 
+      '#include <boost/numeric/bindings/lapack/lapack.h>' ]
+      
+    if template_map.has_key( group_name.lower() + '.includes' ):
+      includes += template_map[ group_name.lower() + '.includes' ].splitlines()
+
+    #
+    # LEVEL 0 HANDLING
+    #  
+    overloads = ''
+    for subroutine in subroutines:
+      sub_template = template_map[ 'lapack_overloads' ]
+      # add the argument list here
+      arg_list = []
+      lapack_arg_list = []
+      for arg in info_map[ subroutine ][ 'arguments' ]:
+        arg_list += [ info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'level_0' ] ]
+        lapack_arg_list += [ info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'call_c_header' ] ]
+      sub_template = sub_template.replace( "$LEVEL0", ", ".join( arg_list ) )
+      sub_template = sub_template.replace( "$CALL_C_HEADER", ", ".join( lapack_arg_list ) )
+      sub_template = sub_template.replace( "$SUBROUTINE", subroutine )
+      sub_template = sub_template.replace( '$groupname', group_name.lower() )
+      
+      overloads += bindings.proper_indent( sub_template )
+  
+    cases = {}
+    # first, see what kind of functions we have
+    # needed for argument check etc.
+    for subroutine in subroutines:
+      if subroutine[0] == 'S' or subroutine[0] == 'D':
+        if not cases.has_key( 'real' ):
+          cases[ 'real' ] = {}
+          cases[ 'real' ][ 'subroutines' ] = []
+        cases[ 'real' ][ 'subroutines' ] += [ subroutine ]
+      if subroutine[0] == 'C' or subroutine[0] == 'Z':
+        if not cases.has_key( 'complex' ):
+          cases[ 'complex' ] = {}
+          cases[ 'complex' ][ 'subroutines' ] = []
+        cases[ 'complex' ][ 'subroutines' ] += [ subroutine ]
+    
+    #
+    # LEVEL 1 and 2 HANDLING
+    #
+    level1_map = {}
+    level2_map = {}
+    for value_type, case_map in cases.iteritems():
+      
+      level1_template = ''
+      level2_template = ''
+      if info_map[ subroutine ][ 'grouped_arguments' ][ 'by_io' ].has_key( 'workspace' ):
+        level1_template = template_map[ 'level1_workspace' ]
+        level2_template = template_map[ 'level2_workspace' ]
+      else:
+        level1_template = template_map[ 'level1_noworkspace' ]
+        level2_template = template_map[ 'level2_noworkspace' ]
+      
+      level1_template = level1_template.replace( '$groupname', group_name.lower() )
+      level1_template = level1_template.replace( "$SPECIALIZATION", value_type )
+    
+      # take this subroutine for arguments etc.
+      subroutine = case_map[ 'subroutines' ][ 0 ]
+      print "taking",subroutine
+      
+      level0_arg_list = []
+      level1_arg_list = []
+      level2_arg_list = []
+      level1_type_arg_list = []
+      level1_assert_list = []
+      call_level1_arg_list = []
+      workspace_query_arg_list = []
+      user_defined_arg_list = []
+      user_defined_opt_arg_list = []
+      for arg in info_map[ subroutine ][ 'arguments' ]:
+        level0_arg_list += [ info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'call_level_0' ] ]
+        if info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'level_1' ] != None:
+          level1_arg_list += [ info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'level_1' ] ]
+        if info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'level_2' ] != None:
+          level2_arg_list += [ info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'level_2' ] ]
+        if info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'level_1_type' ] != None and \
+          info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'level_1_type' ] not in level1_type_arg_list:
+          level1_type_arg_list += [ info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'level_1_type' ] ]
+        if info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'level_1_assert' ] != None:
+          level1_assert_list += [ info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'level_1_assert' ] ]
+        if info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'call_level_1' ] != None:
+          call_level1_arg_list += [ info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'call_level_1' ] ]
+        if info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'opt_workspace_query' ] != None:
+          workspace_query_arg_list += [ info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'opt_workspace_query' ] ]
+          
+      if info_map[ subroutine ][ 'user_defined_variables' ] != None:
+        for arg in info_map[ subroutine ][ 'user_defined_variables' ]:
+          print arg
+          if info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'user_defined_init' ] != None:
+            user_defined_arg_list += [ info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'user_defined_init' ] ]
+      
+      if info_map[ subroutine ][ 'user_defined_opt_variables' ] != None:
+        for arg in info_map[ subroutine ][ 'user_defined_opt_variables' ]:
+          print arg
+          if info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'user_defined_init' ] != None:
+            user_defined_opt_arg_list += [ info_map[ subroutine ][ 'argument_map' ][ arg ][ 'code' ][ 'user_defined_init' ] ]
+      
+      # Level 1 replacements
+      level1_template = level1_template.replace( "$CALL_LEVEL0", ", ".join( level0_arg_list ) )
+      level1_template = level1_template.replace( "$CALL_LEVEL1", ", ".join( call_level1_arg_list ) )
+      level1_template = level1_template.replace( "$LEVEL1", ", ".join( level1_arg_list ) )
+      level1_template = level1_template.replace( "$TYPES", ", ".join( level1_type_arg_list ) )
+      level1_template = level1_template.replace( "$ASSERTS", "\n        ".join( level1_assert_list ) )
+      
+      if len( user_defined_arg_list ) > 0:
+        level1_template = level1_template.replace( "$INIT_USER_DEFINED_VARIABLES", indent_lines( "\n".join(user_defined_arg_list), 8 ) )
+      else:
+        level1_template = level1_template.replace( "\n        $INIT_USER_DEFINED_VARIABLES", "" )
+
+      # Level 2 replacements
+      # some special stuff is done here, such as replacing real_type with a 
+      # type-traits deduction, etc..
+      level2_template = level2_template.replace( "$LEVEL2", ", ".join( level2_arg_list ) )
+      first_typename = level1_type_arg_list[0].split(" ")[-1]
+      first_typename_datatype = first_typename[0:6].lower() # 'matrix' or 'vector'
+      level2_template = level2_template.replace( "$FIRST_TYPENAME", first_typename )
+      level2_template = level2_template.replace( "$TYPEOF_FIRST_TYPENAME", first_typename_datatype )
+      level2_template = level2_template.replace( "$CALL_LEVEL1", ", ".join( call_level1_arg_list ) )
+      level2_template = level2_template.replace( "$TYPES", ", ".join( level1_type_arg_list ) )
+
+      #
+      # Workspace stuff
+      #
+      if info_map[ subroutine ][ 'grouped_arguments' ][ 'by_io' ].has_key( 'workspace' ):
+        # Add an include for the workspace stuff
+        includes += [ '#include <boost/numeric/bindings/lapack/workspace.hpp>' ]
+        includes += [ '#include <boost/numeric/bindings/traits/detail/array.hpp>' ]
+
+        # Continue
+        workspace_size = len( info_map[ subroutine ][ 'grouped_arguments' ][ 'by_io' ][ 'workspace' ] )
+        workspace_args = info_map[ subroutine ][ 'grouped_arguments' ][ 'by_io' ][ 'workspace' ]
+        level1_template = level1_template.replace( "$WORKSPACE_SIZE", str(workspace_size) )
+        level1_template = level1_template.replace( "$WORKSPACE_TYPENAMES", "typename " + ", typename ".join( workspace_args ) )
+        level1_template = level1_template.replace( "$WORKSPACE_TYPES", ", ".join( workspace_args ) )
+
+        # $TMP_WORKARRAYS is something like "tmp_work, tmp_rwork"
+        tmp_workspace_args = []
+        for name in info_map[ subroutine ][ 'grouped_arguments' ][ 'by_io' ][ 'workspace' ]:
+          tmp_workspace_args += [ 'tmp_' + name.lower() ]
+        level1_template = level1_template.replace( "$TMP_WORKARRAYS", ", ".join( tmp_workspace_args ) )
+        
+        # $SETUP_WORKARRAYS looks like 
+        #    traits::detail::array< value_type > $TMP_NAME .... 
+        setup_min_workarrays = ''
+        setup_opt_workarrays_pre = []
+        setup_opt_workarrays_post = []
+        for name in info_map[ subroutine ][ 'grouped_arguments' ][ 'by_io' ][ 'workspace' ]:
+          # minimal case
+          sub_min_template = template_map[ 'setup_min_workspace' ]
+          sub_min_template = sub_min_template.replace( '$NAME', name.lower() )
+          sub_min_template = sub_min_template.replace( '$WORKSPACE_TYPE', info_map[ subroutine ][ 'argument_map' ][ name ][ 'code' ][ 'workspace_type' ] )
+          if info_map[ subroutine ][ 'argument_map' ][ name ][ 'code' ][ 'min_workspace_call' ] != None:
+            sub_min_template = sub_min_template.replace( "$CALL_MIN_SIZE", info_map[ subroutine ][ 'argument_map' ][ name ][ 'code' ][ 'min_workspace_call' ] )
+          
+          setup_min_workarrays += sub_min_template
+
+          # optimal case
+          if info_map[ subroutine ][ 'argument_map' ][ name ][ 'code' ][ 'opt_workspace_pre' ] != None:
+            setup_opt_workarrays_pre += [ info_map[ subroutine ][ 'argument_map' ][ name ][ 'code' ][ 'opt_workspace_pre' ] ]
+          if info_map[ subroutine ][ 'argument_map' ][ name ][ 'code' ][ 'opt_workspace_post' ] != None:
+            setup_opt_workarrays_post += [ info_map[ subroutine ][ 'argument_map' ][ name ][ 'code' ][ 'opt_workspace_post' ] ]
+          
+          
+        # if the length of setup_opt_workarrays_post equals 0, it's equal to the minimal_case
+        opt_workspace_template = ''
+        if len( setup_opt_workarrays_post ) == 0:
+          print "EQUAL to MINIMAL CASE!"
+          opt_workspace_template = template_map[ 'level1_opt_workspace_is_min' ]
+        else:
+          includes += [ '#include <boost/numeric/bindings/traits/detail/utils.hpp>' ]
+          opt_workspace_template = template_map[ 'level1_opt_workspace' ]
+          
+        opt_workspace_template = opt_workspace_template.replace( "$WORKSPACE_QUERY", ", ".join( workspace_query_arg_list ) )
+        opt_workspace_template = opt_workspace_template.replace( "$SETUP_OPT_WORKARRAYS_POST", "\n        ".join( setup_opt_workarrays_post ) )
+        opt_workspace_template = opt_workspace_template.replace( "$SETUP_OPT_WORKARRAYS_PRE", "\n        ".join( setup_opt_workarrays_pre ) )
+        opt_workspace_template = opt_workspace_template.replace( "$CALL_LEVEL1", ", ".join( call_level1_arg_list ) )
+        opt_workspace_template = opt_workspace_template.replace( "$TMP_WORKARRAYS", ", ".join( tmp_workspace_args ) )
+        
+      
+        if len( user_defined_opt_arg_list ) > 0:
+          opt_workspace_template = opt_workspace_template.replace( "$INIT_USER_DEFINED_OPT_VARIABLES", indent_lines( "\n".join(user_defined_arg_list), 8 ) )
+        else:
+          print "removing $INIT_USER_DEFINED_OPT_VARIABLES"
+          opt_workspace_template = opt_workspace_template.replace( "        $INIT_USER_DEFINED_OPT_VARIABLES\n", "" )
+        
+        
+        level1_template = level1_template.replace( "$OPT_WORKSPACE_FUNC", opt_workspace_template.rstrip() )
+        level1_template = level1_template.replace( "$SETUP_MIN_WORKARRAYS_POST", setup_min_workarrays.rstrip() )
+        
+        
+        #
+        # INSERT THE MINIMAL WORKSPACE FUNCTIONS
+        #
+        min_size_funcs = ''
+        for name in info_map[ subroutine ][ 'grouped_arguments' ][ 'by_io' ][ 'workspace' ]:
+          sub_template = template_map[ 'min_size_func' ]
+          sub_template = sub_template.replace( "$NAME", name.lower() )
+          
+          # first: user-defined stuff (overrules any auto-detected stuff)
+          my_key = group_name.lower() + '.' + value_type + '.min_size_' + name.lower()
+          my_key_all = group_name.lower() + '.all.min_size_' + name.lower()
+          print my_key
+          if template_map.has_key( my_key ):
+            sub_template = sub_template.replace( "$MIN_SIZE", indent_lines( template_map[ my_key ].rstrip(), 8 ) )
+            
+          # if that fails, try the more generic key "all"
+          elif template_map.has_key( my_key_all ):
+            sub_template = sub_template.replace( "$MIN_SIZE", indent_lines( template_map[ my_key_all ].rstrip(), 8 ) )
+          
+          elif info_map[ subroutine ][ 'argument_map' ][ name ][ 'code' ][ 'min_workspace' ] != None:
+            resulting_code = 'return ' + info_map[ subroutine ][ 'argument_map' ][ name ][ 'code' ][ 'min_workspace' ] + ';'
+            sub_template = sub_template.replace( "$MIN_SIZE", resulting_code.rstrip() )
+            
+          # Do about the same for the argument stuff.  
+          if info_map[ subroutine ][ 'argument_map' ][ name ][ 'code' ][ 'min_workspace_args' ] != None:
+            sub_template = sub_template.replace( "$ARGUMENTS", info_map[ subroutine ][ 'argument_map' ][ name ][ 'code' ][ 'min_workspace_args' ] )
+
+            #sub_template += 'FOUND'
+          min_size_funcs += sub_template
+
+        min_size_funcs = min_size_funcs.rstrip()
+        level1_template = level1_template.replace( "$MIN_SIZE_FUNCS", min_size_funcs )
+
+      level1_map[ value_type ] = bindings.proper_indent( level1_template )
+      level2_map[ value_type ] = bindings.proper_indent( level2_template )
+
+    #
+    # LEVEL 1 and 2 FINALIZATION
+    #
+    for mapping in [ level1_map, level2_map ]:
+      if len(mapping) > 1:
+        # compare real and complex cases
+        all_keys = mapping.keys()
+        if mapping[ all_keys[0] ] == mapping[ all_keys[1] ]:
+          print "literally everything is the same!!, falling back to 1 case"
+          del mapping[ all_keys[ 1 ] ]
+
+    level1 = ''
+    if len( level1_map ) > 1:
+      level1 = template_map[ 'level1_pre_header' ]
+      includes += [ '#include <boost/utility/enable_if.hpp>' ]
+      includes += [ '#include <boost/numeric/bindings/traits/is_real.hpp>' ]
+      includes += [ '#include <boost/numeric/bindings/traits/is_complex.hpp>' ]
+
+    for value_type in level1_map.keys():
+      if len( level1_map ) == 1:
+        header = template_map[ 'level1_header1' ]
+      else:
+        header = template_map[ 'level1_header2' ]
+
+      level1 += header.replace( "$SPECIALIZATION", value_type )
+      level1 += level1_map[ value_type ]
+
+    level2 = ''
+    for value_type in level2_map.keys():
+      level2 += level2_map[ value_type ]
+
+    #
+    # handle addition of includes
+    #
+    includes_code = ''
+    unique_includes = []
+    for include in includes:
+      if include not in unique_includes:
+        unique_includes += [ include ]
+    sorted_includes = sorted( unique_includes, lambda x, y: cmp( x.lower(), y.lower() ) )
+    if len( sorted_includes ) > 0:
+      includes_code = "\n".join( sorted_includes )
+
+    result = template_map[ 'lapack.hpp' ]
+    result = result.replace( '$INCLUDES', includes_code )
+    result = result.replace( '$OVERLOADS', overloads )
+    result = result.replace( '$LEVEL1', level1 )
+    result = result.replace( '$LEVEL2', level2 )
+    result = result.replace( '$GROUPNAME', group_name )
+    result = result.replace( '$groupname', group_name.lower() )
+
+    # replace the global variables as last (this is convenient)
+    #result = result.replace( '$INDENT', '    ' )
+    #result = result.replace( '$groupname', group_name.lower() )
+    #result = result.replace( '$DESCRIPTION', info_map[ group[g][0] ][ 'description' ] )
+
+    open( os.path.join( base_dir, filename ), 'wb' ).write( result )
+
+#
+# Write the (many) driver routine test cases to cpp files.
+#
+def write_test_case( info_map, group, template_map, base_dir, level_name ):
+
+  for group_name, subroutines in group.iteritems():
+
+    filename = group_name.lower() + '.cpp'
+    result = template_map[ 'test_case.cpp' ]
+    result = result.replace( '$groupname', group_name.lower() )
+    result = result.replace( '$levelname', level_name.lower() )
+
+    open( os.path.join( base_dir, filename ), 'wb' ).write( result )
+
+def write_cmakefile( level_properties, template_map, base_dir ):
+  
+  entries = '' 
+  for problem_type, problem_properties in level_properties.iteritems():
+    if problem_properties.has_key( 'routines_by_value_type' ):
+      group = problem_properties[ 'routines_by_value_type' ]
+      for group_name, subroutines in group.iteritems():
+        sub_result = template_map[ 'CMakeLists.entry' ]
+        sub_result = sub_result.replace( '$groupname', group_name.lower() )
+        entries += sub_result
+
+  filename = 'CMakeLists.txt'
+  result = template_map[ 'CMakeLists.txt' ]
+  result = result.replace( '$ENTRIES', entries )
+  open( os.path.join( base_dir, filename ), 'wb' ).write( result )
+
+
+def read_templates( template_file ):
+  file_contents = open( template_file ).read()
+  split_regex = re.compile( '^\$TEMPLATE\[([^\]]+)\]\s', re.M | re.S )
+  split_templates = split_regex.split( file_contents )[ 1:-1 ]
+  result = {}
+  for index in range(len(split_templates)/2):
+    print "Adding template", split_templates[ index*2 ]
+    result[ split_templates[ index*2 ] ] = split_templates[ index*2 + 1 ]
+  return result
+
+lapack_src_path = './lapack-3.1.1/SRC'
+template_src_path = './templates'
+bindings_target_path = '../../../../boost/numeric/bindings/lapack/'
+test_target_path = '../test/lapack/'
+
+templates = {}
+templates[ 'PARSERMODE' ] = 'LAPACK'
+for root, dirs, files in os.walk( template_src_path ):
+  right_file = re.compile( '^.+\.(cpp|h|hpp|txt)$' )
+  for template_file in files:
+    if right_file.match( template_file ) != None:
+      path_to_template_file = os.path.join( root, template_file )
+      print "Reading template file", path_to_template_file
+      templates.update( read_templates( path_to_template_file ) )
+
+function_info_map = {}
+for lapack_file in os.listdir( lapack_src_path ):
+  right_file = re.compile( '^[cdsz].+\.f$' )
+  if right_file.match( lapack_file ) != None:
+    print "Parsing", lapack_file, "..."
+    key, value = netlib.parse_file( os.path.join( lapack_src_path, lapack_file ), templates )
+    if key != None and value != None:
+      print "Adding LAPACK subroutine", key
+      function_info_map[ key ] = value
+
+print "Grouping subroutines..."
+
+value_type_groups = {}
+value_type_groups = group_by_value_type( function_info_map )
+
+routines = {}
+routines[ 'driver' ] = {}
+routines[ 'driver' ][ 'linear_equations' ] = {}
+routines[ 'driver' ][ 'linear_equations' ][ 'endings' ] = [ 'SV', 'SVX' ]
+
+routines[ 'driver' ][ 'least_squares' ] = {}
+routines[ 'driver' ][ 'least_squares' ][ 'endings' ] = [ 'LS', 'LSY', 'LSS', 'LSD' ]
+
+routines[ 'driver' ][ 'general_least_squares' ] = {}
+routines[ 'driver' ][ 'general_least_squares' ][ 'endings' ] = [ 'LSE', 'GLM' ]
+
+# based on LAPACK Users' Guide, table 2.5
+routines[ 'driver' ][ 'eigen' ] = {}
+routines[ 'driver' ][ 'eigen' ][ 'endings' ] = [ 'YEV', 'EEV', 'YEVX', 'EEVX', 'YEVD', 'EEVD', 'YEVR', 'EEVR', 'EES', 'PEV', 'PEVD', 'PEVX', 'BEV', 'BEVD', 'BEVX', 'EESX', 'ESVD', 'ESDD', 'TEV', 'TEVD', 'TEVX', 'TEVR' ]
+
+# based on LAPACK Users' Guide, table 2.6
+routines[ 'driver' ][ 'general_eigen' ] = {}
+routines[ 'driver' ][ 'general_eigen' ][ 'endings' ] = [ 'GV', 'GVD', 'GVX', 'GES', 'GESX', 'GEV', 'GEVX', 'GSVD' ]
+
+
+routines[ 'computational' ] = {}
+
+# based on LAPACK Users' Guide, table 2.7
+routines[ 'computational' ][ 'linear_equations' ] = {}
+routines[ 'computational' ][ 'linear_equations' ][ 'endings' ] = [ 'TRF', 'TRS', 'CON', 'RFS', 'TRI', 'EQU' ]
+
+# based on LAPACK Users' Guide, table 2.9 
+routines[ 'computational' ][ 'least_squares' ] = {}
+routines[ 'computational' ][ 'least_squares' ][ 'endings' ] = [ 'QP3', 'EQRF', 'GQR', 'MQR', 'LQF', 'GLQ', 'MLQ', 'QLF', 'GQL', 'MQL', 'ERQF', 'GRQ', 'MRQ', 'RZF', 'RZ' ]
+
+routines[ 'computational' ][ 'general_least_squares' ] = {}
+routines[ 'computational' ][ 'general_least_squares' ][ 'endings' ] = [ 'GQRF', 'GRQF' ]
+
+# based on LAPACK Users' Guide, table 2.10
+routines[ 'computational' ][ 'symmetric_eigen' ] = {}
+routines[ 'computational' ][ 'symmetric_eigen' ][ 'endings' ] = [ 'TRD', 'MTR', 'GTR', 'TEQR', 'ERF', 'EDC', 'EGR', 'EBZ', 'TEIN' ]
+
+# based on LAPACK Users' Guide, table 2.11
+routines[ 'computational' ][ 'nonsymmetric_eigen' ] = {}
+routines[ 'computational' ][ 'nonsymmetric_eigen' ][ 'endings' ] = [ 'EHRD', 'EBAL', 'EBAK', 'GHR', 'MHR', 'SEQR', 'SEIN', 'REVC', 'REXC', 'RSYL', 'RSNA', 'RSEN' ]
+
+# based on LAPACK Users' Guide, table 2.12
+routines[ 'computational' ][ 'svd' ] = {}
+routines[ 'computational' ][ 'svd' ][ 'endings' ] = [ 'BRD', 'GBR', 'MBR', 'SQR', 'SDC' ]
+
+# based on LAPACK Users' Guide, table 2.14
+routines[ 'computational' ][ 'general_eigen' ] = {}
+routines[ 'computational' ][ 'general_eigen' ][ 'endings' ] = [ 'GST', 'STF' ]
+
+# based on LAPACK Users' Guide, table 2.15
+routines[ 'computational' ][ 'general_nonsymmetric_eigen' ] = {}
+routines[ 'computational' ][ 'general_nonsymmetric_eigen' ][ 'endings' ] = [ 'GHRD', 'GBAL', 'GBAK', 'EQZ', 'GEVC', 'GEXC', 'GSYL', 'GSNA', 'GSEN' ]
+
+# based on LAPACK Users' Guide, table 2.16
+routines[ 'computational' ][ 'general_nonsymmetric_svd' ] = {}
+routines[ 'computational' ][ 'general_nonsymmetric_svd' ][ 'endings' ] = [ 'SVP', 'SJA' ]
+
+for name in value_type_groups.keys():
+  found = False
+  for level, level_properties in routines.iteritems():
+    for problem_type, problem_properties in level_properties.iteritems():
+      if name[ -2: ] in problem_properties[ 'endings' ] or \
+         name[ -3: ] in problem_properties[ 'endings' ] or \
+         name[ -4: ] in problem_properties[ 'endings' ]:
+        print name, "is in {"+level+", "+  problem_type + "}"
+        if not problem_properties.has_key( 'routines_by_value_type' ):
+          problem_properties[ 'routines_by_value_type' ] = {}
+        problem_properties[ 'routines_by_value_type' ][ name ] = value_type_groups[ name ]
+        found = True
+  if found == False:
+    print name, "is in {??}"
+
+print routines 
+
+
+bindings.write_names_header( function_info_map, value_type_groups, templates, bindings_target_path + 'lapack_names.h' )
+bindings.write_header( function_info_map, value_type_groups, templates, bindings_target_path + 'lapack.h' )
+
+for level, level_properties in routines.iteritems():
+  target_path = bindings_target_path + level
+  if not os.path.exists( target_path ):
+    os.mkdir( target_path )
+  if not os.path.exists( test_target_path + level ):
+    os.mkdir( test_target_path + level )
+
+  for problem_type, problem_properties in level_properties.iteritems():
+    if problem_properties.has_key( 'routines_by_value_type' ):
+      write_functions( function_info_map, problem_properties[ 'routines_by_value_type' ], templates, target_path )
+
+      write_test_case( function_info_map, problem_properties[ 'routines_by_value_type' ], templates, test_target_path + level, level )
+
+  write_cmakefile( level_properties, templates, test_target_path + level )
+
+

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/netlib.py
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/netlib.py	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,1064 @@
+#!/usr/bin/python
+#
+#  Copyright (c) 2008 Thomas Klimpel and Rutger ter Borg
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+#
+
+import re, os.path, copy
+from types import StringType
+
+# for debugging purposes
+import pprint
+
+
+global_type_map = { 
+  'CHARACTER': 'char',
+  'LOGICAL': 'logical_t', 
+  'INTEGER': 'integer_t',
+  'REAL': 'float', 
+  'DOUBLE PRECISION': 'double' }
+  
+templates = {}
+
+
+  
+def c_type( name, properties ):
+  m_type_map = global_type_map
+  m_type_map[ 'COMPLEX' ] = 'fcomplex_t'
+  m_type_map[ 'COMPLEX*16' ] = 'dcomplex_t'
+  m_type_map[ 'DOUBLE COMPLEX' ] = 'dcomplex_t'
+
+  result = m_type_map[ properties[ 'value_type' ] ];
+  if properties[ 'io' ] == [ 'input' ]:
+    result += ' const'
+  result += '*'
+  result += ' ' + name.lower()  # is this really needed?
+  
+  return result
+  
+  
+def cpp_type( name, properties ):
+  m_type_map = global_type_map
+  m_type_map[ 'COMPLEX' ] = 'traits::complex_f'
+  m_type_map[ 'COMPLEX*16' ] = 'traits::complex_d'
+  
+  result = m_type_map[ properties[ 'value_type' ] ]
+  
+  if properties[ 'type' ] == 'scalar':
+    if properties[ 'io' ] == [ 'input' ]:
+      result += ' const'
+    elif properties[ 'io' ] == [ 'external procedure' ]:
+      result += '*'
+    else:
+      result += '&'
+    
+  if properties[ 'type' ] == 'vector' or properties[ 'type' ] == 'matrix':
+    result += '*'
+    
+  result += ' ' + name.lower()
+    
+  return result
+  
+def call_c_type( name, properties ):
+  result = ''
+  if properties[ 'type' ] == 'vector' or properties[ 'type' ] == 'matrix':
+    if properties[ 'value_type' ][ 0:7] == 'COMPLEX':
+      result = 'traits::complex_ptr(' + name.lower() + ')'
+    else:
+      result = name.lower()
+  elif properties[ 'type' ] == 'scalar':
+    if properties[ 'value_type' ][ 0:7] == 'COMPLEX':
+      result = 'traits::complex_ptr(&' + name.lower() + ')'
+    else:
+      result = '&' + name.lower()
+  
+  return result
+  
+
+def call_level0_type( name, properties, arg_map ):
+  result = ''
+  if properties[ 'type' ] == 'matrix':
+    result = "traits::matrix_storage(" + name.lower() + ")"
+  elif properties[ 'type' ] == 'vector':
+    my_name = name.lower()
+    if 'workspace' in properties[ 'io' ]:
+      my_name = 'work.select(' + workspace_type( name, properties ) + '())'
+    result = "traits::vector_storage(" + my_name + ")"
+  elif properties.has_key( 'trait_type' ):
+    if properties[ 'trait_type' ] == 'lda':
+      result = "traits::leading_dimension(" + properties[ 'trait_of' ].lower() + ")"
+    if properties[ 'trait_type' ] == 'num_columns':
+      result = "traits::matrix_size2(" + properties[ 'trait_of' ].lower() + ")"
+    if properties[ 'trait_type' ] == 'num_rows':
+      result = "traits::matrix_size1(" + properties[ 'trait_of' ].lower() + ")"
+    if properties[ 'trait_type' ] == 'size':
+      my_name = properties[ 'trait_of' ].lower()
+      referring_to_properties = arg_map[ properties[ 'trait_of' ] ]
+      if 'workspace' in referring_to_properties[ 'io' ]:
+        my_name = 'work.select(' + workspace_type( properties[ 'trait_of' ].lower(), referring_to_properties ) + \
+                  '())'
+      result = "traits::vector_size(" + my_name + ")"
+    if properties[ 'trait_type' ] == 'uplo':
+      result = "traits::matrix_uplo_tag(" + properties[ 'trait_of' ].lower() + ")"
+  else:
+    result = name.lower()
+  return result
+
+
+def level1_type( name, properties ):
+  result = None
+  if not properties.has_key( 'trait_of' ) and 'workspace' not in properties[ 'io' ]:
+    if properties[ 'type' ] == 'matrix':
+      result = "Matrix" + name + "& " + name.lower()
+    elif properties[ 'type' ] == 'vector':
+      result = "Vector" + name + "& " + name.lower()
+    else:
+      result = cpp_type( name, properties )
+      if properties[ 'value_type' ] == 'REAL':
+        result = result.replace( "float", "real_type" )
+      if properties[ 'value_type' ] == 'DOUBLE PRECISION':
+        result = result.replace( "double", "real_type" )
+  return result
+
+
+def level2_type( name, properties ):
+  result = level1_type( name, properties )
+  if name == 'INFO' and 'output' in properties[ 'io' ]:
+    result = None
+
+  if result != None:
+    if properties[ 'value_type' ] == 'REAL' or properties[ 'value_type' ] == 'DOUBLE PRECISION':
+      result = result.replace( "real_type", "typename traits::$TYPEOF_FIRST_TYPENAME" + \
+        "_traits< $FIRST_TYPENAME >::value_type" )
+
+  return result
+
+
+def level1_typename( name, properties ):
+  result = None
+  if 'workspace' not in properties[ 'io' ]:
+    if properties[ 'type' ] == 'matrix':
+      result = "typename Matrix" + name
+    if properties[ 'type' ] == 'vector':
+      result = "typename Vector" + name
+  return result
+
+
+
+def nested_list_args( arg ):
+  print "finding nested list arguments of", arg
+  if type( arg ) == StringType:
+    if re.compile( '^[A-Z]+$' ).match( arg ) == None:
+      return [ None ]
+    else:
+      return [ arg.upper() ]
+  
+  # we are dealing with a list-type, e.g., 
+  # [ '*', [ 'A', 'B' ] ]
+  # [ 'A', 'B' ]
+  result = []
+  if re.compile( '^[A-Z]+$' ).match( arg[0] ) == None:
+    for a in arg[1]:
+      sub_result = nested_list_args( a )
+      if sub_result != [ None ]:
+        for r in sub_result:
+          if r not in result:
+            result.append( r )
+
+  else:
+    for a in arg:
+      result.append( a )
+
+  print "returning ",result
+  return result
+
+
+
+
+def expand_nested_list( arg, arg_map, use_arg_map = True ):
+
+  print "Expanding nested list: ", arg, len(arg)
+  if type( arg ) == StringType:
+    print "Type is string"
+    # .....
+    if re.compile( '^[A-Z]+$' ).match( arg ) == None:
+      return arg
+    else:
+      if use_arg_map:
+        if not arg_map.has_key( arg ):
+          return '?' + arg.upper()
+        else:
+          return arg_map[ arg ][ 'code' ][ 'call_level_0' ]
+      else:
+        return arg.lower()
+    
+  if arg[0] == '()':
+    result = '(' + expand_nested_list( arg[1], arg_map, use_arg_map ) + ')'
+    return result
+    
+  if arg[0] == 'max' or arg[0] == 'min':
+    print "arg1: ", arg[1]
+    result = 'std::' + arg[0] + '('
+    i = 0
+    for a in arg[1]:
+      result += expand_nested_list( a, arg_map, use_arg_map )
+      i += 1
+      if i != len(arg[1]):
+        result += ","
+    result += ')'
+    return result
+  
+  if arg[0] == '*' or arg[0] == '/' or arg[0] == '+' or arg[0] == '-':
+    print "arg1: ", arg[1]
+    arg_list = []
+    for a in arg[1]:
+      arg_list += [ expand_nested_list( a, arg_map, use_arg_map ) ]
+    result = arg[0].join( arg_list )
+    return result
+  
+  print "ERROR: Don't know what to do!!"
+  return 'ERROR'
+
+def level1_assert( name, properties, arg_map ):
+  result = None
+  
+  if properties.has_key( 'assert_char' ):
+    result = "assert( "
+    result_array = []
+    for char in properties[ 'assert_char' ]:
+      result_array += [ call_level0_type( name, properties, arg_map ) + ' == \'' + char + '\'' ]
+    result += " || ".join( result_array )
+    result += " );"
+    
+  if properties.has_key( 'assert_ge' ) and not properties.has_key( 'workspace_query_for' ):
+    result = "assert( " + call_level0_type( name, properties, arg_map ) + " >= " + expand_nested_list( properties[ 'assert_ge' ], arg_map ) + ' );'
+      
+  if 'workspace' in properties[ 'io' ]:
+    min_workspace_call = min_workspace_call_type( name, properties, arg_map )
+    if min_workspace_call == None:
+      min_workspace_call = '$CALL_MIN_SIZE'
+    result = 'assert( traits::vector_size(work.select(' + workspace_type( name, properties ) + '()) >= ' + \
+             'min_size_' + name.lower() + '( ' + min_workspace_call + ' )));'
+  
+  elif properties.has_key( 'assert_size' ):
+    result = "assert( traits::vector_size(" + call_level0_type( name, properties, arg_map ) + ") >= " + \
+      expand_nested_list( properties[ 'assert_size' ], arg_map ) + ' );'
+  
+  return result
+
+
+def call_level1_type( name, properties ):
+  result = None
+  if level1_type( name, properties ) != None:
+    result = name.lower()
+  return result
+
+
+def workspace_type( name, properties ):
+  result = None
+  if 'workspace' in properties[ 'io' ]:
+    if properties[ 'value_type' ] == 'INTEGER':
+      result = 'integer_t'
+    elif properties[ 'value_type' ] == 'LOGICAL':
+      result = 'bool'
+    elif properties[ 'value_type' ] == 'REAL' or properties[ 'value_type' ] == 'DOUBLE PRECISION':
+      result = 'real_type'
+    else: 
+      result = 'value_type'
+  return result
+
+
+
+
+def opt_workspace_pre_type( name, properties, arg_map ):
+  result = None
+  if 'workspace' in properties[ 'io' ]:
+    if properties.has_key( 'workspace_query_by' ):
+      result = workspace_type( name, properties ) + ' opt_size_' + name.lower() + ';'
+    else:
+      min_workspace_call = min_workspace_call_type( name, properties, arg_map )
+      if min_workspace_call == None:
+        min_workspace_call = '$CALL_MIN_SIZE'
+      result = 'traits::detail::array< ' + workspace_type( name, properties ) + ' >' + \
+               ' tmp_' + name.lower() + '( min_size_' + name.lower() + '( ' + min_workspace_call + ' ) );'
+  return result
+
+
+def opt_workspace_post_type( name, properties ):
+  result = None
+  if 'workspace' in properties[ 'io' ]:
+    if properties.has_key( 'workspace_query_by' ):
+      if properties['value_type'] == 'INTEGER':
+        result = 'traits::detail::array< ' + workspace_type( name, properties ) + ' >' + \
+               ' tmp_' + name.lower() + '( opt_size_' + name.lower() + ' );'
+      else:
+        result = 'traits::detail::array< ' + workspace_type( name, properties ) + ' >' + \
+               ' tmp_' + name.lower() + '( traits::detail::to_int( opt_size_' + name.lower() + ' ) );'
+  return result
+
+
+
+def opt_workspace_query_type( name, properties, arg_map ):
+  result = None
+  if properties.has_key( 'workspace_query_for' ):
+    result = '-1'
+  elif 'workspace' in properties[ 'io' ]:
+    if properties.has_key( 'workspace_query_by' ):
+      result = '&opt_size_' + name.lower();
+    else:
+      result = 'traits::vector_storage(tmp_' + name.lower() + ')'
+  else:
+    result = call_level0_type( name, properties, arg_map )
+  return result
+
+
+def min_workspace_size_type( name, properties, arg_map ):
+  result = None
+  if 'workspace' in properties[ 'io' ] and properties.has_key( 'assert_size' ):
+    result = expand_nested_list( properties[ 'assert_size' ], arg_map, False );
+  return result
+
+
+def min_workspace_arg_type( name, properties, arg_map ):
+  result = None
+  if 'workspace' in properties[ 'io' ] and properties.has_key( 'assert_size_args' ):
+    code_result = []
+    for arg in properties[ 'assert_size_args' ]:
+      if arg_map.has_key( arg ):
+        code_result += [ cpp_type( arg, arg_map[ arg ] ) ]
+      else:
+        code_result += [ '?' + arg.upper() ]
+    result = ", ".join( code_result )
+  return result
+
+
+def min_workspace_call_type( name, properties, arg_map ):
+  result = None
+  if 'workspace' in properties[ 'io' ] and properties.has_key( 'assert_size_args' ):
+    code_result = []
+    for arg in properties[ 'assert_size_args' ]:
+      if arg_map.has_key( arg ):
+        code_result += [ call_level0_type( arg, arg_map[ arg ], arg_map ) ]
+      else:
+        code_result += [ '?' + arg.upper() ]
+      
+    result = ", ".join( code_result )
+  return result
+
+
+def user_defined_type( name, properties, arg_map ):
+  result = None
+  if properties.has_key( 'user_defined' ):
+    result = properties[ 'user_defined' ]
+  return result
+
+
+
+#
+#
+#
+#
+def match_formulae( text_field ):
+  find_start = re.compile( '([A-Z]+)\s?(>=|is\sat\sleast)\s?(.*)the\scode\swill', re.M | re.S ).findall( text_field )
+  for element in find_start:
+    print element
+
+
+
+#
+# Split string using a list of delimiters
+# Delimiters may be substrings of length 1 or 2 (may be increased if necessary)
+#
+def split_delim( s, delim = [','] ):
+  result = []
+  parentheses = 0
+  cur_pos = 0
+  prev_pos = 0
+  for index in range( 0, len(s) ):
+    if s[ index ] == '(': 
+      parentheses += 1
+    elif s[ index ] == ')':
+      parentheses -= 1
+    for length in range( 1, 3 ):
+      if index >= (length-1) and parentheses == 0:
+        c = s[ index-(length-1): index+1 ]
+        if c in delim:
+          result += [ s[ prev_pos:(index-(length-1)) ] ]
+          prev_pos = index+1
+          
+  result += [ s[ prev_pos:len(s) ] ]
+  return result
+
+
+
+#
+# Look for implicit products, like 5N, and replace with 5*N
+#
+def replace_implicit_products( text_field ):
+  result = re.sub( '([0-9])+([A-Z]+)', '\\1*\\2', text_field )
+  return result
+
+
+
+
+def decompose_formula( text_field ):
+  text_field = text_field.strip()
+  print "Decompose: ", text_field
+  
+  if text_field[0] == '(' and text_field[-1] == ')':
+    result = text_field[ 1:-1 ]
+    return [ '()', decompose_formula( result ) ]
+  
+  if len( split_delim( text_field, [ ',' ] ) ) > 1:
+    print "ERROR! (in LAPACK?)"
+    return [ 'ERROR' ]
+  
+  #
+  # Detect leaf: if text_field equals a argument (like N), or a number
+  #  
+  if re.compile( '^([a-zA-Z]+|[0-9]+)$' ).match( text_field ):
+    print "decompose: at leaf: '" + text_field + "'"
+    return text_field.upper()
+  
+  
+  if len( split_delim( text_field, [ '**' ] ) ) > 1:
+    print 'decompose: inserting pow'
+    arguments = split_delim( text_field, [ '**' ] )
+    print arguments
+    result = []
+    for arg in arguments:
+      result.append( decompose_formula( arg ) )
+    return [ 'pow', result ]
+  
+  for operator in [ '*', '/', '+', '-' ]:
+    if len( split_delim( text_field, [ operator ] ) ) > 1:
+      print 'decompose: inserting ' + operator
+      arguments = split_delim( text_field, operator )
+      print arguments
+      result = []
+      for arg in arguments:
+        result.append( decompose_formula( arg ) )
+      return [ operator, result ]
+    
+  
+  if (text_field[ 0:4 ] == 'max(' or text_field[ 0:4 ] == 'MAX(') and \
+    text_field[ -1 ] == ')':
+    print "decompose: inserting max"
+    arguments = split_delim( text_field[ 4:-1 ] )
+    print arguments, len(arguments)
+    # keep max a binary function ... :-)
+    if len( arguments ) > 2:
+      return [ 'max', [ decompose_formula( arguments[0] ), decompose_formula( 'max(' + ",".join( arguments[1:] ) + ')' ) ] ]
+    else:  
+      result = []
+      for arg in arguments:
+        result.append( decompose_formula( arg ) )
+      #result = [ decompose_formula( arguments[0] ), decompose_formula( arguments[1] ) ]
+      return [ 'max', result ]
+  
+
+  if (text_field[ 0:4 ] == 'min(' or text_field[ 0:4 ] == 'MIN(') and \
+    text_field[ -1 ] == ')':
+    print "decompose: inserting min"
+    arguments = split_delim( text_field[ 4:-1 ] )
+    print arguments, len(arguments)
+    # keep max a binary function ... :-)
+    if len( arguments ) > 2:
+      return [ 'min', [ decompose_formula( arguments[0] ), decompose_formula( 'min(' + ",".join( arguments[1:] ) + ')' ) ] ]
+    else:  
+      result = []
+      for arg in arguments:
+        result.append( decompose_formula( arg ) )
+      #result = [ decompose_formula( arguments[0] ), decompose_formula( arguments[1] ) ]
+      return [ 'min', result ]
+  
+
+#
+#
+def match_assert_ge( argument_map, text_field ):
+  #print "Match assert GE..."
+  match_it = re.compile( ' +[A-Z]+[ ]{0,3}(>=|must be at least)[ ]{0,3}([0-9]|(min|max|MIN|MAX|[\(\)\,0-9A-Z\+\*\-])+)' ).findall( text_field )
+  if len( match_it ) == 1:
+    print "Match assert GE:", match_it
+    #print match_it
+    #if len( match_it[ 0 ][ 2 ] ) > 0:
+    return decompose_formula( match_it[ 0 ][ 1 ] )
+  else:
+    print "nr of matches: ", len( match_it )
+    return None
+  
+
+
+
+
+# try different keys, return the one that exists, if any
+
+def my_has_key( key_name, template_map ):
+  # try, e.g., gelsd.all.
+  m_all_key = key_name.replace( ".complex", ".all" ).replace( ".real", ".all" )
+  if template_map.has_key( key_name ):
+    print "using key ", key_name
+    return key_name
+  if template_map.has_key( m_all_key ):
+    print "using key ", m_all_key
+    return m_all_key
+  print "tried keys ", key_name, "and", m_all_key,", no results"
+  return None
+
+
+
+#
+# Default user-defined arg is of type scalar INTEGER
+#
+def add_user_defined_args( arg, argument_map, template_map, base_name ):
+  print "Trying to add user-defined argument definitions for", arg
+
+  argument_map[ arg ] = {}
+
+  base_key = base_name.lower() + '.' + arg
+  print "base_key",base_key
+
+  if my_has_key( base_key + '.value_type', template_map ) != None:
+    argument_map[ arg ][ 'value_type' ] = template_map[ my_has_key( base_key + '.value_type', template_map ) ].strip()
+  else:
+    argument_map[ arg ][ 'value_type' ] = 'INTEGER'
+
+  if my_has_key( base_key + '.type', template_map ) != None:
+    argument_map[ arg ][ 'type' ] = template_map[ my_has_key( base_key + '.type', template_map ) ].strip()
+  else:
+    argument_map[ arg ][ 'type' ] = 'scalar'
+
+  if my_has_key( base_key + '.init', template_map ) != None:
+    argument_map[ arg ][ 'user_defined' ] = template_map[ my_has_key( base_key + '.init', template_map ) ].strip()
+  else:
+    argument_map[ arg ][ 'user_defined' ] = 'UNDEFINED'
+
+  argument_map[ arg ][ 'io' ] = [ 'input' ]
+
+  return
+
+
+
+
+
+
+
+#
+# Parse a LAPACK file
+# input: filename
+# output: a pair of ( function name, map )
+#         the map contains: 
+#         'arguments': an array of arguments
+#         'argument_map': a map of ( argument_name, property ), 
+#                     in which property can be
+#            'type': Fortran type
+#            'cpptype': C++ type
+#            'io': the (input/output) part from the comment section
+#
+def parse_file( filename, template_map ):
+
+  # for nice printing
+  pp = pprint.PrettyPrinter( indent = 2 )
+
+  # read the entire fortran source file
+  source = open( filename ).read()
+
+  # parse and split the code 
+  # * merge multilines to one line (using the $ and + characters)
+  # * split comments-blocks and code blocks
+  # * remove '*' from comments
+  # input:  full source code
+  # output: an array of lines of code
+  #         an array of lines of comments
+  code = []
+  comments = []
+  for i in source.splitlines():
+
+    # Special case: in e.g. CHEEVR comments are lead by many stars instead of 1
+    # replace those (more than 1) with spaces so that it becomes a regular comment
+    # block.
+    leading_stars = re.compile( '^[ ]*\*(\*+)' ).match( i )
+    if leading_stars != None:
+      spaces = i[ leading_stars.start(1):leading_stars.end(1) ].replace( '*', ' ' )
+      i = i[0:leading_stars.start(1)] + spaces + \
+        i[leading_stars.end(1):len(i)]
+
+    # Continue for the regular case
+    match_comment = re.compile( '^[ ]*\*(.*)' ).search( i )
+    if match_comment == None:
+      match_multi = re.compile( '^[ ]*[\$\+][ ]*(.*)$' ).search( i )
+      if match_multi == None:
+        code += [ i ]
+      else:
+        code[-1 ] += match_multi.expand( "\\1" )
+    else:
+      comments += [ match_comment.expand( "\\1" ) ]
+
+  # Acquire important information
+  # * the subroutine name
+  # * the arguments of the subroutine
+  subroutine_found = False
+  subroutine_name = ''
+  subroutine_arguments = []
+  code_line_nr = 0
+  while code_line_nr < len(code) and not subroutine_found:
+    match_subroutine_name = re.compile( 'SUBROUTINE[ ]+([A-Z]+)\(([^\)]+)' ).search( code[ code_line_nr ] )
+    if match_subroutine_name != None:
+      subroutine_found = True
+      subroutine_name = match_subroutine_name.group( 1 )
+      subroutine_arguments = match_subroutine_name.group( 2 ).replace( ' ', '' ).split( "," )
+    code_line_nr += 1
+
+  # If we could not find a subroutine, we quit at our earliest convenience
+  if code_line_nr == len(code):
+    return None, None
+
+  #
+  # Do some further analysis as to what kind of routine this is
+  #
+  subroutine_group_name = subroutine_name[ 1: ]
+  subroutine_value_type = None
+  if subroutine_name[0] == 'C' or subroutine_name[0] == 'Z':
+    subroutine_value_type = 'complex'
+  if subroutine_name[0] == 'S' or subroutine_name[0] == 'D':
+    subroutine_value_type = 'real'
+
+  print "Subroutine: ", subroutine_name
+  print "Arguments:  ", len(subroutine_arguments),":",subroutine_arguments
+  print "Group name: ", subroutine_group_name
+  print "Variant:    ", subroutine_value_type
+
+  # Now we have the names of the arguments. The code following the subroutine statement are
+  # the argument declarations. Parse those right now, splitting these examples
+  #      INTEGER            INFO, LDA, LDVS, LWORK, N, SDIM
+  #      COMPLEX            A( LDA, * ), VS( LDVS, * ), W( * ), WORK( * )
+  # into a map containing
+  #      INFO: value_type=INTEGER, type=scalar
+  #      WORK: value_type=COMPLEX, type=vector
+  #         A: value_type=COMPLEX, type=matrix, leading_dimension=LDA
+  # etc.
+  arguments_found = False
+  argument_map = {}
+  while code_line_nr < len(code) and len( argument_map ) < len( subroutine_arguments ):
+    match_argument_declaration = re.compile( '^[ ]*(EXTERNAL|LOGICAL|CHARACTER|REAL|INTEGER' + \
+      '|DOUBLE PRECISION|DOUBLE COMPLEX|COMPLEX\*16|COMPLEX)[ ]+(.*)$' ).search( code[ code_line_nr] )
+    if match_argument_declaration != None:
+      for argument_match in re.findall( '([A-Z0-9]+(\([^\)]+\))?)[, ]?', match_argument_declaration.group( 2 ) ):
+        argument_description = argument_match[0].strip().split( "(" )
+        argument_name = argument_description[0]
+        argument_map[ argument_name ] = {}
+        argument_map[ argument_name ][ 'value_type' ] = match_argument_declaration.group( 1 )
+        if len(argument_description) == 1:
+          argument_map[ argument_name ][ 'type' ] = 'scalar'
+        else:
+          if argument_description[1].find( "," ) == -1:
+            argument_map[ argument_name ][ 'type' ] = 'vector'
+          else:
+            argument_map[ argument_name ][ 'type' ] = 'matrix'
+            # check if there is a leading dimension
+            argument_map[ argument_name ][ 'leading_dimension' ] = argument_description[1].split( "," )[0].strip()
+    code_line_nr += 1
+
+  # Create convenience lookups by value_type and types of arguments
+  # e.g., grouped_arguments[ 'by_value_type' ][ 'INTEGER' ] will give an array of all integer types
+  #       grouped_arguments[ 'by_type' ][ 'matrix' ] will give an array of all matrices
+  grouped_arguments = {}
+  key_array = [ 'type', 'value_type' ]
+  for s in key_array:
+    grouped_arguments[ 'by_' + s ] = {}
+  # make sure the order of argument names is the same as those in the subroutine argument order
+  for argument_name in subroutine_arguments:
+    argument_properties = argument_map[ argument_name ]
+    for s in key_array:
+      if not grouped_arguments[ 'by_' + s ].has_key( argument_properties[ s ] ):
+        grouped_arguments[ 'by_' + s ][ argument_properties[ s ] ] = []
+      grouped_arguments[ 'by_' + s ][ argument_properties[ s ] ] += [ argument_name ]
+
+  # The next bulk load of information can be acquired from the comment fields, 
+  # this is between "Purpose" and "Arguments". Locate those headers, and init with
+  # -1 so that we can check if they where found.
+  comment_line_nr = 0
+  purpose_line_nr = -1
+  arguments_line_nr = -1
+  while comment_line_nr < len(comments) and purpose_line_nr == -1:
+    if re.compile( '^[ ]+Purpose[ ]*$' ).search( comments[ comment_line_nr ] ) != None:
+      purpose_line_nr = comment_line_nr
+    comment_line_nr += 1
+
+  while comment_line_nr < len(comments) and arguments_line_nr == -1:
+    if re.compile( '^[ ]+Arguments[ ]*$' ).search( comments[ comment_line_nr ] ) != None:
+      arguments_line_nr = comment_line_nr
+    comment_line_nr += 1
+
+  # Gather the actual subroutine purpose. This is always following the Purpose title (obvious :-))
+  # and stopping before the "Arguments" block.
+  subroutine_purpose = ''
+  if purpose_line_nr > 0 and arguments_line_nr > 0:
+    subroutine_purpose = "//" + "\n//".join( comments[ purpose_line_nr+3:arguments_line_nr-1 ] )
+
+  # Break up the comments
+  # Now, for each argument, locate its associated comment field
+  #
+  # In this case, for M, we store the range [45, 48>
+  no_commented_arguments = 0
+  if arguments_line_nr > 0:
+    preceding_argument = ''
+    finished_the_last = False
+    detected_lapack_style = False
+    detected_blas_style = False
+    while comment_line_nr < len(comments) and not finished_the_last:
+
+      # Example for LAPACK-style matching. 
+      # 45 M       (input) INTEGER
+      # 46         The number of rows of the matrix A. M >= 0.
+      # 47
+      # 48 N       (input) INTEGER
+      match_lapack_style = re.compile( '^[\s]*([A-Z]+[2]?)[\s]+\(([a-z/ ]+)\)' ).search( comments[ comment_line_nr ] )
+      if not detected_blas_style and match_lapack_style != None:
+        detected_lapack_style = True
+        argument_name = match_lapack_style.group(1)
+        argument_map[ argument_name ][ 'comment_lines' ] = [ comment_line_nr ]
+        split_regex = re.compile( '\/| or ' )
+        argument_map[ argument_name ][ 'io' ] = split_regex.split( match_lapack_style.group(2) )
+        if preceding_argument != '':
+          argument_map[ preceding_argument ][ 'comment_lines' ] += [ comment_line_nr ]
+        preceding_argument = argument_name
+        no_commented_arguments += 1
+
+      # Example for BLAS, which doesn't mention input/output on the same line
+      # 37 N      - INTEGER.
+      # 38          On entry, N specifies the order of the matrix A.
+      # 39          N must be at least zero.
+      # 40          Unchanged on exit.
+      match_blas_style = re.compile( '^[\s]*([A-Z]+[2]?)[\s]+\- [A-Z]+' ).search( comments[comment_line_nr] )
+      if not detected_lapack_style and match_blas_style != None:
+        detected_blas_style = True
+        argument_name = match_blas_style.group(1)
+        argument_map[ argument_name ][ 'comment_lines' ] = [ comment_line_nr ]
+        # default input/output with blas to output, this will be overwritten if "unchanged on exit" is
+        # found
+        argument_map[ argument_name ][ 'io' ] = [ 'output' ]
+        if preceding_argument != '':
+          argument_map[ preceding_argument ][ 'comment_lines' ] += [ comment_line_nr ]
+        preceding_argument = argument_name
+        no_commented_arguments += 1
+
+      # Detection for BLAS' "input" statement
+      match_unchanged_on_exit = re.compile( '^[\s]*[uU]nchanged on exit' ).search( comments[comment_line_nr] )
+      if detected_blas_style and match_unchanged_on_exit != None:
+        argument_map[ preceding_argument ][ 'io' ] = [ 'input' ]
+
+      # INFO comes last, so detect an empty line for this case
+      if no_commented_arguments == len( subroutine_arguments ) and \
+         len( argument_map[ preceding_argument ][ 'comment_lines' ] ) < 2:
+        match_empty_line = re.compile( '^[ ]*$' ).search( comments[ comment_line_nr ] )
+        if match_empty_line != None:
+          argument_map[ preceding_argument ][ 'comment_lines' ] += [ comment_line_nr + 1 ]
+          finished_the_last = True
+
+      comment_line_nr += 1
+
+    # Inform the debug.log / user which comment style we employed
+    if ( detected_lapack_style ):
+      print "Argument comment style: LAPACK"
+    elif ( detected_blas_style ):
+      print "Argument comment style: BLAS"
+
+  #
+  # TODO
+  # TODO
+  # TODO
+  #
+  if no_commented_arguments != len( subroutine_arguments ):
+    print str(no_commented_arguments) + " out of " + str(len(subroutine_arguments)) + \
+      " arguments are commented, bailing out"
+    return subroutine_name, None
+
+  #
+  # Make a back-reference to those arguments that are defined as leading dimension in the code
+  #
+  for argument_name, argument_properties in argument_map.iteritems():
+    if argument_properties.has_key( 'leading_dimension' ):
+      referring_argument_name = argument_properties[ 'leading_dimension' ]
+      if argument_map.has_key( referring_argument_name ):
+        argument_map[ referring_argument_name ][ 'trait_type' ] = 'lda'
+        argument_map[ referring_argument_name ][ 'trait_of' ] = argument_name
+
+  # Extend convenience lookups by io, recently acquired when processing the comment
+  # fields. We have to be sure arguments are processed in the right order.
+  grouped_arguments[ 'by_io' ] = {}
+  for argument_name in subroutine_arguments:
+    argument_properties = argument_map[ argument_name ]
+    print argument_name, argument_properties
+    for io_type in argument_properties[ 'io' ]:
+      if not grouped_arguments[ 'by_io' ].has_key( io_type ):
+        grouped_arguments[ 'by_io' ][ io_type ] = []
+      grouped_arguments[ 'by_io' ][ io_type ] += [ argument_name ]
+
+  #
+  # Parse the comment fields
+  #
+  user_defined_arg_map = {}
+  for argument_name, argument_properties in argument_map.iteritems():
+
+    print "\n\n**********"
+    print argument_name
+    comment_block = "\n".join( comments[ argument_properties[ 'comment_lines' ][0] : argument_properties[ 'comment_lines' ][1] ] )
+    print comment_block
+    match_formulae( comment_block )
+
+    #
+    # Handle scalar INTEGER comment blocks. Look for type traits stuff.
+    #
+    if argument_properties[ 'type' ] == 'scalar' and \
+       argument_properties[ 'value_type' ] == 'INTEGER':
+      #
+      # Fetch matrix traits such as "the number of columns of A"
+      #
+      match_matrix_traits = re.compile( '(rows|columns|order)(in|of|the|input|\s)+(matrix|matrices|\s)+' + \
+        '([A-Z]+\s+and\s+[A-Z]+|[A-Z]+)', re.M | re.S ).findall( comment_block )
+      if len( match_matrix_traits ) == 1:
+        if match_matrix_traits[0][0] == 'order':
+          # PANIC: return none
+          # e.g., in tridiagonal case, there is no matrix, but a number of 
+          # vectors (the diagonals)
+          if not grouped_arguments[ 'by_type' ].has_key( 'matrix' ):
+            # TODO
+            # TODO
+            return subroutine_name, None
+            # TODO
+            # TODO
+          if match_matrix_traits[0][3] in grouped_arguments[ 'by_type' ][ 'matrix' ]:
+            # because it is both #rows and #columns, we have to choose one
+            argument_properties[ 'trait_type' ] = 'num_columns'
+            argument_properties[ 'trait_of' ] = match_matrix_traits[0][3].strip()
+
+          # see if the traits are overruled through the template system
+          traits_key = subroutine_group_name.lower() + '.' + subroutine_value_type + '.' + argument_name + '.trait_of'
+          if my_has_key( traits_key, template_map ):
+            argument_properties[ 'trait_type' ] = 'num_columns'
+            argument_properties[ 'trait_of' ] = template_map[ my_has_key( traits_key, template_map ) ].strip()
+
+        else:
+          references = match_matrix_traits[0][3].split( 'and' )
+          for matrix_name in references:
+            if matrix_name.strip() in grouped_arguments[ 'by_type' ][ 'matrix' ]:
+              argument_properties[ 'trait_type' ] = 'num_' + match_matrix_traits[0][0]
+              argument_properties[ 'trait_of' ] = matrix_name.strip()
+
+      #
+      # Fetch array traits, such as "the length of the array WORK"
+      #
+      match_array_traits = re.compile( '(The length|The dimension)(of|the|\s)+(array|\s)+([A-Z]+)', re.M | re.S ).findall( comment_block )
+      if len( match_array_traits ) > 0 and match_array_traits[ 0 ][ 3 ] in grouped_arguments[ 'by_type' ][ 'vector' ]:
+        argument_properties[ 'trait_type' ] = 'size'
+        argument_properties[ 'trait_of' ] = match_array_traits[ 0 ][ 3 ]
+
+      # Fetch greater-than-or-equal-to integer asserts, such as 
+      # M >= 0.
+      # N >= max(...)
+      match_greater_equal = match_assert_ge( argument_map, comment_block )
+      if match_greater_equal != None:
+        argument_properties[ 'assert_ge' ] = match_greater_equal
+
+      # Are we dealing with a workspace-length integer?
+      # If so, try to detect the workspace-query text.
+      # And, try to detect for which work arrays the query will run.
+      # Keep the same order of workspace names as used in the grouped arguments map
+      if 'WORK' in argument_name:
+        match_query = re.compile( 'If ' + argument_name + ' \= \-1(\,|then|a|workspace|\s)+query', re.M ).search( comment_block )
+        if match_query != None:
+          work_query_block = comment_block[ match_query.start(0): ]
+          any_workspace = "(" + "|".join( grouped_arguments[ 'by_io' ][ 'workspace' ] ) + ")"
+          match_workspace = re.compile( '[^A-Z]' + any_workspace, re.M | re.S ).findall( work_query_block )
+          if len( match_workspace ) > 0:
+            argument_properties[ 'workspace_query_for' ] = []
+          for name in grouped_arguments[ 'by_io' ][ 'workspace' ]:
+            if name in match_workspace:
+              argument_properties[ 'workspace_query_for' ] += [ name ]
+
+    #
+    # Handle CHARACTER comment blocks.
+    # Try to get which variables are valid, to put this in asserts.
+    #
+    elif argument_properties[ 'value_type' ] == 'CHARACTER':
+      match_statements = re.compile( '=(\s|or|\'[0-9A-Z]\')+[:,]', re.M ).finditer( comment_block )
+      for statement in match_statements:
+        print "Statement:",statement.group(0)
+        match_letters = re.compile( '\'([0-9A-Z])\'' ).findall( statement.group(0) )
+        for letter in match_letters:
+          print "Letter",letter
+          if not argument_properties.has_key( 'assert_char' ):
+            argument_properties[ 'assert_char' ] = []
+          if not letter in argument_properties[ 'assert_char' ]:
+            argument_properties[ 'assert_char' ] += [ letter ]
+
+      if argument_name == 'UPLO':
+        match_uplo = re.compile( '(Upper|Lower)(triangle|triangles|of|input|matrix|\s)+([A-Z]+)' ).findall( comment_block )
+        if len( match_uplo ) == 2 and len( argument_properties[ 'assert_char' ] ) == 2 and \
+          'U' in argument_properties[ 'assert_char' ] and 'L' in argument_properties[ 'assert_char' ]:
+          print "adding uplo trait"
+          argument_properties[ 'trait_type' ] = 'uplo'
+          argument_properties[ 'trait_of' ] = match_uplo[ 0 ][ 2 ]
+
+          # see if the traits are overruled through the template system
+          traits_key = subroutine_group_name.lower() + '.' + subroutine_value_type + '.' + argument_name + '.trait_of'
+          if my_has_key( traits_key, template_map ):
+            argument_properties[ 'trait_of' ] = template_map[ my_has_key( traits_key, template_map ) ].strip()
+
+    #
+    # Minimal workspace dimension recognition
+    #
+    elif argument_properties[ 'type' ] == 'vector':
+      # usually this text is
+      # 1) dimension (...)           without spaces in the formula
+      # 2) dimension at least ...    (e.g., RWORK IN CLALSA)
+      match_dim = re.compile( 'dimension \((.+)\)' ).findall( comment_block )
+      print "Matches on dimension(): ", len( match_dim )
+      for d in match_dim:
+        d = d.replace( ' ', '' )
+        #
+        # TODO
+        # make some sensible rules here
+        #
+        match_unwanted_text = re.compile( '\s([Ii]f|[Ww]hen)\s' ).findall( comment_block )
+        print match_unwanted_text
+        if len( match_unwanted_text ) == 0:
+          argument_properties[ 'assert_size' ] = decompose_formula( replace_implicit_products( d ) )
+          argument_properties[ 'assert_size_args' ] = nested_list_args( argument_properties[ 'assert_size' ] )
+
+      # assert_size_args determines the arguments of min_size function for this
+      # workspace array. But, this gets overruled by user-defined templates.
+      if 'workspace' in argument_properties[ 'io' ]:
+        args_string = None
+        template_key = subroutine_group_name.lower() + '.' + subroutine_value_type + '.min_size_' + argument_name.lower() + '.args'
+        if my_has_key( template_key, template_map ) != None:
+          args_string = template_map[ my_has_key( template_key, template_map ) ]
+          tmp_result = []
+          for arg in args_string.split( "," ):
+            tmp_result.append( arg.strip().upper() )
+          if tmp_result == ['']:
+            tmp_result = []
+
+          for arg in tmp_result:
+            if arg not in argument_map.keys():
+              # variable not found, try user-defined variable definitions
+              add_user_defined_args( arg, user_defined_arg_map, template_map, subroutine_group_name + '.' + subroutine_value_type )
+
+          argument_properties[ 'assert_size_args' ] = tmp_result
+          print "Using user-defined assert_size_args: ", tmp_result
+
+      #
+      # Try to detect packed strorage stuff. Typically these are vectors in Fortran, but 
+      # matrices in our bindings. E.g. as used in spsv. 
+      #
+      packed_keywords = re.compile( '(/s|packed|matrix)+', re.M ).findall( comment_block )
+      if 'matrix' in packed_keywords and 'packed' in packed_keywords:
+        #
+        # Overrule my type :-)
+        #
+        argument_properties[ 'type' ] = 'matrix'
+
+  #
+  # Add user-defined arguments to the argument_map
+  #
+  argument_map.update( user_defined_arg_map )
+
+
+  print "Argument map: "  
+  pp.pprint( argument_map )
+
+
+  #
+  # Make a back-reference for workspace queries
+  #
+  for argument_name, argument_properties in argument_map.iteritems():
+    if argument_properties.has_key( 'workspace_query_for' ):
+      for referring_argument_name in argument_properties[ 'workspace_query_for' ]:
+        if argument_map.has_key( referring_argument_name ):
+          if not argument_map[ referring_argument_name ].has_key( 'workspace_query_by' ):
+            argument_map[ referring_argument_name ][ 'workspace_query_by' ] = []
+          argument_map[ referring_argument_name ][ 'workspace_query_by' ] += [ argument_name ]
+
+
+  #
+  # Generate the actual C++ code statements, based on information acquired so far.
+  #
+  # pass 1
+  for argument_name, argument_properties in argument_map.iteritems():
+    argument_properties[ 'code' ] = {}
+    argument_properties[ 'code' ][ 'lapack_h' ] = c_type( argument_name, argument_properties )
+    argument_properties[ 'code' ][ 'call_c_header' ] = call_c_type( argument_name, argument_properties )
+    argument_properties[ 'code' ][ 'level_0' ] = cpp_type( argument_name, argument_properties )
+    argument_properties[ 'code' ][ 'call_level_0' ] = call_level0_type( argument_name, argument_properties, argument_map )
+    argument_properties[ 'code' ][ 'level_1' ] = level1_type( argument_name, argument_properties )
+    argument_properties[ 'code' ][ 'level_1_type' ] = level1_typename( argument_name, argument_properties )
+    argument_properties[ 'code' ][ 'call_level_1' ] = call_level1_type( argument_name, argument_properties )
+    argument_properties[ 'code' ][ 'level_2' ] = level2_type( argument_name, argument_properties )
+    argument_properties[ 'code' ][ 'workspace_type' ] = workspace_type( argument_name, argument_properties )
+    
+  # Pass 2
+  # A second pass is needed, because the asserts may cross-reference other 
+  # variables which have been assigned their code in pass 1.
+  for argument_name, argument_properties in argument_map.iteritems():
+    argument_properties[ 'code' ][ 'level_1_assert' ] = level1_assert( argument_name, argument_properties, argument_map )
+    argument_properties[ 'code' ][ 'opt_workspace_query' ] = opt_workspace_query_type( argument_name, argument_properties, argument_map )
+    argument_properties[ 'code' ][ 'opt_workspace_pre' ] = opt_workspace_pre_type( argument_name, argument_properties, argument_map )
+    argument_properties[ 'code' ][ 'opt_workspace_post' ] = opt_workspace_post_type( argument_name, argument_properties )
+    argument_properties[ 'code' ][ 'min_workspace' ] = min_workspace_size_type( argument_name, argument_properties, argument_map )
+    argument_properties[ 'code' ][ 'min_workspace_args' ] = min_workspace_arg_type( argument_name, argument_properties, argument_map )
+    argument_properties[ 'code' ][ 'min_workspace_call' ] = min_workspace_call_type( argument_name, argument_properties, argument_map )
+    argument_properties[ 'code' ][ 'user_defined_init' ] = user_defined_type( argument_name, argument_properties, argument_map )
+
+  print "Argument map: "  
+  pp.pprint( argument_map )
+
+  print "Grouped arguments: "
+  pp.pprint( grouped_arguments )
+
+  #
+  # create a dict object
+  #
+  info_map = {}
+  info_map[ 'arguments' ] = subroutine_arguments
+  info_map[ 'purpose' ] = subroutine_purpose
+  info_map[ 'argument_map' ] = argument_map
+  info_map[ 'grouped_arguments' ] = grouped_arguments
+  
+  #
+  # Pass / check user-defined stuff right here.
+  #
+  user_def_key = subroutine_group_name.lower() + '.' + subroutine_value_type + '.extra_variables'
+  if my_has_key( user_def_key, template_map ) != None:
+    user_vars = template_map[ my_has_key( user_def_key, template_map ) ].split( "," )
+    tmp_result = []
+    for v in user_vars:
+      tmp_result.append( v.strip().upper() )
+    info_map[ 'user_defined_variables' ] = tmp_result
+  else:
+    info_map[ 'user_defined_variables' ] = None
+    
+  #
+  # Pass / check user-defined stuff right here.
+  # OPTIMAL CASE (may contain fewer variables)
+  #
+  user_def_key = subroutine_group_name.lower() + '.' + subroutine_value_type + '.extra_opt_variables'
+  if my_has_key( user_def_key, template_map ) != None:
+    user_vars = template_map[ my_has_key( user_def_key, template_map ) ].split( "," )
+    tmp_result = []
+    for v in user_vars:
+      tmp_result.append( v.strip().upper() )
+    info_map[ 'user_defined_opt_variables' ] = tmp_result
+  else:
+    info_map[ 'user_defined_opt_variables' ] = None
+  
+  
+  #subroutine_description.replace( subroutine_name, subroutine_name[ 1: ] )
+  #info_map[ 'description' ] = subroutine_description
+  
+  return subroutine_name, info_map
+
+

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/blas.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/blas.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,57 @@
+$TEMPLATE[blas.hpp]
+//
+// Copyright (c) 2003--2009
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_BLAS_$GROUPNAME_HPP
+#define BOOST_NUMERIC_BINDINGS_BLAS_$GROUPNAME_HPP
+
+$INCLUDES
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace blas {
+
+//$DESCRIPTION
+
+// overloaded functions to call blas
+namespace detail {
+$OVERLOADS}
+
+$LEVEL1
+
+}}}} // namespace boost::numeric::bindings::blas
+
+#endif
+$TEMPLATE[blas_overloads]
+    inline void $groupname( $LEVEL0 ) {
+        BLAS_$SUBROUTINE( $CALL_C_HEADER );
+    }
+$TEMPLATE[blas_level1]
+// value-type based template
+template< typename ValueType >
+struct $groupname_impl {
+
+    typedef ValueType value_type;
+    typedef typename traits::type_traits<ValueType>::real_type real_type;
+
+    // templated specialization
+    template< $TYPES >
+    static void compute( $LEVEL1 ) {
+#ifndef NDEBUG
+        $ASSERTS
+#endif
+        detail::$groupname( $CALL_LEVEL0 );
+    }
+};
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/bdsdc.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/bdsdc.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,9 @@
+$TEMPLATE[bdsdc.real.min_size_work.args]
+COMPQ, N
+$TEMPLATE[bdsdc.real.min_size_work]
+switch ( compq ) {
+    case 'N': return 4*n;
+    case 'P': return 6*n;
+    case 'I': return 3*n*n + 4*n;
+}
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/bdsqr.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/bdsqr.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,15 @@
+$TEMPLATE[bdsqr.all.min_size_work.args]
+N,NCVT,NRU,NCC
+$TEMPLATE[bdsqr.real.min_size_work]
+if ( ncvt == 0 && nru == 0 && ncc == 0 )
+    return 2*n;
+else
+    return std::max(1, 4*n);
+$TEMPLATE[bdsqr.complex.min_size_rwork.args]
+N,NCVT,NRU,NCC
+$TEMPLATE[bdsqr.complex.min_size_rwork]
+if ( ncvt == 0 && nru == 0 && ncc == 0 )
+    return 2*n;
+else
+    return std::max(1, 4*n-4);
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/gebrd.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/gebrd.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,5 @@
+$TEMPLATE[gebrd.all.min_size_work.args]
+M,N
+$TEMPLATE[gebrd.all.min_size_work]
+return std::max( 1, std::max( m, n ) );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/gelqf.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/gelqf.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,13 @@
+$TEMPLATE[gelqf.all.min_size_work.args]
+M
+$TEMPLATE[gelqf.all.min_size_work]
+return std::max( 1, m );
+$TEMPLATE[geqlf.all.min_size_work.args]
+N
+$TEMPLATE[geqlf.all.min_size_work]
+return std::max( 1, n );
+$TEMPLATE[getri.all.min_size_work.args]
+N
+$TEMPLATE[getri.all.min_size_work]
+return std::max( 1, n );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/hetr.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/hetr.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,7 @@
+$TEMPLATE[hetrd.all.min_size_work.args]
+$TEMPLATE[hetrd.all.min_size_work]
+return 1;
+$TEMPLATE[hetrf.all.min_size_work.args]
+$TEMPLATE[hetrf.all.min_size_work]
+return 1;
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/hgeqz.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/hgeqz.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,5 @@
+$TEMPLATE[hgeqz.all.min_size_work.args]
+N
+$TEMPLATE[hgeqz.all.min_size_work]
+return std::max( 1, n );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/larz.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/larz.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,8 @@
+$TEMPLATE[larz.all.min_size_work.args]
+SIDE,M,N
+$TEMPLATE[larz.all.min_size_work]
+if ( side == 'L' )
+    return n;
+else
+    return m;
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/opmtr.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/opmtr.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,8 @@
+$TEMPLATE[opmtr.all.min_size_work.args]
+SIDE,M,N
+$TEMPLATE[opmtr.all.min_size_work]
+if ( side == 'L' )
+    return n;
+else
+    return m;
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/org.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/org.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,25 @@
+$TEMPLATE[orgbr.all.min_size_work.args]
+M,N
+$TEMPLATE[orgbr.all.min_size_work]
+return std::max( 1, std::min( m, n );
+$TEMPLATE[orglq.all.min_size_work.args]
+M
+$TEMPLATE[orglq.all.min_size_work]
+return std::max( 1, m );
+$TEMPLATE[orgrq.all.min_size_work.args]
+M
+$TEMPLATE[orgrq.all.min_size_work]
+return std::max( 1, m );
+$TEMPLATE[orgql.all.min_size_work.args]
+N
+$TEMPLATE[orgql.all.min_size_work]
+return std::max( 1, n );
+$TEMPLATE[orgqr.all.min_size_work.args]
+N
+$TEMPLATE[orgqr.all.min_size_work]
+return std::max( 1, n );
+$TEMPLATE[orgtr.all.min_size_work.args]
+N
+$TEMPLATE[orgtr.all.min_size_work]
+return std::max( 1, n-1 );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/orm.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/orm.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,50 @@
+$TEMPLATE[ormbr.all.min_size_work.args]
+SIDE,M,N
+$TEMPLATE[ormbr.all.min_size_work]
+if ( side == 'L' )
+    return std::max( 1, n );
+else
+    return std::max( 1, m );
+$TEMPLATE[ormlq.all.min_size_work.args]
+SIDE,M,N
+$TEMPLATE[ormlq.all.min_size_work]
+if ( side == 'L' )
+    return std::max( 1, n );
+else
+    return std::max( 1, m );
+$TEMPLATE[ormqr.all.min_size_work.args]
+SIDE,M,N
+$TEMPLATE[ormqr.all.min_size_work]
+if ( side == 'L' )
+    return std::max( 1, n );
+else
+    return std::max( 1, m );
+$TEMPLATE[ormrq.all.min_size_work.args]
+SIDE,M,N
+$TEMPLATE[ormrq.all.min_size_work]
+if ( side == 'L' )
+    return std::max( 1, n );
+else
+    return std::max( 1, m );
+$TEMPLATE[ormtr.all.min_size_work.args]
+SIDE,M,N
+$TEMPLATE[ormtr.all.min_size_work]
+if ( side == 'L' )
+    return std::max( 1, n );
+else
+    return std::max( 1, m );
+$TEMPLATE[ormql.all.min_size_work.args]
+SIDE,M,N
+$TEMPLATE[ormql.all.min_size_work]
+if ( side == 'L' )
+    return std::max( 1, n );
+else
+    return std::max( 1, m );
+$TEMPLATE[ormhr.all.min_size_work.args]
+SIDE,M,N
+$TEMPLATE[ormhr.all.min_size_work]
+if ( side == 'L' )
+    return std::max( 1, n );
+else
+    return std::max( 1, m );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/stedc.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/stedc.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,5 @@
+$TEMPLATE[stedc.all.min_size_iwork.args]
+COMPZ,N
+$TEMPLATE[stedc.all.min_size_iwork]
+// some formula
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/un.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/computational/un.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,77 @@
+$TEMPLATE[ungbr.all.min_size_work.args]
+M,N
+$TEMPLATE[ungbr.all.min_size_work]
+return std::max( 1, std::min( m, n ) );
+$TEMPLATE[ungql.all.min_size_work.args]
+N
+$TEMPLATE[ungql.all.min_size_work]
+return std::max( 1, n );
+$TEMPLATE[ungqr.all.min_size_work.args]
+N
+$TEMPLATE[ungqr.all.min_size_work]
+return std::max( 1, n );
+$TEMPLATE[unglq.all.min_size_work.args]
+M
+$TEMPLATE[unglq.all.min_size_work]
+return std::max( 1, m );
+$TEMPLATE[ungrq.all.min_size_work.args]
+M
+$TEMPLATE[ungrq.all.min_size_work]
+return std::max( 1, m );
+$TEMPLATE[ungtr.all.min_size_work.args]
+SIDE,M,N
+$TEMPLATE[ungtr.all.min_size_work]
+if ( side == 'L' )
+    return std::max( 1, n );
+else
+    return std::max( 1, m );
+$TEMPLATE[unmbr.all.min_size_work.args]
+SIDE,M,N
+$TEMPLATE[unmbr.all.min_size_work]
+if ( side == 'L' )
+    return std::max( 1, n );
+else
+    return std::max( 1, m );
+$TEMPLATE[unmhr.all.min_size_work.args]
+SIDE,M,N
+$TEMPLATE[unmhr.all.min_size_work]
+if ( side == 'L' )
+    return std::max( 1, n );
+else
+    return std::max( 1, m );
+$TEMPLATE[unmlq.all.min_size_work.args]
+SIDE,M,N
+$TEMPLATE[unmlq.all.min_size_work]
+if ( side == 'L' )
+    return std::max( 1, n );
+else
+    return std::max( 1, m );
+$TEMPLATE[unmqr.all.min_size_work.args]
+SIDE,M,N
+$TEMPLATE[unmqr.all.min_size_work]
+if ( side == 'L' )
+    return std::max( 1, n );
+else
+    return std::max( 1, m );
+$TEMPLATE[unmrq.all.min_size_work.args]
+SIDE,M,N
+$TEMPLATE[unmrq.all.min_size_work]
+if ( side == 'L' )
+    return std::max( 1, n );
+else
+    return std::max( 1, m );
+$TEMPLATE[unmql.all.min_size_work.args]
+SIDE,M,N
+$TEMPLATE[unmql.all.min_size_work]
+if ( side == 'L' )
+    return std::max( 1, n );
+else
+    return std::max( 1, m );
+$TEMPLATE[unmtr.all.min_size_work.args]
+SIDE,M,N
+$TEMPLATE[unmtr.all.min_size_work]
+if ( side == 'L' )
+    return std::max( 1, n );
+else
+    return std::max( 1, m );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/cgesv.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/cgesv.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,5 @@
+$TEMPLATE[cgesv.complex.min_size_work.args]
+N, NRHS
+$TEMPLATE[cgesv.complex.min_size_work]
+return n*nrhs;
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gbsv.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gbsv.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,3 @@
+$TEMPLATE[gbsv.all.N.trait_of]
+AB
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gbsvx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gbsvx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,13 @@
+$TEMPLATE[gbsvx.real.min_size_iwork.args]
+N
+$TEMPLATE[gbsvx.real.min_size_iwork]
+return n;
+$TEMPLATE[gbsvx.real.min_size_work.args]
+N
+$TEMPLATE[gbsvx.real.min_size_work]
+return 3*n;
+$TEMPLATE[gbsvx.complex.min_size_rwork.args]
+N
+$TEMPLATE[gbsvx.complex.min_size_rwork]
+return n;
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gees.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gees.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,16 @@
+$TEMPLATE[gees.real.min_size_work.args]
+N
+$TEMPLATE[gees.real.min_size_work]
+return std::max( 1, 3*n );
+$TEMPLATE[gees.all.min_size_bwork.args]
+N, SORT
+$TEMPLATE[gees.all.min_size_bwork]
+if ( sort == 'N' )
+    return 0;
+else
+    return n;
+$TEMPLATE[gees.complex.min_size_work.args]
+N
+$TEMPLATE[gees.complex.min_size_work]
+return std::max( 1, 2*n );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/geesx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/geesx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,27 @@
+$TEMPLATE[geesx.all.min_size_bwork.args]
+N, SORT
+$TEMPLATE[geesx.all.min_size_bwork]
+if ( sort == 'N' )
+    return 0;
+else
+    return n;
+$TEMPLATE[geesx.real.min_size_iwork.args]
+N, SENSE
+$TEMPLATE[geesx.real.min_size_iwork]
+if ( sense == 'N' || sense == 'E' )
+    return 1;
+else
+    return std::max( 1, n*n/4 );
+$TEMPLATE[geesx.all.min_size_work.args]
+N, SENSE
+$TEMPLATE[geesx.real.min_size_work]
+if ( sense == 'N' )
+    return std::max( 1, 3*n );
+else
+    return std::max( 1, n+n*n/2 );
+$TEMPLATE[geesx.complex.min_size_work]
+if ( sense == 'N' )
+    return std::max( 1, 2*n );
+else
+    return std::max( 1, n*n/2 );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/geev.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/geev.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,12 @@
+$TEMPLATE[geev.real.min_size_work.args]
+JOBVL,JOBVR,N
+$TEMPLATE[geev.real.min_size_work]
+if ( jobvl == 'V' || jobvr == 'V' )
+    return std::max( 1, 4*n );
+else
+    return std::max( 1, 3*n );
+$TEMPLATE[geev.complex.min_size_work.args]
+N
+$TEMPLATE[geev.complex.min_size_work]
+return std::max( 1, 2*n );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/geevx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/geevx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,25 @@
+$TEMPLATE[geevx.real.min_size_iwork.args]
+SENSE,N
+$TEMPLATE[geevx.real.min_size_iwork]
+if ( sense == 'N' || sense == 'E' )
+    return 0;
+else
+    return 2*n-2;
+$TEMPLATE[geevx.real.min_size_work.args]
+SENSE,JOBVL,JOBVR,N
+$TEMPLATE[geevx.real.min_size_work]
+if ( sense == 'N' || sense == 'E' ) {
+    if ( jobvl =='V' || jobvr == 'V' )
+        return std::max( 1, 3*n );
+    else
+        return std::max( 1, 2*n );
+} else
+    return std::max( 1, n*(n+6) );
+$TEMPLATE[geevx.complex.min_size_work.args]
+SENSE,N
+$TEMPLATE[geevx.complex.min_size_work]
+if ( sense == 'N' || sense == 'E' )
+    return std::max( 1, 2*n );
+else
+    return std::max( 1, n*n + 2*n );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gegv.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gegv.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,9 @@
+$TEMPLATE[gegv.real.min_size_work.args]
+N
+$TEMPLATE[gegv.real.min_size_work]
+return std::max( 1, 8*n );
+$TEMPLATE[gegv.complex.min_size_work.args]
+N
+$TEMPLATE[gegv.complex.min_size_work]
+return std::max( 1, 2*n );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gels.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gels.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,6 @@
+$TEMPLATE[gels.all.min_size_work.args]
+M,N,NRHS
+$TEMPLATE[gels.all.min_size_work]
+integer_t minmn = std::min( m, n );
+return std::max( 1, minmn + std::max( minmn, nrhs ) );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gelsd.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gelsd.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,29 @@
+$TEMPLATE[gelsd.includes]
+#include <boost/numeric/bindings/lapack/auxiliary/ilaenv.hpp>
+$TEMPLATE[gelsd.complex.min_size_rwork.args]
+MINMN,SMLSIZ,NLVL,NRHS
+$TEMPLATE[gelsd.all.extra_variables]
+MINMN,SMLSIZ,NLVL
+$TEMPLATE[gelsd.all.MINMN.init]
+integer_t minmn = std::min( traits::matrix_size1(a), traits::matrix_size2(a) );
+$TEMPLATE[gelsd.all.SMLSIZ.init]
+integer_t smlsiz = ilaenv(9, "GELSD", "");
+$TEMPLATE[gelsd.all.NLVL.init]
+integer_t nlvl = static_cast<integer_t>(((std::log(static_cast<real_type>(minmn)) / std::log(static_cast<real_type>(2.))) / (smlsiz+1)) + 1);
+$TEMPLATE[gelsd.complex.min_size_rwork]
+integer_t smlsiz_plus_one = smlsiz + 1;
+return std::max( 1, 10*minmn + 2*minmn*smlsiz + 8*minmn*nlvl + 3*smlsiz*nrhs + smlsiz_plus_one * smlsiz_plus_one );
+$TEMPLATE[gelsd.complex.min_size_work.args]
+MINMN, NRHS
+$TEMPLATE[gelsd.complex.min_size_work]
+return std::max( 1, 2*minmn + minmn*nrhs );
+$TEMPLATE[gelsd.all.min_size_iwork.args]
+MINMN,NLVL
+$TEMPLATE[gelsd.all.min_size_iwork]
+return std::max( 1, 3*minmn*nlvl + 11*minmn );
+$TEMPLATE[gelsd.real.min_size_work.args]
+MINMN,SMLSIZ, NLVL, NRHS
+$TEMPLATE[gelsd.real.min_size_work]
+integer_t smlsiz_plus_one = smlsiz + 1;
+return std::max( 1, 12*minmn + 2*minmn*smlsiz + 8*minmn*nlvl + minmn*nrhs + smlsiz_plus_one * smlsiz_plus_one );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gelss.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gelss.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,20 @@
+$TEMPLATE[gelss.real.min_size_work.args]
+M,N,NRHS
+$TEMPLATE[gelss.real.min_size_work]
+integer_t minmn = std::min( m, n );
+return std::max( 1, 3*minmn + std::max( std::max( 2*minmn, std::max(m,n) ), nrhs ) );
+$TEMPLATE[gelss.complex.extra_variables]
+MINMN
+$TEMPLATE[gelss.complex.extra_opt_variables]
+MINMN
+$TEMPLATE[gelss.complex.MINMN.init]
+integer_t minmn = std::min( traits::matrix_size1(a), traits::matrix_size2(a) );
+$TEMPLATE[gelss.complex.min_size_work.args]
+M,N,NRHS,MINMN
+$TEMPLATE[gelss.complex.min_size_work]
+return std::max( 1, 2*minmn + std::max( std::max( m,n ), nrhs ) );
+$TEMPLATE[gelss.complex.min_size_rwork.args]
+MINMN
+$TEMPLATE[gelss.complex.min_size_rwork]
+return 5*minmn;
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gelsy.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gelsy.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,9 @@
+$TEMPLATE[gelsy.all.min_size_work.args]
+M,N,NRHS
+$TEMPLATE[gelsy.real.min_size_work]
+integer_t minmn = std::min( m, n );
+return std::max( 1, std::max( minmn+3*n+1, 2*minmn+nrhs ));
+$TEMPLATE[gelsy.complex.min_size_work]
+integer_t minmn = std::min( m, n );
+return std::max( 1, std::max( std::max( 2*minmn, n+1 ), minmn+nrhs ) );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gesdd.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gesdd.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,28 @@
+$TEMPLATE[gesdd.all.extra_variables]
+MINMN
+$TEMPLATE[gesdd.all.extra_opt_variables]
+MINMN
+$TEMPLATE[gesdd.all.MINMN.init]
+integer_t minmn = std::min( traits::matrix_size1(a), traits::matrix_size2(a) );
+$TEMPLATE[gesdd.all.min_size_work.args]
+M, N, JOBZ, MINMN
+$TEMPLATE[gesdd.real.min_size_work]
+if ( n == 0 ) return 1;
+if ( jobz == 'N' ) return 3*minmn + std::max( std::max(m,n), 7*minmn );
+if ( jobz == 'O' ) return 3*minmn*minmn + std::max( std::max( m,n ), 5*minmn*minmn + 4*minmn );
+return 3*minmn*minmn + std::max( std::max( m,n ), 4*minmn*minmn + 4*minmn );
+$TEMPLATE[gesdd.complex.min_size_work]
+if ( n == 0 ) return 1;
+if ( jobz == 'N' ) return 2*minmn + std::max( m,n );
+if ( jobz == 'O' ) return 2*(minmn*minmn + minmn) + std::max( m, n );
+return minmn*minmn + 2*minmn + std::max( m, n );
+$TEMPLATE[gesdd.all.min_size_iwork.args]
+MINMN
+$TEMPLATE[gesdd.all.min_size_iwork]
+    return 8*minmn;
+$TEMPLATE[gesdd.complex.min_size_rwork.args]
+MINMN, JOBZ
+$TEMPLATE[gesdd.complex.min_size_rwork]
+if ( jobz == 'N' ) return 5*minmn;
+return 5*minmn*minmn + 7*minmn;
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gesvd.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gesvd.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,20 @@
+$TEMPLATE[gesvd.real.min_size_work.args]
+M,N
+$TEMPLATE[gesvd.real.min_size_work]
+integer_t minmn = std::min( m, n );
+return std::max( 1, std::max( 3*minmn+std::max(m,n), 5*minmn ) );
+$TEMPLATE[gesvd.complex.extra_variables]
+MINMN
+$TEMPLATE[gesvd.complex.extra_opt_variables]
+MINMN
+$TEMPLATE[gesvd.complex.MINMN.init]
+integer_t minmn = std::min( traits::matrix_size1(a), traits::matrix_size2(a) );
+$TEMPLATE[gesvd.complex.min_size_work.args]
+M,N,MINMN
+$TEMPLATE[gesvd.complex.min_size_work]
+return std::max( 1, 2*minmn+std::max(m,n) );
+$TEMPLATE[gesvd.complex.min_size_rwork.args]
+MINMN
+$TEMPLATE[gesvd.complex.min_size_rwork]
+return 5*minmn;
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gesvx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gesvx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,9 @@
+$TEMPLATE[gesvx.real.min_size_work.args]
+N
+$TEMPLATE[gesvx.real.min_size_work]
+return 4*n;
+$TEMPLATE[gesvx.complex.min_size_rwork.args]
+N
+$TEMPLATE[gesvx.complex.min_size_rwork]
+return 2*n;
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gges.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gges.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,14 @@
+$TEMPLATE[gges.all.min_size_work.args]
+N
+$TEMPLATE[gges.real.min_size_work]
+return std::max( 1, 8*n + 16 );
+$TEMPLATE[gges.complex.min_size_work]
+return std::max( 1, 2*n );
+$TEMPLATE[gges.all.min_size_bwork.args]
+N, SORT
+$TEMPLATE[gges.all.min_size_bwork]
+if ( sort == 'N' )
+    return 0;
+else
+    return n;
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/ggesx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/ggesx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,34 @@
+$TEMPLATE[ggesx.all.min_size_iwork.args]
+N, SENSE
+$TEMPLATE[ggesx.real.min_size_iwork]
+if ( sense == 'N' )
+    return 1;
+else
+    return std::max( 1, n+6 );
+$TEMPLATE[ggesx.complex.min_size_iwork]
+if ( sense == 'N' )
+    return 1;
+else
+    return std::max( 1, n+2 );
+$TEMPLATE[ggesx.all.min_size_bwork.args]
+N, SORT
+$TEMPLATE[ggesx.all.min_size_bwork]
+if ( sort == 'N' )
+    return 0;
+else
+    return n;
+$TEMPLATE[ggesx.all.min_size_work.args]
+N, SENSE
+$TEMPLATE[ggesx.real.min_size_work]
+if ( n == 0 )
+    return 1;
+if ( sense == 'N' )
+    return std::max( 8*n, 6*n+16 );
+else
+    return std::max( 8*n, std::max( 6*n+16, n*n/2 ));
+$TEMPLATE[ggesx.complex.min_size_work]
+if ( sense == 'N' )
+    return std::max( 1, 2*n );
+else
+    return std::max( 1, std::max( 2*n, n*n/2 ) );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/ggev.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/ggev.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,9 @@
+$TEMPLATE[ggev.real.min_size_work.args]
+N
+$TEMPLATE[ggev.real.min_size_work]
+return std::max( 1, 8*n );
+$TEMPLATE[ggev.complex.min_size_work.args]
+N
+$TEMPLATE[ggev.complex.min_size_work]
+return std::max( 1, 2*n );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/ggevx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/ggevx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,50 @@
+$TEMPLATE[ggevx.all.min_size_bwork.args]
+SENSE, N
+$TEMPLATE[ggevx.all.min_size_bwork]
+if ( sense == 'N' )
+  return 0;
+else
+  return n;
+$TEMPLATE[ggevx.real.min_size_iwork.args]
+SENSE, N
+$TEMPLATE[ggevx.real.min_size_iwork]
+if ( sense == 'E' )
+  return 0;
+else
+  return n+6;
+$TEMPLATE[ggevx.complex.min_size_iwork.args]
+SENSE, N
+$TEMPLATE[ggevx.complex.min_size_iwork]
+if ( sense == 'E' )
+  return 0;
+else
+  return n+2;
+$TEMPLATE[ggevx.complex.min_size_rwork.args]
+BALANC, N
+$TEMPLATE[ggevx.complex.min_size_rwork]
+if ( balanc == 'S' || balanc == 'B' )
+    return std::max( 1, 6*n );
+else
+    return std::max( 1, 2*n );
+$TEMPLATE[ggevx.real.min_size_work.args]
+BALANC,JOBVL,JOBVR,SENSE,N
+$TEMPLATE[ggevx.real.min_size_work]
+if ( balanc == 'S' || balanc == 'B' || jobvl == 'V' || jobvr == 'V' )
+    return std::max( 1, 6*n );
+if ( sense == 'E' )
+    return std::max( 1, 10*n );
+if ( sense == 'V' || sense == 'B' )
+    return 2*n*n + 8*n + 16;
+return std::max( 1, 2*n );
+$TEMPLATE[ggevx.complex.min_size_work.args]
+SENSE, N
+$TEMPLATE[ggevx.complex.min_size_work]
+if ( sense == 'N' )
+    return std::max( 1, 2*n );
+else {
+    if ( sense == 'E' )
+        return std::max( 1, 4*n );
+    else
+        return std::max( 1, 2*n*n+2*n );
+}
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/ggglm.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/ggglm.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,5 @@
+$TEMPLATE[ggglm.all.min_size_work.args]
+M,N,P
+$TEMPLATE[ggglm.all.min_size_work]
+return std::max( 1, n+m+p );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gglse.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/gglse.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,5 @@
+$TEMPLATE[gglse.all.min_size_work.args]
+M,N,P
+$TEMPLATE[gglse.all.min_size_work]
+return std::max( 1, m+n+p );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hbev.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hbev.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,3 @@
+$TEMPLATE[hbev.all.UPLO.trait_of]
+AB
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hbevd.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hbevd.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,32 @@
+$TEMPLATE[hbevd.complex.min_size_iwork.args]
+JOBZ,N
+$TEMPLATE[hbevd.complex.min_size_iwork]
+if ( jobz == 'N' || n < 2 )
+    return 1;
+else
+    return 3 + 5*n;
+$TEMPLATE[hbevd.complex.min_size_rwork.args]
+JOBZ,N
+$TEMPLATE[hbevd.complex.min_size_rwork]
+if ( n < 2 )
+    return 1;
+else {
+    if ( jobz == 'N' )
+        return n;
+    else
+        return 1 + 5*n + 2*n*n;
+}
+$TEMPLATE[hbevd.complex.min_size_work.args]
+JOBZ,N
+$TEMPLATE[hbevd.complex.min_size_work]
+if ( n < 2 )
+    return 1;
+else {
+    if ( jobz == 'N' )
+        return n;
+    else
+        return 2*n*n;
+}
+$TEMPLATE[hbevd.all.UPLO.trait_of]
+AB
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hbevx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hbevx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,3 @@
+$TEMPLATE[hbevx.all.UPLO.trait_of]
+AB
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hbgv.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hbgv.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,3 @@
+$TEMPLATE[hbgv.all.UPLO.trait_of]
+AB
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hbgvd.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hbgvd.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,32 @@
+$TEMPLATE[hbgvd.complex.min_size_iwork.args]
+JOBZ,N
+$TEMPLATE[hbgvd.complex.min_size_iwork]
+if ( jobz == 'N' || n < 2 )
+    return 1;
+else
+    return 3 + 5*n;
+$TEMPLATE[hbgvd.complex.min_size_rwork.args]
+JOBZ,N
+$TEMPLATE[hbgvd.complex.min_size_rwork]
+if ( n < 2 )
+    return 1;
+else {
+    if ( jobz == 'N' )
+        return n;
+    else
+        return 1 + 5*n + 2*n*n;
+}
+$TEMPLATE[hbgvd.complex.min_size_work.args]
+JOBZ,N
+$TEMPLATE[hbgvd.complex.min_size_work]
+if ( n < 2 )
+    return 1;
+else {
+    if ( jobz == 'N' )
+        return n;
+    else
+        return 2*n*n;
+}
+$TEMPLATE[hbgvd.all.UPLO.trait_of]
+AB
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hbgvx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hbgvx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,3 @@
+$TEMPLATE[hbgvx.all.UPLO.trait_of]
+AB
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/heev.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/heev.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,9 @@
+$TEMPLATE[heev.complex.min_size_rwork.args]
+N
+$TEMPLATE[heev.complex.min_size_rwork]
+return std::max( 1, 3*n-2 );
+$TEMPLATE[heev.complex.min_size_work.args]
+N
+$TEMPLATE[heev.complex.min_size_work]
+return std::max( 1, 2*n-1 );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/heevd.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/heevd.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,30 @@
+$TEMPLATE[heevd.complex.min_size_iwork.args]
+JOBZ,N
+$TEMPLATE[heevd.complex.min_size_iwork]
+if ( jobz == 'N' || n < 2 )
+    return 1;
+else
+    return 3 + 5*n;
+$TEMPLATE[heevd.complex.min_size_rwork.args]
+JOBZ,N
+$TEMPLATE[heevd.complex.min_size_rwork]
+if ( n < 2 )
+    return 1;
+else {
+    if ( jobz == 'N' )
+        return n;
+    else
+        return 1 + 5*n + 2*n*n;
+}
+$TEMPLATE[heevd.complex.min_size_work.args]
+JOBZ,N
+$TEMPLATE[heevd.complex.min_size_work]
+if ( n < 2 )
+    return 1;
+else {
+    if ( jobz == 'N' )
+        return n+1;
+    else
+        return 2*n + n*n;
+}
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/heevr.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/heevr.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,13 @@
+$TEMPLATE[heevr.complex.min_size_work.args]
+N
+$TEMPLATE[heevr.complex.min_size_work]
+return std::max( 1, 2*n );
+$TEMPLATE[heevr.complex.min_size_rwork.args]
+N
+$TEMPLATE[heevr.complex.min_size_rwork]
+return std::max( 1, 24*n );
+$TEMPLATE[heevr.complex.min_size_iwork.args]
+N
+$TEMPLATE[heevr.complex.min_size_iwork]
+return std::max( 1, 10*n );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/heevx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/heevx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,5 @@
+$TEMPLATE[heevx.complex.min_size_work.args]
+N
+$TEMPLATE[heevx.complex.min_size_work]
+return std::max( 1, 2*n );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hegv.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hegv.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,9 @@
+$TEMPLATE[hegv.complex.min_size_rwork.args]
+N
+$TEMPLATE[hegv.complex.min_size_rwork]
+return std::max( 1, 3*n-2 );
+$TEMPLATE[hegv.complex.min_size_work.args]
+N
+$TEMPLATE[hegv.complex.min_size_work]
+return std::max( 1, 2*n-1 );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hegvd.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hegvd.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,30 @@
+$TEMPLATE[hegvd.complex.min_size_iwork.args]
+JOBZ,N
+$TEMPLATE[hegvd.complex.min_size_iwork]
+if ( jobz == 'N' || n < 2 )
+    return 1;
+else
+    return 3 + 5*n;
+$TEMPLATE[hegvd.complex.min_size_rwork.args]
+JOBZ,N
+$TEMPLATE[hegvd.complex.min_size_rwork]
+if ( n < 2 )
+    return 1;
+else {
+    if ( jobz == 'N' )
+        return n;
+    else
+        return 1 + 5*n + 2*n*n;
+}
+$TEMPLATE[hegvd.complex.min_size_work.args]
+JOBZ,N
+$TEMPLATE[hegvd.complex.min_size_work]
+if ( n < 2 )
+    return 1;
+else {
+    if ( jobz == 'N' )
+        return n+1;
+    else
+        return 2*n + n*n;
+}
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hegvx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hegvx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,5 @@
+$TEMPLATE[hegvx.complex.min_size_work.args]
+N
+$TEMPLATE[hegvx.complex.min_size_work]
+return std::max( 1, 2*n );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hesv.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hesv.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,4 @@
+$TEMPLATE[hesv.complex.min_size_work.args]
+$TEMPLATE[hesv.complex.min_size_work]
+return 1;
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hesvx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hesvx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,5 @@
+$TEMPLATE[hesvx.complex.min_size_work.args]
+N
+$TEMPLATE[hesvx.complex.min_size_work]
+return std::max( 1, 2*n );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpev.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpev.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,3 @@
+$TEMPLATE[hpev.all.UPLO.trait_of]
+AP
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpevd.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpevd.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,32 @@
+$TEMPLATE[hpevd.complex.min_size_iwork.args]
+JOBZ,N
+$TEMPLATE[hpevd.complex.min_size_iwork]
+if ( jobz == 'N' || n < 2 )
+    return 1;
+else
+    return 3 + 5*n;
+$TEMPLATE[hpevd.complex.min_size_rwork.args]
+JOBZ,N
+$TEMPLATE[hpevd.complex.min_size_rwork]
+if ( n < 2 )
+    return 1;
+else {
+    if ( jobz == 'N' )
+        return n;
+    else
+        return 1 + 5*n + 2*n*n;
+}
+$TEMPLATE[hpevd.complex.min_size_work.args]
+JOBZ,N
+$TEMPLATE[hpevd.complex.min_size_work]
+if ( n < 2 )
+    return 1;
+else {
+    if ( jobz == 'N' )
+        return n;
+    else
+        return 2*n;
+}
+$TEMPLATE[hpevd.all.UPLO.trait_of]
+AP
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpevx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpevx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,3 @@
+$TEMPLATE[hpevx.all.UPLO.trait_of]
+AP
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpgv.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpgv.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,3 @@
+$TEMPLATE[hpgv.all.UPLO.trait_of]
+AP
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpgvd.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpgvd.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,32 @@
+$TEMPLATE[hpgvd.complex.min_size_iwork.args]
+JOBZ,N
+$TEMPLATE[hpgvd.complex.min_size_iwork]
+if ( jobz == 'N' || n < 2 )
+    return 1;
+else
+    return 3 + 5*n;
+$TEMPLATE[hpgvd.complex.min_size_rwork.args]
+JOBZ,N
+$TEMPLATE[hpgvd.complex.min_size_rwork]
+if ( n < 2 )
+    return 1;
+else {
+    if ( jobz == 'N' )
+        return n;
+    else
+        return 1 + 5*n + 2*n*n;
+}
+$TEMPLATE[hpgvd.complex.min_size_work.args]
+JOBZ,N
+$TEMPLATE[hpgvd.complex.min_size_work]
+if ( n < 2 )
+    return 1;
+else {
+    if ( jobz == 'N' )
+        return n;
+    else
+        return 2*n;
+}
+$TEMPLATE[hpgvd.all.UPLO.trait_of]
+AP
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpgvx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpgvx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,3 @@
+$TEMPLATE[hpgvx.all.UPLO.trait_of]
+AP
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpsv.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpsv.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,5 @@
+$TEMPLATE[hpsv.all.N.trait_of]
+AP
+$TEMPLATE[hpsv.all.UPLO.trait_of]
+AP
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpsvx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/hpsvx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,3 @@
+$TEMPLATE[hpsvx.all.UPLO.trait_of]
+AP
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/lalsd.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/lalsd.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,26 @@
+$TEMPLATE[lalsd.real.min_size_work.args]
+N,SMLSIZ, NLVL, NRHS
+$TEMPLATE[lalsd.real.min_size_work]
+integer_t smlsiz_plus_one = smlsiz + 1;
+return 9*n + 2*n*smlsiz + 8*n*nlvl + n*nrhs + smlsiz_plus_one * smlsiz_plus_one;
+$TEMPLATE[lalsd.real.min_size_iwork.args]
+N,NLVL
+$TEMPLATE[lalsd.real.min_size_iwork]
+return 3*n*nlvl + 11*n;
+$TEMPLATE[lalsd.complex.min_size_rwork.args]
+N,SMLSIZ, NLVL, NRHS
+$TEMPLATE[lalsd.complex.min_size_rwork]
+integer_t smlsiz_plus_one = smlsiz + 1;
+return 9*n + 2*n*smlsiz + 8*n*nlvl + 3*smlsiz*nrhs + smlsiz_plus_one * smlsiz_plus_one;
+$TEMPLATE[lalsd.all.extra_variables]
+NLVL
+$TEMPLATE[lalsd.complex.NLVL.init]
+integer_t nlvl = std::max( 0, static_cast<integer_t>(
+    std::log(static_cast<real_type>(std::min(traits::matrix_size2(b),n))/
+    static_cast<real_type>(smlsiz+1)) /
+    std::log(static_cast<real_type>(2.))) + 1 );
+$TEMPLATE[lalsd.real.NLVL.init]
+integer_t nlvl = std::max( 0, static_cast<integer_t>(
+    std::log(static_cast<real_type>(n)/static_cast<real_type>(smlsiz+1)) /
+    std::log(static_cast<real_type>(2.)) ) + 1 );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/pbsv.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/pbsv.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,5 @@
+$TEMPLATE[pbsv.all.N.trait_of]
+AB
+$TEMPLATE[pbsv.all.UPLO.trait_of]
+AB
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/pbsvx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/pbsvx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,3 @@
+$TEMPLATE[pbsvx.all.UPLO.trait_of]
+AB
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/ppsv.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/ppsv.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,5 @@
+$TEMPLATE[ppsv.all.N.trait_of]
+AP
+$TEMPLATE[ppsv.all.UPLO.trait_of]
+AP
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/ppsvx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/ppsvx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,5 @@
+$TEMPLATE[ppsvx.all.N.trait_of]
+AP
+$TEMPLATE[ppsvx.all.UPLO.trait_of]
+AP
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sbev.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sbev.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,3 @@
+$TEMPLATE[sbev.all.UPLO.trait_of]
+AB
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sbevd.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sbevd.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,21 @@
+$TEMPLATE[sbevd.real.min_size_iwork.args]
+JOBZ,N
+$TEMPLATE[sbevd.real.min_size_iwork]
+if ( jobz == 'N' || n < 2 )
+    return 1;
+else
+    return 3 + 5*n;
+$TEMPLATE[sbevd.real.min_size_work.args]
+JOBZ,N
+$TEMPLATE[sbevd.real.min_size_work]
+if ( n < 2 )
+    return 1;
+else {
+    if ( jobz == 'N' )
+        return 2*n;
+    else
+        return 1 + 5*n + 2*n*n;
+}
+$TEMPLATE[sbevd.all.UPLO.trait_of]
+AB
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sbevx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sbevx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,3 @@
+$TEMPLATE[sbevx.all.UPLO.trait_of]
+AB
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sbgv.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sbgv.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,3 @@
+$TEMPLATE[sbgv.all.UPLO.trait_of]
+AB
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sbgvd.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sbgvd.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,21 @@
+$TEMPLATE[sbgvd.real.min_size_iwork.args]
+JOBZ,N
+$TEMPLATE[sbgvd.real.min_size_iwork]
+if ( jobz == 'N' || n < 2 )
+    return 1;
+else
+    return 3 + 5*n;
+$TEMPLATE[sbgvd.real.min_size_work.args]
+JOBZ,N
+$TEMPLATE[sbgvd.real.min_size_work]
+if ( n < 2 )
+    return 1;
+else {
+    if ( jobz == 'N' )
+        return 3*n;
+    else
+        return 1 + 5*n + 2*n*n;
+}
+$TEMPLATE[sbgvd.all.UPLO.trait_of]
+AB
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sbgvx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sbgvx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,3 @@
+$TEMPLATE[sbgvx.all.UPLO.trait_of]
+AB
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spev.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spev.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,3 @@
+$TEMPLATE[spev.all.UPLO.trait_of]
+AP
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spevd.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spevd.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,21 @@
+$TEMPLATE[spevd.real.min_size_iwork.args]
+JOBZ,N
+$TEMPLATE[spevd.real.min_size_iwork]
+if ( jobz == 'N' || n < 2 )
+    return 1;
+else
+    return 3 + 5*n;
+$TEMPLATE[spevd.real.min_size_work.args]
+JOBZ,N
+$TEMPLATE[spevd.real.min_size_work]
+if ( n < 2 )
+    return 1;
+else {
+    if ( jobz == 'N' )
+        return 2*n;
+    else
+        return 1 + 6*n + n*n;
+}
+$TEMPLATE[spevd.all.UPLO.trait_of]
+AP
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spevx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spevx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,3 @@
+$TEMPLATE[spevx.all.UPLO.trait_of]
+AP
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spgv.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spgv.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,3 @@
+$TEMPLATE[spgv.all.UPLO.trait_of]
+AP
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spgvd.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spgvd.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,21 @@
+$TEMPLATE[spgvd.real.min_size_iwork.args]
+JOBZ,N
+$TEMPLATE[spgvd.real.min_size_iwork]
+if ( jobz == 'N' || n < 2 )
+    return 1;
+else
+    return 3 + 5*n;
+$TEMPLATE[spgvd.real.min_size_work.args]
+JOBZ,N
+$TEMPLATE[spgvd.real.min_size_work]
+if ( n < 2 )
+    return 1;
+else {
+    if ( jobz == 'N' )
+        return 2*n;
+    else
+        return 1 + 6*n + n*n;
+}
+$TEMPLATE[spgvd.all.UPLO.trait_of]
+AP
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spgvx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spgvx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,3 @@
+$TEMPLATE[spgvx.all.UPLO.trait_of]
+AP
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spsv.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spsv.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,5 @@
+$TEMPLATE[spsv.all.N.trait_of]
+AP
+$TEMPLATE[spsv.all.UPLO.trait_of]
+AP
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spsvx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/spsvx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,5 @@
+$TEMPLATE[spsvx.all.N.trait_of]
+AP
+$TEMPLATE[spsvx.all.UPLO.trait_of]
+AP
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/stev.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/stev.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,5 @@
+$TEMPLATE[stev.real.min_size_work.args]
+N
+$TEMPLATE[stev.real.min_size_work]
+return std::max( 1, 2*n-2 );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/stevd.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/stevd.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,15 @@
+$TEMPLATE[stevd.real.min_size_iwork.args]
+JOBZ,N
+$TEMPLATE[stevd.real.min_size_iwork]
+if ( jobz == 'N' || n < 2 )
+    return 1;
+else
+    return 3 + 5*n;
+$TEMPLATE[stevd.real.min_size_work.args]
+JOBZ,N
+$TEMPLATE[stevd.real.min_size_work]
+if ( jobz == 'N' || n < 2 )
+    return 1;
+else
+    return 1 + 4*n + n*n;
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/stevr.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/stevr.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,9 @@
+$TEMPLATE[stevr.real.min_size_work.args]
+N
+$TEMPLATE[stevr.real.min_size_work]
+return std::max( 1, 20*n );
+$TEMPLATE[stevr.real.min_size_iwork.args]
+N
+$TEMPLATE[stevr.real.min_size_iwork]
+return std::max( 1, 10*n );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/syev.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/syev.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,5 @@
+$TEMPLATE[syev.real.min_size_work.args]
+N
+$TEMPLATE[syev.real.min_size_work]
+return std::max( 1, 3*n-1 );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/syevd.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/syevd.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,19 @@
+$TEMPLATE[syevd.real.min_size_iwork.args]
+JOBZ,N
+$TEMPLATE[syevd.real.min_size_iwork]
+if ( jobz == 'N' || n < 2 )
+    return 1;
+else
+    return 3 + 5*n;
+$TEMPLATE[syevd.real.min_size_work.args]
+JOBZ,N
+$TEMPLATE[syevd.real.min_size_work]
+if ( n < 2 )
+    return 1;
+else {
+    if ( jobz == 'N' )
+        return 2*n + 1;
+    else
+        return 1 + 6*n + 2*n*n;
+}
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/syevr.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/syevr.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,9 @@
+$TEMPLATE[syevr.real.min_size_work.args]
+N
+$TEMPLATE[syevr.real.min_size_work]
+return std::max( 1, 26*n );
+$TEMPLATE[syevr.real.min_size_iwork.args]
+N
+$TEMPLATE[syevr.real.min_size_iwork]
+return std::max( 1, 10*n );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/syevx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/syevx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,8 @@
+$TEMPLATE[syevx.real.min_size_work.args]
+N
+$TEMPLATE[syevx.real.min_size_work]
+if ( n < 2 )
+    return 1;
+else
+    return 8*n;
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sygv.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sygv.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,5 @@
+$TEMPLATE[sygv.real.min_size_work.args]
+N
+$TEMPLATE[sygv.real.min_size_work]
+return std::max( 1, 3*n-1 );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sygvd.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sygvd.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,19 @@
+$TEMPLATE[sygvd.real.min_size_iwork.args]
+JOBZ,N
+$TEMPLATE[sygvd.real.min_size_iwork]
+if ( jobz == 'N' || n < 2 )
+    return 1;
+else
+    return 3 + 5*n;
+$TEMPLATE[sygvd.real.min_size_work.args]
+JOBZ,N
+$TEMPLATE[sygvd.real.min_size_work]
+if ( n < 2 )
+    return 1;
+else {
+    if ( jobz == 'N' )
+        return 2*n + 1;
+    else
+        return 1 + 6*n + 2*n*n;
+}
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sygvx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sygvx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,5 @@
+$TEMPLATE[sygvx.real.min_size_work.args]
+N
+$TEMPLATE[sygvx.real.min_size_work]
+return std::max( 1, 8*n );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sysv.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sysv.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,4 @@
+$TEMPLATE[sysv.all.min_size_work.args]
+$TEMPLATE[sysv.all.min_size_work]
+return 1;
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sysvx.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/driver/sysvx.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,9 @@
+$TEMPLATE[sysvx.real.min_size_work.args]
+N
+$TEMPLATE[sysvx.real.min_size_work]
+return std::max( 1, 3*n );
+$TEMPLATE[sysvx.complex.min_size_work.args]
+N
+$TEMPLATE[sysvx.complex.min_size_work]
+return std::max( 1, 2*n );
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/lapack.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/lapack.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,137 @@
+$TEMPLATE[lapack.hpp]
+//
+// Copyright (c) 2003--2009
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_$GROUPNAME_HPP
+#define BOOST_NUMERIC_BINDINGS_LAPACK_$GROUPNAME_HPP
+
+$INCLUDES
+
+namespace boost {
+namespace numeric {
+namespace bindings {
+namespace lapack {
+
+//$DESCRIPTION
+
+// overloaded functions to call lapack
+namespace detail {
+$OVERLOADS}
+
+$LEVEL1
+$LEVEL2
+}}}} // namespace boost::numeric::bindings::lapack
+
+#endif
+$TEMPLATE[lapack_overloads]
+    inline void $groupname( $LEVEL0 ) {
+        LAPACK_$SUBROUTINE( $CALL_C_HEADER );
+    }
+$TEMPLATE[level1_pre_header]
+// value-type based template
+template< typename ValueType, typename Enable = void >
+struct $groupname_impl{};
+
+$TEMPLATE[level1_header1]
+// value-type based template
+template< typename ValueType >
+struct $groupname_impl {
+
+$TEMPLATE[level1_header2]
+// $SPECIALIZATION specialization
+template< typename ValueType >
+struct $groupname_impl< ValueType, typename boost::enable_if< traits::is_$SPECIALIZATION<ValueType> >::type > {
+
+$TEMPLATE[level1_workspace]
+    typedef ValueType value_type;
+    typedef typename traits::type_traits<ValueType>::real_type real_type;
+
+    // user-defined workspace specialization
+    template< $TYPES, $WORKSPACE_TYPENAMES >
+    static void compute( $LEVEL1, detail::workspace$WORKSPACE_SIZE< $WORKSPACE_TYPES > work ) {
+#ifndef NDEBUG
+        $INIT_USER_DEFINED_VARIABLES
+        $ASSERTS
+#endif
+        detail::$groupname( $CALL_LEVEL0 );
+    }
+
+    // minimal workspace specialization
+    template< $TYPES >
+    static void compute( $LEVEL1, minimal_workspace work ) {
+        $INIT_USER_DEFINED_VARIABLES
+$SETUP_MIN_WORKARRAYS_POST
+        compute( $CALL_LEVEL1, workspace( $TMP_WORKARRAYS ) );
+    }
+
+    // optimal workspace specialization
+    template< $TYPES >
+    static void compute( $LEVEL1, optimal_workspace work ) {
+$OPT_WORKSPACE_FUNC
+    }
+
+$MIN_SIZE_FUNCS
+};
+
+$TEMPLATE[level1_opt_workspace]
+        $INIT_USER_DEFINED_OPT_VARIABLES
+        $SETUP_OPT_WORKARRAYS_PRE
+        detail::$groupname( $WORKSPACE_QUERY );
+        $SETUP_OPT_WORKARRAYS_POST
+        compute( $CALL_LEVEL1, workspace( $TMP_WORKARRAYS ) );
+$TEMPLATE[level1_opt_workspace_is_min]
+        compute( $CALL_LEVEL1, minimal_workspace() );
+$TEMPLATE[level2_workspace]
+// template function to call $groupname
+template< $TYPES, typename Workspace >
+inline integer_t $groupname( $LEVEL2, Workspace work = optimal_workspace() ) {
+    typedef typename traits::$TYPEOF_FIRST_TYPENAME_traits< $FIRST_TYPENAME >::value_type value_type;
+    integer_t info(0);
+    $groupname_impl< value_type >::compute( $CALL_LEVEL1, work );
+    return info;
+}
+
+$TEMPLATE[setup_min_workspace]
+        traits::detail::array< $WORKSPACE_TYPE > tmp_$NAME( min_size_$NAME( $CALL_MIN_SIZE ) );
+$TEMPLATE[setup_opt_workspace]
+        traits::detail::array< $WORKSPACE_TYPE > tmp_$NAME( $TMP_SIZE );
+$TEMPLATE[min_size_func]
+    static integer_t min_size_$NAME( $ARGUMENTS ) {
+        $MIN_SIZE
+    }
+
+$TEMPLATE[level1_noworkspace]
+    typedef ValueType value_type;
+    typedef typename traits::type_traits<ValueType>::real_type real_type;
+
+    // templated specialization
+    template< $TYPES >
+    static void compute( $LEVEL1 ) {
+#ifndef NDEBUG
+        $ASSERTS
+#endif
+        detail::$groupname( $CALL_LEVEL0 );
+    }
+};
+
+$TEMPLATE[level2_noworkspace]
+// template function to call $groupname
+template< $TYPES >
+inline integer_t $groupname( $LEVEL2 ) {
+    typedef typename traits::$TYPEOF_FIRST_TYPENAME_traits< $FIRST_TYPENAME >::value_type value_type;
+    integer_t info(0);
+    $groupname_impl< value_type >::compute( $CALL_LEVEL1 );
+    return info;
+}
+
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/singleton_blas.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/singleton_blas.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,56 @@
+$TEMPLATE[blas.h]
+//
+// Copyright (c) 2003--2009
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_BLAS_BLAS_H
+#define BOOST_NUMERIC_BINDINGS_BLAS_BLAS_H
+
+#include <boost/numeric/bindings/traits/type.h>
+#include <boost/numeric/bindings/blas/blas_names.h>
+
+extern "C" {
+
+$CONTENT
+
+}
+
+#endif
+
+$TEMPLATE[blas.h_function]
+    void BLAS_$SUBROUTINE( $ARGUMENTS );
+$TEMPLATE[blas_names.h]
+//
+// Copyright (c) 2003--2009
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_BLAS_BLAS_NAMES_H
+#define BOOST_NUMERIC_BINDINGS_BLAS_BLAS_NAMES_H
+
+#include <boost/numeric/bindings/traits/fortran.h>
+
+$CONTENT
+
+#endif
+
+$TEMPLATE[blas_names.h_function]
+#define BLAS_$SUBROUTINE FORTRAN_ID( $subroutine )
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/singleton_lapack.hpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/singleton_lapack.hpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,66 @@
+$TEMPLATE[lapack.h]
+//
+// Copyright (c) 2003--2009
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_LAPACK_H
+#define BOOST_NUMERIC_BINDINGS_LAPACK_LAPACK_H
+
+#include <boost/numeric/bindings/traits/type.h>
+#include <boost/numeric/bindings/lapack/lapack_names.h>
+
+#ifndef BOOST_NUMERIC_BINDINGS_NO_STRUCTURE_CHECK 
+#  define BOOST_NUMERIC_BINDINGS_FORTRAN
+#endif 
+
+extern "C" {
+
+$CONTENT
+
+    int LAPACK_ILAENV(int const* ispec, const char* name, const char* opt,
+        int const* n1, int const* n2, int const* n3, int const* n4, int, int);
+}
+
+#endif
+
+$TEMPLATE[lapack.h_function]
+    void LAPACK_$SUBROUTINE( $ARGUMENTS );
+$TEMPLATE[lapack_names.h]
+//
+// Copyright (c) 2003--2009
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#ifndef BOOST_NUMERIC_BINDINGS_LAPACK_LAPACK_NAMES_H
+#define BOOST_NUMERIC_BINDINGS_LAPACK_LAPACK_NAMES_H
+
+#ifndef BOOST_NUMERIC_BINDINGS_USE_CLAPACK
+#  include <boost/numeric/bindings/traits/fortran.h>
+#else
+#  define FORTRAN_ID( id ) id##_
+#endif
+
+$CONTENT
+
+#endif
+
+$TEMPLATE[lapack_names.h_function]
+#define LAPACK_$SUBROUTINE FORTRAN_ID( $subroutine )
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/test/CMakeLists.txt
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/test/CMakeLists.txt	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,23 @@
+$TEMPLATE[CMakeLists.txt]
+#
+# Copyright (c) 2009 by Rutger ter Borg
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+#
+# THIS FILE IS AUTOMATICALLY GENERATED
+# PLEASE DO NOT EDIT!
+#
+
+enable_language( Fortran )
+find_package( LAPACK REQUIRED )
+
+#include_directories( . )
+
+$ENTRIES
+
+$TEMPLATE[CMakeLists.entry]
+add_executable( $groupname $groupname.cpp )
+target_link_libraries( $groupname ${LAPACK_LIBRARIES} )
+$TEMPLATE[end]

Added: sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/test/test_case.cpp
==============================================================================
--- (empty file)
+++ sandbox/numeric_bindings/libs/numeric/bindings/tools/templates/test/test_case.cpp	2009-02-11 09:01:46 EST (Wed, 11 Feb 2009)
@@ -0,0 +1,32 @@
+$TEMPLATE[test_case.cpp]
+//
+// Copyright (c) 2003--2009
+// Toon Knapen, Karl Meerbergen, Kresimir Fresl,
+// Thomas Klimpel and Rutger ter Borg
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// THIS FILE IS AUTOMATICALLY GENERATED
+// PLEASE DO NOT EDIT!
+//
+
+#include <cstdlib>
+#include <boost/numeric/bindings/lapack/$levelname/$groupname.hpp>
+
+int main(int argc, char *argv[]) {
+
+
+
+
+
+
+
+
+
+
+    return EXIT_SUCCESS;
+}
+
+$TEMPLATE[end]