DynamicOperations

Defintion of all dynamic operations, including arithmetic, logical, relational, and bit-operations. More...

Functions
trilean	dyn_op_neg (dyn_c *dyn)
	Negate dynamic value in param dyn. More...
trilean	dyn_op_add (dyn_c *dyn1, dyn_c *dyn2)
	Add dyn2 to dyn1. More...
trilean	dyn_op_sub (dyn_c *dyn1, dyn_c *dyn2)
	Subtract dyn2 from dyn1. More...
trilean	dyn_op_mul (dyn_c *dyn1, dyn_c *dyn2)
	Multiply dyn1 with dyn2. More...
trilean	dyn_op_div (dyn_c *dyn1, dyn_c *dyn2)
	Divide dyn1 by dyn2. More...
trilean	dyn_op_mod (dyn_c *dyn1, dyn_c *dyn2)
	dyn1 Modulo dyn2 More...
trilean	dyn_op_pow (dyn_c *dyn1, dyn_c *dyn2)
	dyn1 to the power of dyn2 More...
trilean	dyn_op_and (dyn_c *dyn1, dyn_c *dyn2)
	Logical (trinary) AND operation. More...
trilean	dyn_op_or (dyn_c *dyn1, dyn_c *dyn2)
	Logical (trinary) OR operation. More...
trilean	dyn_op_xor (dyn_c *dyn1, dyn_c *dyn2)
	Logical (trinary) XOR operation. More...
trilean	dyn_op_not (dyn_c *dyn)
	Logical (trinary) Negation. More...
trilean	dyn_op_id (dyn_c *dyn1, dyn_c *dyn2)
	Type and Value Equality. More...
trilean	dyn_op_eq (dyn_c *dyn1, dyn_c *dyn2)
	Relational Equality. More...
trilean	dyn_op_ne (dyn_c *dyn1, dyn_c *dyn2)
	Relational Not Equal. More...
trilean	dyn_op_lt (dyn_c *dyn1, dyn_c *dyn2)
	Relational Less Than. More...
trilean	dyn_op_le (dyn_c *dyn1, dyn_c *dyn2)
	Relational Less Than or Equal. More...
trilean	dyn_op_gt (dyn_c *dyn1, dyn_c *dyn2)
	Relational Greater Than. More...
trilean	dyn_op_ge (dyn_c *dyn1, dyn_c *dyn2)
	Relational Greater Than or Equal. More...
trilean	dyn_op_in (dyn_c *element, dyn_c *container)
	Check if dyn2 is element of dyn1. More...
trilean	dyn_op_b_not (dyn_c *dyn)
	Binary complement.
trilean	dyn_op_b_and (dyn_c *dyn1, dyn_c *dyn2)
	Binary AND.
trilean	dyn_op_b_or (dyn_c *dyn1, dyn_c *dyn2)
	Binary OR.
trilean	dyn_op_b_xor (dyn_c *dyn1, dyn_c *dyn2)
	Binary XOR.
trilean	dyn_op_b_shift_l (dyn_c *dyn1, dyn_c *dyn2)
	Binary shift left.
trilean	dyn_op_b_shift_r (dyn_c *dyn1, dyn_c *dyn2)
	Binary shift right.

Detailed Description

Defintion of all dynamic operations, including arithmetic, logical, relational, and bit-operations.

These functions cover all basic operations, which are common for most programming languages. In principle most operations known from Python are offered with a similar behavior, but with two differences. Dynamic operations evaluate a result based on the data type with the highes priority and not on the basis of left-hand and right-hand parameters. That means, for dynple (see the defintion of every function):

// LIST type is higher than STRING type
dyn_op_add([1,2,3], "test string") == [1,2,3,"test string"]
dyn_op_add("test string", [1,2,3]) == ["test string",1,2,3]

// STRING type is higher than INTEGER type
dyn_op_mul(3, "abc") == "abcabcabc"
dyn_op_mul("abc", 3) == "abcabcabc"

// FLOAT type is higher than INTEGER type
dyn_op_div(9.0, 3) == 3.0
dyn_op_div(9, 3.0) == 3.0

The result is always stored and returned within the first parameter passed to an operator function. If this parameter is a dynamic reference of TYPE REFERENCE or REFERENCE2, then a new element is created, the original element remains. If the operation was performed without any error, then DYN_TRUE is returned by every function of that module, otherwise DYN_FALSE.

A second characteristic of the operations applied is that a trinary logical system is applied to simplify error-handling amongst other benefits. Trinary means that next to the two boolean values DYN_TRUE and DYN_FALSE, the NONE type is used to represent another unknown or undefined state. The benefit is, that comparing two distinct dynamic types such as a list and a string with less than or greater than results in that unknown/undefined state and not in an error. This trinary logical system is also perfect for applying logical operations, see therefor the corresponding logical functions.

See also

https://en.wikipedia.org/wiki/Three-valued_logic

Function Documentation

dyn_op_add()

trilean dyn_op_add	(	dyn_c *	dyn1,
		dyn_c *	dyn2
	)

Add dyn2 to dyn1.

The add operation shows generates different results according to the input data types. The resulting type is defined by the highest type, see the following list for allowed operations:

dyn_1	dyn_2	result type
BOOL	BOOL	BOOL
INTEGER	BOOL	INTEGER
BOOL	INTEGER	INTEGER
INTEGER	INTEGER	INTEGER
FLOAT	BOOL	FLOAT
BOOL	FLOAT	FLOAT
FLOAT	INTEGER	FLOAT
INTEGER	FLOAT	FLOAT
FLOAT	FLOAT	FLOAT
STRING	(NUMERIC)	STRING (concatenaited) "abc123"
(NUMERIC)	STRING	STRING (concatenaited) "123abc"
STRING	STRING	STRING (concatenaited) "abcabc"
LIST	...	LIST [, ...]
...	LIST	LIST [... ,]
SET	...	SET {, ...} (unique elements only)
...	SET	SET {, ...} (unique elements only)
DICT	DICT	DICT {with all elements}

Parameters

[in,out]	dyn1	in- and output parameter
[in]	dyn2	input parameter

Return values

DYN_TRUE	if operation could be applied onto the input data type
DYN_FALSE	otherwise

Definition at line 124 of file dynamic_op.c.

{
    CHECK_REFERENCE(dyn1, dyn2)

    dyn_c tmp;
    DYN_INIT(&tmp);

    if (DYN_TYPE(dyn1) && DYN_TYPE(dyn2)) {
        switch (max_type(dyn1, dyn2)) {
            case BOOL:

            case INTEGER: dyn_set_int(dyn1, dyn_get_int(dyn1) + dyn_get_int(dyn2));
                          goto LABEL_OK;
            case FLOAT:   dyn_set_float(dyn1, dyn_get_float(dyn1) + dyn_get_float(dyn2));
                          goto LABEL_OK;
            case STRING:  {
                if (DYN_TYPE(dyn1) == STRING) {
                    dyn1->data.str = (dyn_str) realloc(dyn1->data.str, dyn_strlen(dyn1->data.str) +
                                                                      dyn_string_len(dyn2) + 1 );
                    dyn_string_add(dyn2, dyn1->data.str);
                }
                else {
                    tmp.type = STRING;
                    tmp.data.str = (dyn_str) malloc(dyn_string_len(dyn1) + dyn_string_len(dyn2) + 1);
                    tmp.data.str[0]='\0';
                    dyn_string_add(dyn1, tmp.data.str);
                    dyn_string_add(dyn2, tmp.data.str);
                    dyn_move(&tmp, dyn1);
                }
                goto LABEL_OK;
            }
            case LIST: {
                if (DYN_TYPE(dyn1) == LIST) {
                    dyn_list_push(dyn1, dyn2);
                } else {
                    dyn_move(dyn1, &tmp);
                    dyn_copy(dyn2, dyn1);
                    dyn_list_insert(dyn1, &tmp, 0);
                }
                goto LABEL_OK;

            }
            case SET: {
                if (DYN_TYPE(dyn1) == DYN_TYPE(dyn2)) {
                    dyn_ushort i;
                    for (i=0; i<DYN_LIST_LEN(dyn2); ++i)
                        dyn_set_insert(dyn1, DYN_LIST_GET_REF(dyn2, i));
                } else if (DYN_TYPE(dyn1) == SET) {
                    dyn_set_insert(dyn1, dyn2);
                } else {
                    dyn_move(dyn1, &tmp);
                    dyn_copy(dyn2, dyn1);
                    dyn_set_insert(dyn1, &tmp);
                }
                goto LABEL_OK;
            }
            case DICT: {
                if (DYN_TYPE(dyn1) == DYN_TYPE(dyn2)) {
                    dyn_ushort i;
                    for (i=0; i<DYN_DICT_LEN(dyn2); ++i)
                        dyn_dict_insert(dyn1,
                                        DYN_DICT_GET_I_KEY(dyn2, i),
                                        DYN_DICT_GET_I_REF(dyn2, i));
                    goto LABEL_OK;
                }
            }
        }
    }

    dyn_free(dyn1);
    return DYN_FALSE;
LABEL_OK:
    return DYN_TRUE;
}

dyn_op_and()

trilean dyn_op_and	(	dyn_c *	dyn1,
		dyn_c *	dyn2
	)

Logical (trinary) AND operation.

As depicted in the truth table below, this function performes the standard boolean AND operation, the extention with the None boolean type does not affect this operation. The truth value of every dynamic element is generated with the help of function dyn_get_bool_3.

AND	True	False	None
True	True	False	None
False	False	False	False
None	None	False	None

The result of this operation is stored within the first parameter dyn1, if this value is a reference, then a new value is created, otherwise the original value gets overwritten.

See also

dyn_get_bool_3

dyn_get_bool

Parameters

[out]	dyn1	in- and output dynamic element
[in]	dyn2	second operand

Returns

DYN_TRUE, operation can be applied on every combination of dynamic data types

Definition at line 542 of file dynamic_op.c.

{
    dyn_char o1 = dyn_get_bool_3(dyn1);
    dyn_char o2 = dyn_get_bool_3(dyn2);

    if (o1 != DYN_NONE && o2 != DYN_NONE)
        dyn_set_bool(dyn1, o1 && o2);
    else if (o1 == DYN_FALSE || o2 == DYN_FALSE)
        dyn_set_bool(dyn1, DYN_FALSE);
    else
        dyn_free(dyn1);

    return DYN_TRUE;
}

dyn_op_div()

trilean dyn_op_div	(	dyn_c *	dyn1,
		dyn_c *	dyn2
	)

Divide dyn1 by dyn2.

Dividing is only performed onto NUMERIC values, for all other values DYN_FALSE gets returned.

Parameters

[in,out]	dyn1	in- and output parameter
[in]	dyn2	input parameter

Return values

DYN_TRUE	if operation could be applied onto the input data types
DYN_FALSE	otherwise

Definition at line 356 of file dynamic_op.c.

{
    CHECK_REFERENCE(dyn1, dyn2)

    if ( DYN_TYPE(dyn1) && DYN_TYPE(dyn2) ) {
        switch (max_type(dyn1, dyn2)) {
            case BOOL:
            case INTEGER:   dyn_set_int(dyn1, dyn_get_int(dyn1) / dyn_get_int(dyn2));
                            goto LABEL_OK;
            case FLOAT:     dyn_set_float(dyn1, dyn_get_float(dyn1) / dyn_get_float(dyn2));
                            goto LABEL_OK;
        }
    }

    dyn_free(dyn1);
    return DYN_FALSE;

LABEL_OK:
    return DYN_TRUE;
}

dyn_op_eq()

trilean dyn_op_eq	(	dyn_c *	dyn1,
		dyn_c *	dyn2
	)

Relational Equality.

Parameters

[in,out]	dyn1	in and output parameter
[in]	dyn2	exponent value

Returns

DYN_TRUE, can be performed onto any combination of types

Definition at line 850 of file dynamic_op.c.

Referenced by dyn_op_id().

{
    dyn_set_bool(dyn1, dyn_op_cmp(dyn1, dyn2)
                       ? DYN_FALSE
                       : DYN_TRUE);
    return DYN_TRUE;
}

dyn_op_ge()

trilean dyn_op_ge	(	dyn_c *	dyn1,
		dyn_c *	dyn2
	)

Relational Greater Than or Equal.

Parameters

[in,out]	dyn1	in and output parameter
[in]	dyn2	exponent value

Returns

DYN_TRUE, can be performed onto any combination of types

Definition at line 898 of file dynamic_op.c.

{
    dyn_op_lt(dyn1, dyn2);
    dyn_op_not(dyn1);       // NONE remains NONE

    return DYN_TRUE;
}

dyn_op_gt()

trilean dyn_op_gt	(	dyn_c *	dyn1,
		dyn_c *	dyn2
	)

Relational Greater Than.

Parameters

[in,out]	dyn1	in and output parameter
[in]	dyn2	exponent value

Returns

DYN_TRUE, can be performed onto any combination of types

Definition at line 912 of file dynamic_op.c.

Referenced by dyn_op_le().

{
    dyn_char rslt = dyn_op_cmp (dyn1, dyn2);

    // types not comparable
    if (rslt == 4)
        dyn_free(dyn1);
    else
        dyn_set_bool(dyn1, (rslt == 2)
                           ? DYN_TRUE
                           : DYN_FALSE );
    return DYN_TRUE;
}

dyn_op_id()

trilean dyn_op_id	(	dyn_c *	dyn1,
		dyn_c *	dyn2
	)

Type and Value Equality.

Parameters

[in,out]	dyn1	in and output parameter
[in]	dyn2	exponent value

Returns

DYN_TRUE, can be performed onto any combination of types

Definition at line 834 of file dynamic_op.c.

{
    if( DYN_TYPE(DYN_IS_REFERENCE(dyn1) ? dyn1->data.ref : dyn1) ==
        DYN_TYPE(DYN_IS_REFERENCE(dyn2) ? dyn2->data.ref : dyn2) )
      dyn_op_eq(dyn1, dyn2);
    else
      dyn_set_bool(dyn1, DYN_FALSE);
    return DYN_TRUE;
}

dyn_op_in()

trilean dyn_op_in	(	dyn_c *	element,
		dyn_c *	container
	)

Check if dyn2 is element of dyn1.

Can only be applied if the container is of type LIST, SET, or DICT.

Parameters

[in,out]	in	and output parameter
[in]	dyn2	exponent value

Return values

DYN_TRUE	if the operation could be applied
DYN_FALSE	otherwise

Definition at line 949 of file dynamic_op.c.

Referenced by dyn_set_insert().

{
    dyn_c *tmp = DYN_IS_REFERENCE(element) ? element->data.ref : element;

    if(DYN_IS_REFERENCE(container))
        container = container->data.ref;

    switch (DYN_TYPE(container)) {
        case SET:
        case LIST:
        case DICT:
            dyn_set_bool(element, search(container, tmp));
            return DYN_TRUE;
    }

    dyn_free(element);
    return DYN_FALSE;
}

dyn_op_le()

trilean dyn_op_le	(	dyn_c *	dyn1,
		dyn_c *	dyn2
	)

Relational Less Than or Equal.

Parameters

[in,out]	dyn1	in- and output parameter
[in]	dyn2	exponent value

Returns

DYN_TRUE, can be performed onto any combination of types

Definition at line 932 of file dynamic_op.c.

{
    dyn_op_gt(dyn1, dyn2);
    dyn_op_not(dyn1); // NONE remains NONE

    return DYN_TRUE;
}

dyn_op_lt()

trilean dyn_op_lt	(	dyn_c *	dyn1,
		dyn_c *	dyn2
	)

Relational Less Than.

Parameters

[in,out]	dyn1	in and output parameter
[in]	dyn2	exponent value

Returns

DYN_TRUE, can be performed onto any combination of types

Definition at line 878 of file dynamic_op.c.

Referenced by dyn_op_ge().

{
    dyn_char rslt = dyn_op_cmp (dyn1, dyn2);

    // types not comparable
    if (rslt == 4)
        dyn_free(dyn1);
    else
        dyn_set_bool(dyn1, (rslt == 1)
                           ? DYN_TRUE
                           : DYN_FALSE);
    return DYN_TRUE;
}

dyn_op_mod()

trilean dyn_op_mod	(	dyn_c *	dyn1,
		dyn_c *	dyn2
	)

dyn1 Modulo dyn2

Modulo can only be performed onto NUMERIC values, if these are of type FLOAT then they are casted to INTEGER, such that the result is always of type INTEGER.

Parameters

[in,out]	dyn1	in- and output(INTEGER) parameter
[in]	dyn2	input parameter

Return values

DYN_TRUE	if operation could be applied onto the input data types
DYN_FALSE	otherwise

Definition at line 388 of file dynamic_op.c.

{
    CHECK_REFERENCE(dyn1, dyn2)

    dyn_char t1 = DYN_TYPE(dyn1);
    dyn_char t2 = DYN_TYPE(dyn2);

    if ( (t1 && t2) && t1 <= FLOAT && t2 <= FLOAT ) {
        dyn_set_int(dyn1, dyn_get_int(dyn1) % dyn_get_int(dyn2));
        return DYN_TRUE;
    }

    dyn_free(dyn1);
    return DYN_FALSE;
}

dyn_op_mul()

trilean dyn_op_mul	(	dyn_c *	dyn1,
		dyn_c *	dyn2
	)

Multiply dyn1 with dyn2.

Multiplication generates different results according to the input data types. For NUMERIC and NUMERIC data types the common arithmetic multiplication gets applied and for the combination of: (LIST|STRING) * NUMERIC or NUMERIC * (LIST|STRING) results in a repeated string or repeated list, multiplication with ZERO generates an empty LIST or STRING, negative values are not allowed.

Parameters

[in,out]	dyn1	in- and output parameter
[in]	dyn2	input parameter

Return values

DYN_TRUE	if operation could be applied onto the input data types or values
DYN_FALSE	otherwise

Definition at line 271 of file dynamic_op.c.

{
    CHECK_REFERENCE(dyn1, dyn2)

    if (DYN_TYPE(dyn1) && DYN_TYPE(dyn2)) {
        switch (max_type(dyn1, dyn2)) {
            case BOOL:
            case INTEGER: dyn_set_int(dyn1, dyn_get_int(dyn1) * dyn_get_int(dyn2));
                          goto LABEL_OK;
            case FLOAT:   dyn_set_float(dyn1, dyn_get_float(dyn1) * dyn_get_float(dyn2));
                          goto LABEL_OK;
            case STRING:  {
                dyn_ushort i;
                if (DYN_TYPE(dyn1) == INTEGER && DYN_TYPE(dyn2) == STRING) {
                    i = dyn_get_int(dyn1);
                    dyn_copy(dyn2, dyn1);
                } else if (DYN_TYPE(dyn1) == STRING && DYN_TYPE(dyn2) == INTEGER)
                    i = dyn_get_int(dyn2);
                else
                    break;
                switch (i) {
                    case 0: dyn_set_string(dyn1, "");
                    case 1: break;
                    default: {
                        dyn_ushort len = dyn_strlen(dyn1->data.str);
                        dyn1->data.str = (dyn_str) realloc(dyn1->data.str, len * i + 1);

                        dyn_str c = &dyn1->data.str[len];
                        dyn_ushort j;
                        while(--i) {
                            for(j=0; j<len; ++j) {
                                *c++ = dyn1->data.str[j];
                            }
                        }
                        *c = '\0';
                    }
                }
                goto LABEL_OK;
            }
            case LIST: {
                dyn_ushort i;
                if (DYN_TYPE(dyn1) == INTEGER && DYN_TYPE(dyn2) == LIST) {
                    i = dyn_get_int(dyn1);
                    dyn_copy(dyn2, dyn1);
                } else if (DYN_TYPE(dyn1) == LIST && DYN_TYPE(dyn2) == INTEGER)
                    i = dyn_get_int(dyn2);
                else
                    break;

                dyn_ushort len = DYN_LIST_LEN(dyn1);
                if (!i) {
                    dyn_set_list_len(dyn1, 1);
                    goto LABEL_OK;
                }
                if (i > 0) {
                    if (dyn_list_resize(dyn1, DYN_LIST_LEN(dyn1)*i ) ) {
                        dyn_ushort m, n;
                        for (m=1; m<i; ++m) {
                            for (n=0; n<len; n++)
                                dyn_list_push(dyn1, DYN_LIST_GET_REF(dyn1 ,n));
                        }
                        goto LABEL_OK;
                    }
                }
            }
        }
    }

    dyn_free(dyn1);
    return DYN_FALSE;

LABEL_OK:
    return DYN_TRUE;
}

dyn_op_ne()

trilean dyn_op_ne	(	dyn_c *	dyn1,
		dyn_c *	dyn2
	)

Relational Not Equal.

Parameters

[in,out]	dyn1	in and output parameter
[in]	dyn2	exponent value

Returns

DYN_TRUE, can be performed onto any combination of types

Definition at line 864 of file dynamic_op.c.

{
    dyn_set_bool(dyn1, dyn_op_cmp(dyn1, dyn2)
                       ? DYN_TRUE
                       : DYN_FALSE);
    return DYN_TRUE;
}

dyn_op_neg()

trilean dyn_op_neg

(

dyn_c *

dyn

)

Negate dynamic value in param dyn.

The negation operation is only be applied onto numeric or boolean/trilean data types. For all other types the result of dyn is set to type NONE.

Parameters

dyn	in- and output dynamic element

Return values

DYN_TRUE	if operation could be applied onto the input data type
DYN_FALSE	otherwise

Definition at line 72 of file dynamic_op.c.

{
    CHECK_COPY_REFERENCE(dyn)

    switch (DYN_TYPE(dyn)) {
        case NONE:    goto LABEL_OK;
        case BOOL:    dyn->data.b = !dyn->data.b;
                      goto LABEL_OK;
        case INTEGER: dyn->data.i = -dyn->data.i;
                      goto LABEL_OK;
        case FLOAT:   dyn->data.f = -dyn->data.f;
                      goto LABEL_OK;
    }

    dyn_free(dyn);
    return DYN_FALSE;

LABEL_OK:
    return DYN_TRUE;
}

dyn_op_not()

trilean dyn_op_not

(

dyn_c *

dyn

)

Logical (trinary) Negation.

As depicted in the truth table below, this function performes the standard boolean NOT operation, the extention with the None boolean type does not affect this operation. The truth value of every dynamic element is generated with the help of function dyn_get_bool_3.

NOT	True	False	None
NOT	False	True	None

The result of this operation is stored within the first parameter dyn1, if this value is a reference, then a new value is created, otherwise the original value gets overwritten.

See also

dyn_get_bool_3

dyn_get_bool

Parameters

[out]

dyn

in- and output dynamic element

Returns

DYN_TRUE, operation can be applied on every combination of dynamic data types

Definition at line 658 of file dynamic_op.c.

Referenced by dyn_op_ge(), and dyn_op_le().

{
    CHECK_COPY_REFERENCE(dyn)

    if (DYN_NOT_NONE(dyn))
        dyn_set_bool(dyn, !dyn_get_bool_3(dyn));

    return DYN_TRUE;
}

dyn_op_or()

trilean dyn_op_or	(	dyn_c *	dyn1,
		dyn_c *	dyn2
	)

Logical (trinary) OR operation.

As depicted in the truth table below, this function performes the standard boolean OR operation, the extention with the None boolean type does not affect this operation. The truth value of every dynamic element is generated with the help of function dyn_get_bool_3.

OR	True	False	None
True	True	True	True
False	True	False	None
None	True	None	None

The result of this operation is stored within the first parameter dyn1, if this value is a reference, then a new value is created, otherwise the original value gets overwritten.

See also

dyn_get_bool_3

dyn_get_bool

Parameters

[out]	dyn1	in- and output dynamic element
[in]	dyn2	second operand

Returns

DYN_TRUE, operation can be applied on every combination of dynamic data types

Definition at line 582 of file dynamic_op.c.

{
    dyn_char o1 = dyn_get_bool_3(dyn1);
    dyn_char o2 = dyn_get_bool_3(dyn2);

    if (o1 != DYN_NONE && o2 != DYN_NONE)
        dyn_set_bool(dyn1, o1 || o2);
    else if (o1 == DYN_TRUE || o2 == DYN_TRUE)
        dyn_set_bool(dyn1, DYN_TRUE);
    else
        dyn_free(dyn1);

    return DYN_TRUE;
}

dyn_op_pow()

trilean dyn_op_pow	(	dyn_c *	dyn1,
		dyn_c *	dyn2
	)

dyn1 to the power of dyn2

Power function is only applied onto NUMERIC values less than FLOAT, in case of a FLOAT value the system pow function gets applied or in case of the usage of an embedded system, fast_approx_pow algorithm is applied.

Parameters

[in,out]	dyn1	base value and result value
[in]	dyn2	exponent value

Return values

DYN_TRUE	if operation could be applied onto the input data types
DYN_FALSE	otherwise

Definition at line 453 of file dynamic_op.c.

{
    CHECK_REFERENCE(dyn1, dyn2)

    if (DYN_IS_NONE(dyn1) || DYN_IS_NONE(dyn2)) {
        dyn_free(dyn1);
        return DYN_FALSE;
    }

    if (DYN_TYPE(dyn1) <= FLOAT && DYN_TYPE(dyn2) == FLOAT) {
        dyn_set_float(dyn1, fast_approx_pow(dyn_get_float(dyn1),
                                            dyn_get_float(dyn2)));
        return DYN_TRUE;
    }

    if (DYN_TYPE(dyn2) == INTEGER) {
        dyn_int exponent = dyn_get_int(dyn2);

        if (DYN_TYPE(dyn1) == INTEGER) {
            dyn_int base = dyn_get_int(dyn1);
            if (exponent > 0) {
                while (--exponent)
                    dyn1->data.i *= base;
            } else {
                dyn_set_float(dyn1, base);
                --exponent;
                while (exponent++)
                    dyn1->data.f /= base;
            }
            return DYN_TRUE;
        } else if (DYN_TYPE(dyn1) == FLOAT) {
            dyn_float base = dyn_get_float(dyn1);
            if (exponent > 0) {
                while (--exponent)
                    dyn1->data.f *= base;
            } else {
                --exponent;
                while (exponent++)
                    dyn1->data.f /= base;
            }
            return DYN_TRUE;
        }
    }

    dyn_free(dyn1);
    return DYN_FALSE;
}

dyn_op_sub()

trilean dyn_op_sub	(	dyn_c *	dyn1,
		dyn_c *	dyn2
	)

Subtract dyn2 from dyn1.

The subtract operation shows generates different results according to the input data types. Subtraction is allowed on numeric values and onto sets, where the second parameter defines the element/set that shoult be subtracted from the other set.

Parameters

[in,out]	dyn1	in- and output parameter
[in]	dyn2	input parameter

Return values

DYN_TRUE	if operation could be applied onto the input data types
DYN_FALSE	otherwise

Definition at line 211 of file dynamic_op.c.

{
    CHECK_REFERENCE(dyn1, dyn2)

    if ( DYN_TYPE(dyn1) && DYN_TYPE(dyn2) ) {
        switch (max_type(dyn1, dyn2)) {
            case BOOL:
            case INTEGER: dyn_set_int(dyn1, dyn_get_int(dyn1) - dyn_get_int(dyn2));
                          goto LABEL_OK;
            case FLOAT:   dyn_set_float(dyn1, dyn_get_float(dyn1) - dyn_get_float(dyn2));
                          goto LABEL_OK;
            case SET: {
                dyn_ushort pos;
                if (DYN_TYPE(dyn1) == DYN_TYPE(dyn2)) {
                    dyn_ushort i;
                    for (i=0; i<DYN_LIST_LEN(dyn2); ++i) {
                        pos = search(dyn1, DYN_LIST_GET_REF(dyn2, i));
                        if (pos)
                            dyn_list_remove(dyn1, pos-1);
                    }
                } else if (DYN_TYPE(dyn1) == SET) {
                    pos = search(dyn1, dyn2);
                    if (pos)
                        dyn_list_remove(dyn1, pos-1);
                } else {
                    dyn_c tmp;
                    DYN_INIT(&tmp);
                    dyn_move(dyn1, &tmp);
                    dyn_copy(dyn2, dyn1);
                    pos = search(dyn1, &tmp);
                    if (pos)
                        dyn_list_remove(dyn1, pos-1);
                }
                goto LABEL_OK;
            }
        }
    }

    dyn_free(dyn1);
    return DYN_FALSE;

LABEL_OK:
    return DYN_TRUE;
}

dyn_op_xor()

trilean dyn_op_xor	(	dyn_c *	dyn1,
		dyn_c *	dyn2
	)

Logical (trinary) XOR operation.

As depicted in the truth table below, this function performes the standard boolean XOR operation, the extention with the None boolean type does not affect this operation. The truth value of every dynamic element is generated with the help of function dyn_get_bool_3.

XOR	True	False	None
True	False	True	None
False	True	False	None
None	None	None	None

The result of this operation is stored within the first parameter dyn1, if this value is a reference, then a new value is created, otherwise the original value gets overwritten.

See also

dyn_get_bool_3

dyn_get_bool

Parameters

[out]	dyn1	in- and output dynamic element
[in]	dyn2	second operand

Returns

DYN_TRUE, operation can be applied on every combination of dynamic data types

Definition at line 623 of file dynamic_op.c.

{
    dyn_char o1 = dyn_get_bool_3(dyn1);
    dyn_char o2 = dyn_get_bool_3(dyn2);

    if (o1 != DYN_NONE && o2 != DYN_NONE)
        dyn_set_bool(dyn1, o1 != o2);
    else
        dyn_free(dyn1);

    return DYN_TRUE;
}