cvar.cc

/*
 *	Variant Variables (used by CExp)
 *
 *	This program is distributed under the terms of the GPL v3.0 or later
 *	Download the GNU Public License (GPL) from <https://www.gnu.org>
 *
 *	Copyright(C) 2025, Free Software Foundation, Inc.
 *	Written by Nicholas Christopoulos <mailto:netnic@proton.me>
 */

#ifndef CVAR_H
#define CVAR_H 		0x10000

#include <cstddef>
#include <cstring>
#include <cstdarg>
#include <string>
#include <stdexcept>
#include <unordered_map>

#ifndef CEXP_DATA_T
#define CEXP_DATA_T
typedef ssize_t int_t;
typedef size_t  uint_t;
typedef double  real_t;
#endif

typedef enum { v_int, v_float, v_str, v_matrix } cvar_type_t;

#include "cmatrix.cc"

class CExp;

class CVar {
private:
	cvar_type_t type; // type of data in this block
	int_t	i;	// integer value
	real_t	f;	// floating point value
	std::string	s;	// string value
	CMatrix	m;	// matrix value
#ifdef CEXP_USE_PROPS
	std::unordered_map<std::string,CVar> props; // properties (if used)
#endif
	
public:
	CVar()			{ type = v_int; i = 0; f = 0; }
	CVar(int n)		{ type = v_int; i = n; f = 0; }
	CVar(int_t n)	{ type = v_int; i = n; f = 0; }
	CVar(uint_t n)	{ type = v_int; i = n; f = 0; }
	CVar(real_t n)	{ type = v_float; i = 0; f = n; }
	CVar(const std::string& sp)	{ type = v_str; i = 0; f = 0; s = sp; }
	CVar(const CMatrix& mp)	{ type = v_matrix; i = 0; f = 0; m = mp; }
	CVar(const CVar& src) {
		type = src.type;
#ifdef CEXP_USE_PROPS
		props = src.props;
#endif
		switch ( type ) {
		case v_int:   i = src.i; break;
		case v_float: f = src.f; break;
		case v_str:   s = src.s; break;
		case v_matrix:
			if ( src.m.size() )
				m = src.m;
			else if ( m.size() )
				m.clear();
			break;
			}
		}
	virtual ~CVar() { clear(); }

	void clear() {
		type = v_int;
		i = 0; f = 0;
		if ( !s.empty() ) s.clear();
		if ( m.size() )   m.clear();
#ifdef CEXP_USE_PROPS
		if ( !props.empty() )
			props.clear();
#endif
		}

	const CVar& operator=(const CVar& src) {
		clear();
		type = src.type;
#ifdef CEXP_USE_PROPS
		props = src.props;
#endif
		switch ( type ) {
		case v_int:   i = src.i; break;
		case v_float: f = src.f; break;
		case v_str:   s = src.s; break;
		case v_matrix: m = src.m; break;
			break;
			}
		return *this;
		}
	
	void seti(int_t n)	{ clear(); type = v_int; i = n; }
	void seti(uint_t n)	{ clear(); type = v_int; i = n; }
	void setf(real_t n)	{ clear(); type = v_float; f = n; }
	void sets(const std::string& _s)		{ clear(); type = v_str; s = _s; }
	void setm(const CMatrix& _m)	{ clear(); type = v_matrix; m = _m; }

	int_t geti() const {
		switch ( type ) {
		case v_int:		return i;
		case v_float:	return (int_t) f;
		case v_str:		return atoll(s.c_str());
		case v_matrix:	throw std::runtime_error("matrix cannot converted to integer");
			}
		throw std::runtime_error("data type corrupted");
		}

	real_t getf() const {
		switch ( type ) {
		case v_int:		return i;
		case v_float:	return f;
		case v_str:		return strtod(s.c_str(), NULL);
		case v_matrix:  throw std::runtime_error("matrix cannot converted to real number");
			}
		throw std::runtime_error("data type corrupted");
		}

	std::string gets() const {
		switch ( type ) {
		case v_int:		return std::to_string(i);
		case v_float:	return std::to_string(f);
		case v_str:		return s;
		case v_matrix: {
				std::string z = "[";
				for ( size_t r = 0; r < m.rows(); r ++ ) {
					for ( size_t c = 0; c < m.cols(); c ++ ) {
						z = z + std::to_string(m.get(r,c));
						if ( c < m.cols() - 1 )
							z += ",";
						}
					if ( r < m.rows() - 1 )
						z += ";";
					}
				z += "]";
				return z;
				}
			}
		throw std::runtime_error("data type corrupted");
		}

	inline const CMatrix& getm() const { return m; }
	
	void print() const;
	void print(const char *fmt, ...) const;

	friend class CExp;
	
	friend CVar operator+(const CVar& a, const CVar& b);
	friend CVar operator-(const CVar& a, const CVar& b);
	friend CVar operator*(const CVar& a, const CVar& b);
	friend CVar operator/(const CVar& a, const CVar& b);
	friend CVar operator%(const CVar& a, const CVar& b);
	};

CVar operator+(const CVar& a, const CVar& b);
CVar operator-(const CVar& a, const CVar& b);
CVar operator*(const CVar& a, const CVar& b);
CVar operator/(const CVar& a, const CVar& b);
CVar operator%(const CVar& a, const CVar& b);
#endif

/* -------------------------------------------------------------------------------- */
#ifdef CVAR_IMPL
#include <cstdio>
#include <cstdlib>
#include <cstring>
#define CMATRIX_IMPL
#include "cmatrix.cc"
using namespace std;
//
CVar operator+(const CVar& a, const CVar& b) {
	if ( a.type == v_int && b.type == v_int )
		return (a.i + b.i);
	else if ( a.type == v_str && b.type == v_str )
		return (a.s + b.s);
	else if ( a.type == v_matrix && b.type == v_matrix )
		return (a.m + b.m);
	else if ( a.type == v_matrix && b.type <= v_str )
		return (a.m + b.getf());
	else if ( a.type <= v_str && b.type <= v_str )
		return (a.getf() + b.getf());
	throw runtime_error("Type mismatch");
	}	

CVar operator-(const CVar& a, const CVar& b) {
	if ( a.type == v_int && b.type == v_int )
		return (a.i - b.i);
	else if ( a.type == v_matrix && b.type == v_matrix )
		return (a.m - b.m);
	else if ( a.type == v_matrix && b.type <= v_str )
		return (a.m - b.getf());
	else if ( a.type <= v_str && b.type <= v_str )
		return (a.getf() - b.getf());
	throw runtime_error("Type mismatch");
	}

CVar operator*(const CVar& a, const CVar& b) {
	if ( a.type == v_int && b.type == v_int )
		return (a.i * b.i);
	else if ( a.type == v_matrix && b.type == v_matrix )
		return (a.m * b.m);
	else if ( a.type == v_matrix && b.type <= v_float )
		return (a.m * b.getf());
	else if ( a.type <= v_float && b.type == v_matrix )
		return (b.m * a.getf());
	else if ( a.type <= v_str && b.type <= v_str )
		return (a.getf() * b.getf());
	throw runtime_error("Type mismatch");
	}

CVar operator/(const CVar& a, const CVar& b) {
	if ( b.getf() == 0.0 )
		throw runtime_error("Division by zero");
	if ( a.type <= v_str && b.type <= v_str )
		return (a.getf() / b.getf());
	if ( a.type == v_matrix && b.type <= v_str )
		return (a.m / b.getf());
	throw runtime_error("Type mismatch");
	}

CVar operator%(const CVar& a, const CVar& b) {
	if ( b.geti() == 0 )
		throw runtime_error("Division by zero");
	if ( a.type <= v_str && b.type <= v_str )
		return (a.geti() % b.geti());
	if ( a.type == v_matrix && b.type <= v_str )
		return (a.m % b.geti());
	throw runtime_error("Type mismatch");
	}

void CVar::print() const {
	switch ( type ) {
	case v_int:
		printf("%zd\n", i);
		break;
	case v_float:
		printf("%g\n", f);
		break;
	case v_str:
		printf("%s\n", s.c_str());
		break;
	case v_matrix:
		for ( size_t r = 0; r < m.rows(); r ++ ) {
			printf("|\t");
			for ( size_t c = 0; c < m.cols(); c ++ )
				printf("%g\t", m.get(r, c));
			printf("|\n");
			}
		break;
	default:
		throw runtime_error("variable type is wrong!");
		}
	}

void CVar::print(const char *fmt, ...) const {
	char buf[LINE_MAX];
	va_list ap;
	
	va_start(ap, fmt);
	vsnprintf(buf, LINE_MAX, fmt, ap);
	va_end(ap);
	printf("%s", buf);
	print();
	}

#endif // implementation