1 files changed, 327 insertions, 0 deletions
diff --git a/samples/lu/lumat.cpp b/samples/lu/lumat.cpp
new file mode 100644
index 0000000..465c306
--- /dev/null
+++ b/samples/lu/lumat.cpp
@@ -0,0 +1,327 @@
+#include "soapH.h"
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//  vector
+//
+////////////////////////////////////////////////////////////////////////////////
+
+vector::vector()
+{ vector(NULL);
+}
+
+vector::vector(struct soap *env)
+{ soap = env;
+  __ptr = 0;
+  __size = 0;
+  __offset = 0;
+}
+
+vector::vector(struct soap *env, int size)
+{ soap = env;
+  __size = size;
+  __offset = 1;
+  __ptr = (double*)soap_malloc(soap, size*sizeof(double));
+  for (int i = 0; i < size; i++)
+    __ptr[i] = 0.0;
+}
+
+vector::vector(struct soap *env, int start, int end)
+{ soap = env;
+  __size = end-start+1;
+  __offset = start;
+  __ptr = (double*)soap_malloc(soap, __size*sizeof(double));
+  for (int i = 0; i < __size; i++)
+    __ptr[i] = 0.0;
+}
+
+vector::~vector()
+{	// no deallocation: let gSOAP handle all dynamic allocation and deallocation
+}
+
+int vector::start()
+{ return __offset;
+}
+
+int vector::end()
+{ return __size+__offset-1;
+}
+
+int vector::size()
+{ return __size;
+}
+
+void vector::resize(int size)
+{ resize(1, size);
+}
+
+void vector::resize(int start, int end)
+{ double *p;
+  int n, size = end-start+1;
+  if (__offset == start && __size == size)
+    return; // nothing to do
+  p = (double*)soap_malloc(soap, size*sizeof(double));
+  for (int i = 0; i < size; i++)
+    p[i] = 0.0;
+  if (__ptr)
+  { if (start < __offset)
+    { n = (size-__offset+start <= __size ? size-__offset+start : __size);
+      for (int i = 0; i < n; i++)
+        p[__offset-start+i] = __ptr[i];
+    }
+    else
+    { n = (__size-start+__offset <= size ? __size-start+__offset : size);
+      for (int i = 0; i < n; i++)
+        p[i] = __ptr[start-__offset+i];
+    }
+    soap_dealloc(soap, __ptr);
+  }
+  __ptr = p;
+  __size = size;
+  __offset = start;
+}
+
+double& vector::operator[](int i)
+{ return __ptr[i-__offset];
+}
+
+double vector::operator()(int i)
+{ if (i >= __offset && i < __size+__offset)
+    return __ptr[i-__offset];
+  return 0.0;
+}
+
+void vector::print()
+{ int i;
+  for (i = 1; i <= end(); i++)
+    printf("%f ", (*this)(i));
+  printf("\n");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//  ivector
+//
+////////////////////////////////////////////////////////////////////////////////
+
+ivector::ivector()
+{ ivector(NULL);
+}
+
+ivector::ivector(struct soap *env)
+{ soap = env;
+  __ptr = 0;
+  __size = 0;
+}
+
+ivector::ivector(struct soap *env, int size)
+{ soap = env;
+  __size = size;
+  __offset = 1;
+  __ptr = (int*)soap_malloc(soap, size*sizeof(int));
+  for (int i = 0; i < size; i++)
+    __ptr[i] = 0;
+}
+
+ivector::ivector(struct soap *env, int start, int end)
+{ soap = env;
+  __size = end-start+1;
+  __offset = start;
+  __ptr = (int*)soap_malloc(soap, __size*sizeof(int));
+  for (int i = 0; i < __size; i++)
+    __ptr[i] = 0;
+}
+
+ivector::~ivector()
+{	// no deallocation: let gSOAP handle all dynamic allocation and deallocation
+}
+
+int ivector::start()
+{ return __offset;
+}
+
+int ivector::end()
+{ return __size+__offset-1;
+}
+
+int ivector::size()
+{ return __size;
+}
+
+void ivector::resize(int size)
+{ resize(1, size);
+}
+
+void ivector::resize(int start, int end)
+{ int *p;
+  int n, size = end-start+1;
+  if (__offset == start && __size == size)
+    return; // nothing to do
+  p = (int*)soap_malloc(soap, size*sizeof(int));
+  for (int i = 0; i < size; i++)
+    p[i] = 0;
+  if (__ptr)
+  { if (start < __offset)
+    { n = (size-__offset+start <= __size ? size-__offset+start : __size);
+      for (int i = 0; i < n; i++)
+        p[__offset-start+i] = __ptr[i];
+    }
+    else
+    { n = (__size-start+__offset <= size ? __size-start+__offset : size);
+      for (int i = 0; i < n; i++)
+        p[i] = __ptr[start-__offset+i];
+    }
+    soap_dealloc(soap, __ptr);
+  }
+  __ptr = p;
+  __size = size;
+  __offset = start;
+}
+
+int& ivector::operator[](int i)
+{ return __ptr[i-__offset];
+}
+
+int ivector::operator()(int i)
+{ if (i >= __offset && i < __size+__offset)
+    return __ptr[i-__offset];
+  return 0;
+}
+
+void ivector::print()
+{ int i;
+  for (i = 1; i <= end(); i++)
+    printf("%4d ", (*this)(i));
+  printf("\n");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+//  matrix
+//
+////////////////////////////////////////////////////////////////////////////////
+
+matrix::matrix()
+{ matrix(NULL);
+}
+
+matrix::matrix(struct soap *env)
+{ soap = env;
+  __ptr = 0;
+  __size = 0;
+  __offset = 0;
+}
+
+matrix::matrix(struct soap *env, int rows)
+{ soap = env;
+  __ptr = soap_new_vector(soap, rows);
+  __size = rows;
+  __offset = 1;
+}
+
+matrix::matrix(struct soap *env, int rows, int cols)
+{ soap = env;
+  __size = rows;
+  __offset = 1;
+  __ptr = soap_new_vector(soap, __size);
+  for (int i = 0; i < __size; i++)
+    __ptr[i].resize(cols);
+}
+
+matrix::matrix(struct soap *env, int rowstart, int rowend, int colstart, int colend)
+{ soap = env;
+  __size = rowend-rowstart+1;
+  __offset = rowstart;
+  __ptr = soap_new_vector(soap, __size);
+  for (int i = 0; i <= __size-__offset; i++)
+    __ptr[i].resize(colstart, colend);
+}
+
+matrix::~matrix()
+{ 	// no deallocation: let gSOAP handle all dynamic allocation and deallocation
+}
+
+int matrix::start()
+{ return __offset;
+}
+
+int matrix::end()
+{ return __size+__offset-1;
+}
+
+int matrix::size()
+{ return __size;
+}
+
+void matrix::resize(int rows, int cols)
+{ resize(1, rows, 1, cols);
+}
+
+void matrix::resize(int rowstart, int rowend, int colstart, int colend)
+{ int i;
+  vector *p;
+  int n, size = rowend-rowstart+1;
+  if (__offset != rowstart || __size != rowend-rowstart+1)
+  { if (__ptr)
+    { p = soap_new_vector(soap, size);
+      if (rowstart < __offset)
+      { for (i = 0; i < __offset-rowstart; i++)
+          p[i].resize(colstart, colend);
+        n = (size-__offset+rowstart <= __size ? size-__offset+rowstart : __size);
+        for (i = 0; i < n; i++)
+        { __ptr[i].resize(colstart, colend);
+          p[__offset-rowstart+i] = __ptr[i];
+        }
+	for (; i < size-__offset+rowstart; i++)
+	  p[i].resize(colstart, colend);
+      }
+      else
+      { n = (__size-rowstart+__offset <= size ? __size-rowstart+__offset : size);
+        for (i = 0; i < n; i++)
+        { __ptr[i].resize(colstart, colend);
+          p[i] = __ptr[rowstart-__offset+i];
+        }
+        for (; i < size; i++)
+          p[i].resize(colstart, colend);
+      }
+      __ptr = p;
+      __size = size;
+      __offset = rowstart;
+    }
+    else
+    { __size = size;
+      __offset = rowstart;
+      __ptr = soap_new_vector(soap, size);
+      for (i = 0; i < size; i++)
+        __ptr[i].resize(colstart, colend);
+    }
+  }
+  else
+    for (i = 0; i < size; i++)
+      __ptr[i].resize(colstart, colend);
+}
+
+vector& matrix::operator[](int i)
+{ return __ptr[i-__offset];
+}
+
+double matrix::operator()(int i, int j)
+{ int s;
+  if (i >= __offset && i < __size+__offset)
+  { s = __ptr[i-__offset].__offset;
+    if (j >= s && j < __ptr[i-__offset].__size+s)
+      return __ptr[i-__offset].__ptr[j-s];
+  }
+  return 0.0;
+}
+
+void matrix::print()
+{ int i, j;
+  for (i = start(); i <= end(); i++)
+  { for (j = 1; j < (*this)[i].start(); j++)
+      printf("-------- ");
+    for (; j <= (*this)[i].end(); j++)
+      printf("%f ", (*this)(i, j));
+    printf("\n");
+  }
+}