# Thread: 2 am complex double conversion woes

1. ## 2 am complex double conversion woes

Hey all,

Its 2am im a little sleepy so I may be missing something elementary here;

I have calculator from the relisoft site that ive been modifying.

Code:
```main
{input
scanner
parser}```
Been modifying it to implement complex numbers, using the <complex> standard with c++.

So far so good; it can evaluate expressions like : (5 + j)/(5 + 16j) etc correctly.

The program im modifying has a symbaltable where it has a list of functions, ive gone through every single declared double and checked to make sure its complex<double> now, but still when it tries to use any of the functions in the table:
Code:
```symtab.cpp:57: error: invalid conversion from `double (*)(double) throw ()' to
`std::complex<double> (*)(std::complex<double>)'```
Looked in stroustrups book, and the normal, cos, sin, exp functions are built in, cant understand why I cant change all the double types to complex and use the existing program structure? It works with operators... but functions... nope.

Perhaps vague description, however whenever I post code, the nice people here go ahead and code the whole thing, which is more than what I need, and more of your time than I want to take.

A suggestion as to what I may be overlooking would be fine.

Edit: In case its too vague,
symtab.cpp:
Code:
```//------------------------------------
//  symtab.cpp
//  (c) Bartosz Milewski, 1994
//------------------------------------

#include "symtab.h"
#include <cassert>
#include <cstring>
#include <iostream>
#include <complex>
using std::complex;
using std::cout;
using std::endl;

complex<double> CoTan (complex<double> x)
{
complex<double> y = tan (x);
if (y.real() == 0)
{
cout << "cotan of " << x << " undefined\n";
return HUGE_VAL;
}
return 1.0 / y;
}           //do this for other funs

complex<double> cos (complex<double> x)
{
complex<double> y = cos (x);
if (y.real() == 0)
{
cout << "cotan of " << x << " undefined\n";
return HUGE_VAL;
}
return 1.0 / y;
}           //do this for other funs

FunctionEntry funArr [maxIdFun] =
{
//   log,  "log",
//   log10,"log10",
//     exp,  "exp",
//   sqrt, "sqrt",
//   sin,  "sin",
//     cos,  "cos",
//   tan,  "tan",
CoTan,"cotan",
//   sinh, "sinh",
//   cosh, "cosh",
//   tanh, "tanh",
//   asin, "asin",
//   acos, "acos",
//   atan, "atan",
0,    ""
};

FunctionTable::FunctionTable (SymbolTable & symTab, FunctionEntry funArr [])
: _size(0)
{
for (int i = 0; i < maxIdFun; ++i)
{
int len =  strlen (funArr [i].strFun);
if (len == 0)
break;
_pFun [i] = funArr [i].pFun;
cout << funArr[i].strFun << endl;
int j = symTab.ForceAdd (funArr[i].strFun, len);
assert (i == j);
++_size;
}
}

List::List ()
{}

List::~List ()
{
{
}
}

{
// add in front of the list
}

// Find the list in hash table that may contain
// the id of the string we are looking for

List const & HTable::Find (char const * str, int len) const
{
int i = hash (str, len);
assert (i >= 0 && i < _size);
return _aList [i];
}

void HTable::Add (char const * str, int len, int id)
{
int i = hash (str, len);
assert (i >= 0 && i < _size);
}

// Private hashing function

int HTable::hash (char const * str, int len) const
{

assert (len != 0);
// must be unsigned, hash should return positive number
unsigned h = str ;
for (int i = 1; i < len; ++i)
h = (h << 4) + str [i];
return h % _size;  // small positive integer
}

SymbolTable::SymbolTable (int size)
: _size (size), _curId (0), _curStrOff (0), _htab (size + 1)

{
_offStr = new int [size];
_bufSize = size * 10;
_strBuf = new char [_bufSize];
}

SymbolTable::~SymbolTable()
{
delete []_offStr;
delete []_strBuf;
}

// Add string without looking for duplicates

int SymbolTable::ForceAdd (char const * str, int len)
{
// is there enough space?
if (_curId == _size
|| _curStrOff + len + 1 >= _bufSize)
{
return idNotFound;
}
// point to place where the string will be stored
_offStr [_curId] = _curStrOff;
// copy the string there
strncpy (&_strBuf [_curStrOff], str, len);
// calculate new offset
_curStrOff += len;
_strBuf [_curStrOff] = 0;  // null terminate
++_curStrOff;
++_curId;
return _curId - 1;
}

int SymbolTable::Find (char const * str, int len) const
{
// Get a short list from hash table
List const & list = _htab.Find (str, len);
// Iterate over this list
{
int offStr = _offStr [id];
// char const * strStored = &_strBuf [ offStr ];
char const * strStored = _strBuf + offStr;
if (strcmp (str, strStored) == 0) // they're equal
{
return id;  // success!
}
}
return idNotFound;
}

// map integer into string. Must be valid id

char const * SymbolTable::GetString (int id) const
{
assert (id >= 0);
assert (id < _curId);
int offStr = _offStr [id];
return &_strBuf [offStr];
// return _strBuf + offStr;
}```
symtab.h:
Code:
```#if !defined SYMTAB_H
#define SYMTAB_H
//------------------------------------
//  symtab.h
//  (c) Bartosz Milewski, 1994
//------------------------------------
#include <cstring>
#include <complex>

using std::complex;

const int maxIdFun = 16;

typedef complex<double> (*PFun) (complex<double> x);

class FunctionEntry
{
public:
PFun pFun;
char* strFun;
};

extern FunctionEntry funArr [];

class SymbolTable;

class FunctionTable
{
public:
FunctionTable (SymbolTable& symTab, FunctionEntry funArr []);
int Size () const { return _size; }
PFun GetFun (int id) { return _pFun [id]; }
private:
PFun  _pFun [maxIdFun];
int   _size;
};

// stores integer id in a link
{
public:
: _pNext (pNext), _id (id) {}

Link *  Next () const { return _pNext; }
int     Id () const { return _id; }
private:
int     _id;
};

class List
{
public:
List ();
~List ();
private:
};

// Hash table of strings

class HTable
{
public:
explicit HTable (int size): _size(size)
{
_aList = new List[size];
}

~HTable ()
{
delete [] _aList;
}

List const & Find (char const * str, int len) const;
List const & Find (char const * str) const
{
return Find (str, strlen (str));
}
void Add (char const * str, int len, int id);
void Add (char const * str, int id)
{
}
private:
int hash (char const * str, int len) const;

List * _aList;
int    _size;
};

const int idNotFound = -1;

// String table maps strings to ints
// and ints to strings

class SymbolTable
{
public:
explicit SymbolTable (int size);
~SymbolTable ();
int ForceAdd (char const * str, int len);
int Find (char const * str, int len) const;
char const * GetString (int id) const;
private:
HTable  _htab;
int *   _offStr; // offsets of strings in buffer
int     _size;
int     _curId;
char *  _strBuf;
int     _bufSize;
int     _curStrOff;
};
#endif``` 2. symtab.cpp:57: error: invalid conversion from `double (*)(double) throw ()' to
`std::complex<double> (*)(std::complex<double>)'

try return y / 1.0;
or return y = y / 1.0;
or return (complex<double>(1.0) / y); //this might be a syntax error

i may be way off on this theory, but complex: perator/ function might return a double if the left hand operand is a double and the right hand operand is complex..and vice versa Popular pages Recent additions 