"""

The follwing constructor classes exists here:

+------------------------------------------+---------------------------------------+

| Class | Description |

+==========================================+=======================================+

| :py:class:`~matlab2cpp.datatype.Type` | Frontend for the datatype string |

+------------------------------------------+---------------------------------------+

| :py:class:`~matlab2cpp.datatype.Dim` | Reference to the number of dimensions |

+------------------------------------------+---------------------------------------+

| :py:class:`~matlab2cpp.datatype.Mem` | Reference to the memory type |

+------------------------------------------+---------------------------------------+

| :py:class:`~matlab2cpp.datatype.Num` | Numerical value indicator |

+------------------------------------------+---------------------------------------+

| :py:class:`~matlab2cpp.datatype.Suggest` | Frontend for suggested datatype |

+------------------------------------------+---------------------------------------+

"""

from . import supplement

dim0 = {"int", "float", "uword", "double", "cx_double", "size_t"}

dim1 = {"ivec", "fvec", "uvec", "vec", "cx_vec"}

dim2 = {"irowvec", "frowvec", "urowvec", "rowvec", "cx_rowvec"}

dim3 = {"imat", "fmat", "umat", "mat", "cx_mat"}

dim4 = {"icube", "fcube", "ucube", "cube", "cx_cube"}

dims = [dim0, dim1, dim2, dim3, dim4]

mem0 = {"uword", "uvec", "urowvec", "umat", "ucube"}

mem1 = {"int", "ivec", "irowvec", "imat", "icube"}

mem2 = {"float", "fvec", "frowvec", "fmat", "fcube"}

mem3 = {"double", "vec", "rowvec", "mat", "cube"}

mem4 = {"cx_double", "cx_vec", "cx_rowvec", "cx_mat", "cx_cube"}

mems = [mem0, mem1, mem2, mem3, mem4]

others = {"char", "string", "TYPE", "func_lambda", "struct", "structs", "cell",

"wall_clock", "SPlot"}

def common_loose(vals):

"""Common denominator among several names.

Loose enforcment"""

if not isinstance(vals, (tuple, list)) or \

isinstance(vals[0], int):

vals = [vals]

vals = list(vals)

for i in range(len(vals)):

if isinstance(vals[i], str):

continue

if isinstance(vals[i][0], int):

vals[i] = get_name(*vals[i])

vals = set(vals)

if len(vals) == 1:

return vals.pop()

vals.discard("TYPE")

if len(vals) == 1:

return vals.pop()

for other in others:

vals.discard(other)

if len(vals) == 0:

return "TYPE"

elif len(vals) == 1:

return vals.pop()

dims_ = map(get_dim, vals)

if dims_:

dim = max(*dims_)

else:

return "TYPE"

if dim == 2 and 1 in dims_:

dim = 3

types = map(get_mem, vals)

type = max(*types)

val = get_name(dim, type)

return val

def common_strict(vals):

"""Common denominator among several names.

Strict enforcment"""

if not isinstance(vals, (tuple, list)) \

or isinstance(vals[0], int):

vals = [vals]

vals = list(vals)

for i in range(len(vals)):

if isinstance(vals[i], str):

continue

if isinstance(vals[i][0], int):

vals[i] = get_name(*vals[i])

vals = set(vals)

if len(vals) == 1:

return vals.pop()

for other in others:

if other in vals:

return "TYPE"

dims_ = map(get_dim, vals)

dim = max(*dims_)

if dim == 2 and 1 in dims_:

return "TYPE"

types = map(get_mem, vals)

type = max(*types)

val = get_name(dim, type)

return val

def pointer_split(name):

p = name.count("*")

if not p:

return 0, name

return p, name[:-p]

def get_dim(val):

while val[-1] == "*":

val = val[:-1]

if val in dim0: dim = 0

elif val in dim1: dim = 1

elif val in dim2: dim = 2

elif val in dim3: dim = 3

elif val in dim4: dim = 4

elif val in others: dim = None

else:

raise ValueError("Datatype '%s' not recognized" % val)

return dim

def get_mem(val):

while val[-1] == "*":

val = val[:-1]

if val in mem0: mem = 0

elif val in mem1: mem = 1

elif val in mem2: mem = 2

elif val in mem3: mem = 3

elif val in mem4: mem = 4

elif val in others: mem = None

else:

raise ValueError("Datatype '%s' not recognized" % val)

return mem

def get_num(val):

while val[-1] == "*":

val = val[:-1]

if val in others: num = False

else: num = True

return num

def get_name(dim, mem):

return dims[dim].intersection(mems[mem]).pop()

def get_type(instance):

if instance.prop["type"] == "TYPE":

instance = instance.declare

return instance.prop["type"]

class Dim(object):

"""

The `node.dim` is a help variable for handling numerical datatype.

It represents the number of dimension a numerical object represents:

+-------+--------------+

| *dim* | Description |

+=======+==============+

| 0 | scalar |

+-------+--------------+

| 1 | (col-)vector |

+-------+--------------+

| 2 | row-vector |

+-------+--------------+

| 3 | matrix |

+-------+--------------+

| 4 | cube |

+-------+--------------+

| None | Other |

+-------+--------------+

The variable can be both read and set in real time:

>>> node = collection.Var(None, "name")

>>> node.type="float"

>>> print(node.dim)

0

>>> node.dim = 3

>>> print(node.type)

fmat

"""

def __get__(self, instance, owner):

if instance is None:

return self

return get_dim(get_type(instance))

def __set__(self, instance, value):

mem = get_mem(get_type(instance))

instance.prop["type"] = get_name(value, mem)

class Mem(object):

"""

The `node.mem` is a help variable for handling numerical datatype.

It represents the internal basic datatype represented in memory:

+-------+-------------+

| *mem* | Description |

+=======+=============+

| 0 | unsiged int |

+-------+-------------+

| 1 | integer |

+-------+-------------+

| 2 | float |

+-------+-------------+

| 3 | double |

+-------+-------------+

| 4 | complex |

+-------+-------------+

| None | Other |

+-------+-------------+

The variable can be both read and set in real time:

>>> node = collection.Var(None, "name")

>>> node.type="float"

>>> print(node.mem)

2

>>> node.mem = 3

>>> print(node.type)

double

"""

def __get__(self, instance, owner):

if instance is None:

return self

return get_mem(get_type(instance))

def __set__(self, instance, value):

dim = get_dim(get_type(instance))

instance.prop["type"] = get_name(dim, value)

class Num(object):

"""

The `node.num` is a help variable for handling numerical datatype. It is

a boolean values which is true given that the datatype is of numerical type.

"""

def __get__(self, instance, owner):

if instance is None:

return self

return get_num(get_type(instance))

def __set__(self, instance, value):

if not value:

instance.prop["type"] = "TYPE"

else:

raise AttributeError("num can not be set True consistently")

class Type(object):

"""

Datatypes can be roughly split into two groups: **numerical** and

**non-numerical** types. The numerical types are as follows:

+-------------+--------------+-----------+-----------+----------+-------------+

| | unsigned int | int | float | double | complex |

+=============+==============+===========+===========+==========+=============+

| scalar | *uword* | *int* | *float* | *double* | *cx_double* |

+-------------+--------------+-----------+-----------+----------+-------------+

| vector | *uvec* | *ivec* | *fvec* | *vec* | *cx_vec* |

+-------------+--------------+-----------+-----------+----------+-------------+

| row\-vector | *urowvec* | *irowvec* | *frowvec* | *rowvec* | *cx_rowvec* |

+-------------+--------------+-----------+-----------+----------+-------------+

| matrix | *umat* | *imat* | *fmat* | *mat* | *cx_mat* |

+-------------+--------------+-----------+-----------+----------+-------------+

| cube | *ucube* | *icube* | *fcube* | *cube* | *cx_cube* |

+-------------+--------------+-----------+-----------+----------+-------------+

Values along the horizontal axis represents the amount of memory reserved per

element, and the along the vertical axis represents the various number of

dimensions. The names are equivalent to the ones in the Armadillo package.

The non-numerical types are as follows:

+---------------+------------------------+

| Name | Description |

+===============+========================+

| *char* | Single text character |

+---------------+------------------------+

| *string* | Text string |

+---------------+------------------------+

| *struct* | Struct container |

+---------------+------------------------+

| *structs* | Struct array container |

+---------------+------------------------+

| *func_lambda* | Anonymous function |

+---------------+------------------------+

The node datatype can be referenced by any node through `node.type` and can be

inserted as placeholder through `%(type)s`.

"""

def __get__(self, instance, owner):

if instance is None:

return self

return get_type(instance)

def __set__(self, instance, value):

value = value or "TYPE"

if isinstance(value, str):

p, value = pointer_split(value)

instance.pointer = p

else:

value = common_strict(value)

instance.prop["type"] = value

class Suggest(object):

"""Same as Type, but for suggested value.

"""

def __set__(self, instance, value):

if value == "TYPE":

return

instance.declare.prop["suggest"] = value

def __get__(self, instance, owner):

return supplement.suggests.get(instance)

if __name__ == "__main__":

import doctest

doctest.testmod()