From 3b012a8086d550433188cebbf95746d2455f0b6f Mon Sep 17 00:00:00 2001
From: David Mayerich <mayerich@illinois.edu>
Date: Thu, 15 May 2014 12:17:37 -0500
Subject: [PATCH] added code for command-line arguments

---
 math/complex.h          |  84 +++++++++++++++++++++++++++++++++++++++++++++++++-----------------------------------
 math/quad.h             |   2 +-
 math/spherical_bessel.h |  22 +++++++++++-----------
 optics/material.h       |   4 +++-
 tools/arguments.h       | 416 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 480 insertions(+), 48 deletions(-)
 create mode 100644 tools/arguments.h

diff --git a/math/complex.h b/math/complex.h
index afc79af..4fca324 100644
--- a/math/complex.h
+++ b/math/complex.h
@@ -143,8 +143,8 @@ struct complex
     }
     CUDA_CALLABLE complex<T> & operator=(const T &rhs)
     {
-        this->r = rhs;
-        this->i = 0;
+        	this->r = rhs;
+        	this->i = 0;
 
 		return *this;
     }
@@ -153,34 +153,34 @@ struct complex
     CUDA_CALLABLE complex<T> operator+=(const complex<T> &rhs)
     {
 		*this = *this + rhs;
-        return *this;
+        	return *this;
     }
     CUDA_CALLABLE complex<T> operator+=(const T &rhs)
     {
 		*this = *this + rhs;
-        return *this;
+        	return *this;
     }
 
     CUDA_CALLABLE complex<T> operator*=(const complex<T> &rhs)
     {
 		*this = *this * rhs;
-        return *this;
+        	return *this;
     }
 	CUDA_CALLABLE complex<T> operator*=(const T &rhs)
     {
 		*this = *this * rhs;
-        return *this;
+        	return *this;
     }
 	//divide and assign
 	CUDA_CALLABLE complex<T> operator/=(const complex<T> &rhs)
     {
 		*this = *this / rhs;
-        return *this;
+        	return *this;
     }
     CUDA_CALLABLE complex<T> operator/=(const T &rhs)
     {
 		*this = *this / rhs;
-        return *this;
+        	return *this;
     }
 
     //absolute value operator (returns the absolute value of the complex number)
@@ -191,23 +191,23 @@ struct complex
 
 	CUDA_CALLABLE complex<T> log()
 	{
-        complex<T> result;
-        result.r = std::log(std::sqrt(r * r + i * i));
-        result.i = std::atan2(i, r);
+		complex<T> result;
+		result.r = (T)std::log(std::sqrt(r * r + i * i));
+		result.i = (T)std::atan2(i, r);
 
 
-        return result;
+		return result;
 	}
 
 	CUDA_CALLABLE complex<T> exp()
 	{
-        complex<T> result;
+		complex<T> result;
 
-        T e_r = std::exp(r);
-        result.r = e_r * std::cos(i);
-        result.i = e_r * std::sin(i);
+		T e_r = std::exp(r);
+		result.r = e_r * (T)std::cos(i);
+		result.i = e_r * (T)std::sin(i);
 
-        return result;
+		return result;
 	}
 
 	/*CUDA_CALLABLE complex<T> pow(int y)
@@ -218,11 +218,11 @@ struct complex
 
 	CUDA_CALLABLE complex<T> pow(T y)
 	{
-        complex<T> result;
+		complex<T> result;
 
-        result = log() * y;
+		result = (T)log() * y;
 
-        return result.exp();
+		return result.exp();
 	}
 
 	CUDA_CALLABLE complex<T> sqrt()
@@ -275,14 +275,14 @@ struct complex
 template<typename T>
 CUDA_CALLABLE static rts::complex<T> operator+(const double a, const rts::complex<T> b)
 {
-    return rts::complex<T>(a + b.r, b.i);
+    return rts::complex<T>((T)a + b.r, b.i);
 }
 
 //subtraction with a real value
 template<typename T>
 CUDA_CALLABLE static rts::complex<T> operator-(const double a, const rts::complex<T> b)
 {
-    return rts::complex<T>(a - b.r, -b.i);
+    return rts::complex<T>((T)a - b.r, -b.i);
 }
 
 //minus sign
@@ -303,23 +303,16 @@ CUDA_CALLABLE static rts::complex<T> operator*(const double a, const rts::comple
 template<typename T>
 CUDA_CALLABLE static rts::complex<T> operator/(const double a, const rts::complex<T> b)
 {
-    //return complex<T>(a * b.r, a * b.i);
     rts::complex<T> result;
 
     T denom = b.r * b.r + b.i * b.i;
 
-    result.r = (a * b.r) / denom;
-    result.i = -(a * b.i) / denom;
+    result.r = ((T)a * b.r) / denom;
+    result.i = -((T)a * b.i) / denom;
 
     return result;
 }
 
-//POW function
-/*template<typename T>
-CUDA_CALLABLE static complex<T> pow(complex<T> x, int y)
-{
-	return x.pow(y);
-}*/
 
 template<typename T>
 CUDA_CALLABLE static rts::complex<T> pow(rts::complex<T> x, T y)
@@ -374,22 +367,43 @@ CUDA_CALLABLE static T imag(rts::complex<T> a)
 }
 
 //trigonometric functions
+//template<class A>
+/*CUDA_CALLABLE static rts::complex<float> sinf(const rts::complex<float> x)
+{
+	rts::complex<float> result;
+	result.r = sinf(x.r) * coshf(x.i);
+	result.i = cosf(x.r) * sinhf(x.i);
+
+	return result;
+}*/
+
 template<class A>
 CUDA_CALLABLE rts::complex<A> sin(const rts::complex<A> x)
 {
 	rts::complex<A> result;
-	result.r = std::sin(x.r) * std::cosh(x.i);
-	result.i = std::cos(x.r) * std::sinh(x.i);
+	result.r = (A)std::sin(x.r) * (A)std::cosh(x.i);
+	result.i = (A)std::cos(x.r) * (A)std::sinh(x.i);
 
 	return result;
 }
 
+//floating point template
+//template<class A>
+/*CUDA_CALLABLE static rts::complex<float> cosf(const rts::complex<float> x)
+{
+	rts::complex<float> result;
+	result.r = cosf(x.r) * coshf(x.i);
+	result.i = -(sinf(x.r) * sinhf(x.i));
+
+	return result;
+}*/
+
 template<class A>
 CUDA_CALLABLE rts::complex<A> cos(const rts::complex<A> x)
 {
 	rts::complex<A> result;
-	result.r = std::cos(x.r) * std::cosh(x.i);
-	result.i = -(std::sin(x.r) * std::sinh(x.i));
+	result.r = (A)std::cos(x.r) * (A)std::cosh(x.i);
+	result.i = -((A)std::sin(x.r) * (A)std::sinh(x.i));
 
 	return result;
 }
diff --git a/math/quad.h b/math/quad.h
index 8564500..ec24058 100644
--- a/math/quad.h
+++ b/math/quad.h
@@ -192,7 +192,7 @@ struct quad
         T dc = (A+Y - p).len();
         T dd = (A+X+Y - p).len();
 
-        return fmax( da, fmax(db, fmax(dc, dd) ) );
+        return std::max( da, std::max(db, std::max(dc, dd) ) );
 	}
 };
 
diff --git a/math/spherical_bessel.h b/math/spherical_bessel.h
index b052d7d..2aece36 100644
--- a/math/spherical_bessel.h
+++ b/math/spherical_bessel.h
@@ -5,20 +5,20 @@
 
 namespace rts{
 
-#define RTS_BESSEL_CONVERGENCE_MIN		0.0145
-#define RTS_BESSEL_CONVERGENCE_MAX		0.4
-#define RTS_BESSEL_MAXIMUM_FLOAT		-1e33
+#define RTS_BESSEL_CONVERGENCE_MIN		0.0145f
+#define RTS_BESSEL_CONVERGENCE_MAX		0.4f
+#define RTS_BESSEL_MAXIMUM_FLOAT		-1e33f
 
 template <typename T>
 CUDA_CALLABLE void sbesselj(int n, complex<T> x, complex<T>* j)
 {
     //compute the first bessel function
     if(n >= 0)
-        j[0] = sin(x) / x;
+        j[0] = (T)sin(x) / x;
 
     //compute the second bessel function
     if(n >= 1)
-        j[1] = j[0] / x - cos(x) / x;
+        j[1] = j[0] / x - (T)cos(x) / x;
 
     //use the recurrence relation to compute the rest
     for(int i = 2; i <= n; i++)
@@ -40,11 +40,11 @@ CUDA_CALLABLE void sbessely(int n, complex<T> x, complex<T>* y)
 {
     //compute the first bessel function
     if(n >= 0)
-        y[0] = -cos(x) / x;
+        y[0] = -(T)cos(x) / x;
 
     //compute the second bessel function
     if(n >= 1)
-        y[1] = y[0] / x - sin(x) / x;
+        y[1] = y[0] / x - (T)sin(x) / x;
 
     //use the recurrence relation to compute the rest
     for(int i = 2; i <= n; i++)
@@ -85,18 +85,18 @@ template <typename T>
 CUDA_CALLABLE void init_sbesselj(T x, T* j)
 {
 	//compute the first 2 bessel functions
-	j[0] = sin(x) / x;
+	j[0] = (T)sin(x) / x;
 
-	j[1] = j[0] / x - cos(x) / x;
+	j[1] = j[0] / x - (T)cos(x) / x;
 }
 
 template <typename T>
 CUDA_CALLABLE void init_sbessely(T x, T* y)
 {
 	//compute the first 2 bessel functions
-	y[0] = -cos(x) / x;
+	y[0] = -(T)cos(x) / x;
 
-	y[1] = y[0] / x - sin(x) / x;
+	y[1] = y[0] / x - (T)sin(x) / x;
 }
 
 template <typename T>
diff --git a/optics/material.h b/optics/material.h
index d6a4a99..9921702 100644
--- a/optics/material.h
+++ b/optics/material.h
@@ -11,7 +11,7 @@
 #include "rts/math/complex.h"
 #include "rts/math/function.h"
 
-#define PI  3.14159
+#define PI  3.14159f
 
 namespace rts{
 
@@ -144,6 +144,8 @@ namespace rts{
                     case field_A:
                         newRI.n.imag(_A(val * scaleA, newRI.lambda));
                         break;
+		    default:
+			break;
                 }
             }
 
diff --git a/tools/arguments.h b/tools/arguments.h
new file mode 100644
index 0000000..eec324a
--- /dev/null
+++ b/tools/arguments.h
@@ -0,0 +1,416 @@
+#ifndef RTS_ARGUMENTS
+#define RTS_ARGUMENTS
+
+#include <string>
+#include <vector>
+#include <iostream>
+#include <iomanip>
+#include <sstream>
+#include <iterator>
+#include <algorithm>
+
+#ifdef _WIN32
+#include <Windows.h>
+#endif
+
+namespace rts{
+
+	class argument
+	{
+	private:
+		bool ansi;
+
+		//argument name
+		std::string name;
+
+		//description of the argument
+		std::vector<std::string> desc;
+
+		//argument values
+		std::vector<std::string> vals;
+
+		//range or example
+		std::string range;
+
+		//flag is true when the argument is user-specified
+		bool flag;
+
+		void parse_val(const std::string &s){
+
+			vals.clear();
+
+			std::stringstream ss(s);
+			std::string item;
+			while (std::getline(ss, item, ' ')) {
+				vals.push_back(item);
+			}
+		}
+
+		void parse_desc(const std::string &s){
+
+			desc.clear();
+
+			std::stringstream ss(s);
+			std::string item;
+			while (std::getline(ss, item, '\n')) {
+				desc.push_back(item);
+			}
+		}
+
+	public:
+		void set_ansi(bool b){ ansi = b; }
+        //create an argument with a given name, description, and default value
+		argument(std::string _name, std::string _desc, std::string _default = "", std::string _range = "")
+		{
+			name = _name;
+			parse_desc(_desc);
+			parse_val(_default);
+
+			//if a default value is provided, set the flag
+			if(_default != "")
+                flag = true;
+            else flag = false;
+
+			range = _range;
+
+
+		}
+
+		int nargs()
+		{
+            return vals.size();
+        }
+
+		//return the value of a text argument
+		std::string as_text(int n = 0)
+		{
+            if(!flag)
+            {
+                std::cout<<"ERROR - Argument requested without being set: "<<name<<std::endl;
+                exit(1);
+            }
+
+            if(vals.size() > n)
+                return vals[n];
+
+            else return "";
+		}
+
+        //return the value of a floating point argument
+		float as_float(int n = 0)
+		{
+            if(!flag)
+            {
+                std::cout<<"ERROR - Argument requested without being set: "<<name<<std::endl;
+                exit(1);
+            }
+
+            if(vals.size() > n)
+            {
+                float r;
+                if ( ! (istringstream(vals[n]) >> r) ) r = 0;
+                return r;
+            }
+
+            else return 0;
+		}
+
+		//return the value of an integer argument
+		int as_int(int n = 0)
+		{
+            if(!flag)
+            {
+                std::cout<<"ERROR - Argument requested without being set: "<<name<<std::endl;
+                exit(1);
+            }
+
+            if(vals.size() > n)
+            {
+                int r;
+                if ( ! (istringstream(vals[n]) >> r) ) r = 0;
+                return r;
+            }
+
+            else return 0;
+		}
+
+		//get the width of the left column
+		int col_width()
+		{
+            int n = 3;
+            //add the length of the argument name
+            n += name.size();
+
+            //if there are any default parameters
+            if(vals.size() > 0)
+            {
+                //padding (parenthesis, =, etc.)
+                n += 6;
+
+                //for each default argument value
+                for(int v=0; v<vals.size(); v++)
+                    n += vals[v].size() + 1;
+            }
+
+            //add a buffer of 4 characters
+            n += 4;
+
+            return n;
+		}
+
+
+		//string output
+		std::string toStr(int width = 0)
+		{
+			std::stringstream ss;
+
+			int color_size = 0;
+
+
+			//create the left column
+			std::string left_part = std::string(" --") + name;
+			if(vals.size() != 0)
+			{
+				if(ansi)
+					left_part += "\033[1;32m";
+				left_part += " ( = ";
+				for(int v=0; v<vals.size(); v++)
+					left_part += vals[v] + std::string(" ");
+				left_part += ")";
+				if(ansi)
+					left_part += "\033[0m";
+				if(ansi)
+					color_size = 11;
+			}
+			else
+                color_size = 0;
+
+			//if no width is passed, put 4 spaces between left and right columns
+			if(width == 0) width = col_width();
+
+			ss<<std::left<<std::setw(width + color_size)<<left_part;
+
+			//output right column
+			for(int d=0; d<desc.size(); d++)
+			{
+				if(d == 0)
+					ss<<desc[0];
+				else
+					ss<<std::endl<<setfill(' ')<<setw(width)<<" "<<desc[d];
+
+			}
+
+			//output the range in the right column
+			if(range != "" && ansi)
+                ss<<std::endl<<setfill(' ')<<setw(width)<<" "<<"    "<<std::string("\033[1;36m") + range + "\033[0m";
+			else if(range != "")
+				ss<<std::endl<<setfill(' ')<<setw(width)<<" "<<"    "<<range;
+
+			return ss.str();
+		}
+
+		//compare the name of the argument to a string
+		bool operator==(std::string rhs)
+		{
+            return (name == rhs);
+		}
+
+		//set the argument to a given value
+		void set(std::string _value)
+		{
+            parse_val(_value);
+
+            //set the flag
+            flag = true;
+		}
+
+		bool is_set()
+		{
+            return flag;
+        }
+
+	};
+
+	struct argsection
+	{
+		std::string name;
+		unsigned int index;
+	};
+
+	class arglist
+	{
+    private:
+		bool ansi;
+
+		//vector of arguments
+        std::vector<argument> args;
+
+		//column width of the longest argument
+        int col_width;
+
+		//list of sections
+		std::vector<argsection> sections;
+
+    public:
+
+        arglist(){ col_width = 0; }
+
+		void set_ansi(bool b)
+		{
+			ansi = b;
+			for(int i=0; i<args.size(); i++)
+				args[i].set_ansi(ansi);
+		}
+
+        void add(std::string _name, std::string _desc, std::string _default = "", std::string _range = "")
+        {
+            argument arg(_name, _desc, _default, _range);
+			arg.set_ansi(ansi);
+            args.push_back(arg);
+
+            col_width = std::max<int>(col_width, arg.col_width());
+        }
+
+		void section(std::string _name)
+		{
+			argsection s;
+			s.name = _name;
+			s.index = args.size();
+			sections.push_back(s);
+		}
+
+        //output the arguments (generally in response to --help)
+        std::string toStr()
+        {
+            std::stringstream ss;
+
+            int si = -1;
+
+            if(sections.size() > 0)
+                si = 0;
+
+            //for each argument
+            for(int a=0; a<args.size(); a++)
+            {
+                if(si != -1 && a == sections[si].index)
+                {
+					if(ansi)
+						ss<<std::endl<<std::left<<setfill('=')<<setw(col_width)<<std::string("\033[1;31m") + sections[si].name<<"\033[0m"<<std::endl;
+					else
+						ss<<std::endl<<std::left<<setfill('=')<<setw(col_width)<<sections[si].name<<std::endl;
+                    si++;
+                    if(si == sections.size()) si = -1;
+                }
+
+                ss<<args[a].toStr(col_width)<<std::endl;
+            }
+
+            return ss.str();
+        }
+
+        int index(std::string _name)
+        {
+            int i = find(args.begin(), args.end(), _name) - args.begin();
+
+            if(i >= args.size())
+                i = -1;
+
+            return i;
+        }
+
+        void set(std::string _name, std::string _value)
+        {
+            int i = index(_name);
+
+            if(i != -1)
+            {
+                args[i].set(_value);
+                //adjust the column width if necessary
+                col_width = max(col_width, args[i].col_width());
+            }
+            else
+                std::cout<<"ERROR - Argument not recognized: "<<_name<<std::endl;
+        }
+
+        //parse a parameter string
+        void parse(int argc, char* argv[])
+        {
+            //if the number of arguments is 1, we're done
+            if(argc <= 1) return;
+
+            std::string name;
+            std::string params;
+
+            for(int i=1; i<argc; i++)
+            {
+                //if the argument is a parameter name
+                if(argv[i][0] == '-' && argv[i][1] == '-')
+                {
+                    //add any previous arguments
+                    if(name != "")
+                        set(name, params);
+                    //set the current argument to this name
+                    name = argv[i]+2;
+                    //clear the parameters list
+                    params = "";
+                }
+                else
+                {
+					if(params != "")
+						params += " ";
+                    params += argv[i];
+                }
+            }
+
+            //set the last argument
+            set(name, params);
+        }
+
+        //determine if a parameter has been set (either specified by the user or with a default value)
+        bool operator()(std::string _name)
+        {
+            int i = find(args.begin(), args.end(), _name) - args.begin();
+
+            if(i < 0)
+            {
+                std::cout<<"ERROR - Unspecified parameter name: "<<_name<<std::endl;
+                exit(1);
+            }
+
+            return args[i].is_set();
+        }
+
+        int nargs(std::string _name)
+        {
+            int i = find(args.begin(), args.end(), _name) - args.begin();
+
+            if(i < 0)
+            {
+                std::cout<<"ERROR - Unspecified parameter name: "<<_name<<std::endl;
+                exit(1);
+            }
+
+            return args[i].nargs();
+        }
+
+        argument operator[](std::string _name)
+        {
+            int i = find(args.begin(), args.end(), _name) - args.begin();
+
+            if(i < 0)
+            {
+                std::cout<<"ERROR - Unspecified parameter name: "<<_name<<std::endl;
+                exit(1);
+            }
+
+            return args[i];
+        }
+
+
+	};
+
+
+
+}	//end namespace rts
+
+#endif
--
libgit2 0.21.4