update

include/amscppnarray/amscppnarray.hpp

@@ -4,17 +4,53 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>
+#include <vector>
 #include <new>
 #include <initializer_list>
+#include <thread>
 
 namespace ams
 {
 namespace narray
 {
 
+typedef int64_t narray_size_t;
+
+static const int narray_success = 1;
+static const int narray_failure = -1;
+
+//problem size at which to begin using threaded operations
+static const narray_size_t narray_thread_sz = 5000;
+
+//maximum number of threads to use
+static const int narray_max_threads = 50;
+
 template<typename T> class narray
 {
     public:
+    narray_size_t length;
+    T *data;
+
+    narray();
+    narray(const narray<T>& other);
+    narray<T>& operator=(const narray<T>& other);
+    narray<T>& operator=(const std::vector<T>& other);
+    narray(const std::initializer_list<T> initlist);
+    ~narray();
+
+    int resize(const narray_size_t newlength);
+
+    T& operator[](const narray_size_t ind);
+    const T& operator[](const narray_size_t ind) const;
+    T& at(const narray_size_t ind);
+    const T& at(const narray_size_t ind) const;
+
+    void clear(); //erases all elements, sets size to 0
+    void setall(const T& val); //sets all elements to val
+
+    //Comparators
+
+    //Operations
 
 };
 

include/amscppnarray/amscppnarray_impl.hpp

@@ -6,7 +6,196 @@ namespace ams
 namespace narray
 {
 
+template<typename T> narray<T>::narray()
+{
+    length = 0;
+    data = NULL;
+
+    return;
+}
+
+template<typename T> int narray<T>::resize(const narray_size_t newlength)
+{
+    int ret = narray_failure;
+    narray_size_t I;
+    T *newdata = NULL;
+
+    if(newlength<=0)
+    {
+        if(data!=NULL) {delete[] data; data=NULL;}
+        length = 0;
+        ret = narray_success;
+        return ret;
+    }
+
+    newdata = new(std::nothrow) T[newlength];
+    if(newdata==NULL)
+    {
+        ret = narray_failure;
+        return ret;
+    }
+
+    for(I=0;I<length&I<newlength;I++)
+    {
+        newdata[I] = data[I];
+    }
+    for(I=length;I<newlength;I++)
+    {
+        newdata[I] = T();
+    }
+
+    if(data!=NULL) {delete[] data; data=NULL;}
+    data = newdata;
+    length = newlength;
+    ret = narray_success;
+
+    return ret;
+}
+
+template<typename T> narray<T>::narray(const narray<T>& other)
+{
+    narray_size_t I;
+    int res;
+    length = 0;
+    data = NULL;
+
+    if(this!=&other)
+    {
+        res = this->resize(other.length);
+        if(res!=narray_success)
+        {
+            return;
+        }
+        else
+        {
+            for(I=0;I<length && I<other.length;I++)
+            {
+                data[I] = other.data[I];
+            }
+        }
+    }
+}
+
+
+template<typename T> narray<T>& narray<T>::operator=(const narray<T>& other)
+{
+    narray_size_t I;
+    int res;
+
+    if(this!=&other)
+    {
+        res = this->resize(other.length);
+        if(res!=narray_success)
+        {
+            return *this;
+        }
+        else
+        {
+            for(I=0;I<length && I<other.length;I++)
+            {
+                data[I] = other.data[I];
+            }
+        }
+    }
+    return *this;
+}
+
+template<typename T> narray<T>& narray<T>::operator=(const std::vector<T>& other)
+{
+    narray_size_t I;
+    int res;
+
+    if(this!=&other)
+    {
+        res = this->resize(other.size());
+        if(res!=narray_success)
+        {
+            return *this;
+        }
+        else
+        {
+            for(I=0;I<length && I<other.size();I++)
+            {
+                data[I] = other.data[I];
+            }
+        }
+    }
+    return *this;
+}
+
+template<typename T> narray<T>::narray(const std::initializer_list<T> initlist)
+{
+    narray_size_t I;
+    int res;
+    length = 0;
+    data = NULL;
+
+    res = this->resize(initlist.size());
+    if(res!=narray_success)
+    {
+        return;
+    }
+    else
+    {
+        I = 0;
+        for(T elem : initlist)
+        {
+            data[I] = elem;
+            if(I<length) I++;
+        }
+    }
+}
+
+template<typename T> narray<T>::~narray()
+{
+    length = 0;
+    if(data!=NULL) {delete[] data; data=NULL;}
+    return;
+}
+
+template<typename T> T& narray<T>::operator[](const narray_size_t ind)
+{
+    return data[ind];
+}
+
+template<typename T> const T& narray<T>::operator[](const narray_size_t ind) const
+{
+    return data[ind];
+}
+
+template<typename T> T& narray<T>::at(const narray_size_t ind)
+{
+    return data[ind];
+}
+
+template<typename T> const T& narray<T>::at(const narray_size_t ind) const
+{
+    return data[ind];
+}
+
+template<typename T> void narray<T>::clear()
+{
+    this->resize(0);
+    return;
+}
+
+template<typename T> void narray<T>::setall(const T& val)
+{
+    narray_size_t I;
+    int nthreads;
 
+    if(length<narray_thread_sz)
+    {
+        for(I=0;I<length;I++) data[I] = val;
+    }
+    else
+    {
+        //threaded operation
+        nthreads = std::thread::hardware_concurrency;
+        
+    }
+    return;
+}
 
 
 }; //end namespace narray

src/amscppnarray/amscppnarray.cpp

@@ -7,7 +7,7 @@ namespace narray
 
 void test_narray1()
 {
-
+    
     return;
 }