C++ (Cpp) sol_flow_packet_get_drange_valueの例

コード例 #1

ファイル: float.c プロジェクト: kalyankondapally/soletta

static int
pow_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
    struct drange_pow_data *mdata = data;
    double value, result;
    int r;

    r = sol_flow_packet_get_drange_value(packet, &value);
    SOL_INT_CHECK(r, < 0, r);

    if (port == 0) {
        if (mdata->var0_initialized &&
            sol_drange_val_equal(mdata->var0, value))
            return 0;
        mdata->var0 = value;
        mdata->var0_initialized = true;
    } else {
        if (mdata->var1_initialized &&
            sol_drange_val_equal(mdata->var1, value))
            return 0;
        mdata->var1 = value;
        mdata->var1_initialized = true;
    }

    if (!(mdata->var0_initialized && mdata->var1_initialized))
        return 0;

    errno = 0;
    result = pow(mdata->var0, mdata->var1);
    SOL_INT_CHECK(errno, != 0, -errno);

    return sol_flow_send_drange_value_packet(node,
        SOL_FLOW_NODE_TYPE_FLOAT_POW__OUT__OUT, result);
}

コード例 #2

ファイル: float.c プロジェクト: gpaes/soletta

static int
classify_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
    double value;
    int r;

    r = sol_flow_packet_get_drange_value(packet, &value);
    SOL_INT_CHECK(r, < 0, r);

    switch (fpclassify(value)) {
    case FP_NAN:
        sol_flow_send_drange_value_packet(node, SOL_FLOW_NODE_TYPE_FLOAT_CLASSIFY__OUT__NAN, value);
        break;
    case FP_INFINITE:
        sol_flow_send_drange_value_packet(node, SOL_FLOW_NODE_TYPE_FLOAT_CLASSIFY__OUT__INFINITE, value);
        break;
    case FP_ZERO:
        sol_flow_send_drange_value_packet(node, SOL_FLOW_NODE_TYPE_FLOAT_CLASSIFY__OUT__ZERO, value);
        break;
    case FP_SUBNORMAL:
        sol_flow_send_drange_value_packet(node, SOL_FLOW_NODE_TYPE_FLOAT_CLASSIFY__OUT__SUBNORMAL, value);
        break;
    default:
        sol_flow_send_drange_value_packet(node, SOL_FLOW_NODE_TYPE_FLOAT_CLASSIFY__OUT__NORMAL, value);
    }

    return 0;
}

コード例 #3

ファイル: unix-socket.c プロジェクト: ChunHungLiu/soletta

static int
float_writer_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
    struct unix_socket_data *mdata = data;
    int r;
    double val;

    r = sol_flow_packet_get_drange_value(packet, &val);
    SOL_INT_CHECK(r, < 0, r);

    return unix_socket_write(mdata->un_socket, &val, sizeof(val));
}

コード例 #4

ファイル: float.c プロジェクト: kalyankondapally/soletta

static int
abs_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
    double value, result;
    int r;

    r = sol_flow_packet_get_drange_value(packet, &value);
    SOL_INT_CHECK(r, < 0, r);

    result = fabs(value);

    return sol_flow_send_drange_value_packet(node,
        SOL_FLOW_NODE_TYPE_FLOAT_ABS__OUT__OUT, result);
}

コード例 #5

ファイル: float.c プロジェクト: kalyankondapally/soletta

static int
sqrt_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
    double value, result;
    int r;

    r = sol_flow_packet_get_drange_value(packet, &value);
    SOL_INT_CHECK(r, < 0, r);

    if (isless(value, 0)) {
        SOL_WRN("Number can't be negative");
        return -EDOM;
    }

    result = sqrt(value);

    return sol_flow_send_drange_value_packet(node,
        SOL_FLOW_NODE_TYPE_FLOAT_SQRT__OUT__OUT, result);
}

コード例 #6

ファイル: servo-motor.c プロジェクト: ricardotk/soletta

static int
angle_set(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
    double in_value;
    struct servo_motor_data *mdata = data;
    int r, pulse_width;

    r = sol_flow_packet_get_drange_value(packet, &in_value);
    SOL_INT_CHECK(r, < 0, r);

    if (isless(in_value, 0) || isgreaterequal(in_value, 180)) {
        SOL_WRN("Invalid value %f. It must be >= 0 and < 180", in_value);
        return -EINVAL;
    }

    pulse_width = in_value * mdata->duty_cycle_diff / 180 +
        mdata->duty_cycle_range.min;

    return set_pulse_width(mdata, pulse_width);
}

コード例 #7

ファイル: float.c プロジェクト: kalyankondapally/soletta

static int
min_max_process(struct sol_flow_node *node, void *data, uint16_t port, uint16_t conn_id, const struct sol_flow_packet *packet)
{
    struct drange_min_max_data *mdata = data;
    double *result;
    int r;

    r = sol_flow_packet_get_drange_value(packet, &mdata->val[port]);
    SOL_INT_CHECK(r, < 0, r);

    mdata->val_initialized[port] = true;
    if (!(mdata->val_initialized[0] && mdata->val_initialized[1]))
        return 0;

    if (mdata->func(mdata->val[0], mdata->val[1]))
        result = &mdata->val[0];
    else
        result = &mdata->val[1];

    return sol_flow_send_drange_value_packet(node, mdata->port, *result);
}

コード例 #8

ファイル: float.c プロジェクト: kalyankondapally/soletta

static int
ln_process(struct sol_flow_node *node,
    void *data,
    uint16_t port,
    uint16_t conn_id,
    const struct sol_flow_packet *packet)
{
    double value, result;
    int r;

    r = sol_flow_packet_get_drange_value(packet, &value);
    SOL_INT_CHECK(r, < 0, r);

    if (fpclassify(value) == FP_ZERO || islessequal(value, 0.0)) {
        SOL_WRN("Number can't be negative or too close to zero");
        return -EDOM;
    }

    result = log(value);

    return sol_flow_send_drange_value_packet(node,
        SOL_FLOW_NODE_TYPE_FLOAT_LN__OUT__OUT, result);
}