Esempio n. 1
0
File: min.hpp Progetto: okhat/ngraph
            void min(const T* arg,
                     T* out,
                     const Shape& in_shape,
                     const Shape& out_shape,
                     const AxisSet& reduction_axes)
            {
                T minval = std::numeric_limits<T>::has_infinity ? std::numeric_limits<T>::infinity()
                                                                : std::numeric_limits<T>::max();

                CoordinateTransform output_transform(out_shape);

                for (const Coordinate& output_coord : output_transform)
                {
                    out[output_transform.index(output_coord)] = minval;
                }

                CoordinateTransform input_transform(in_shape);

                for (const Coordinate& input_coord : input_transform)
                {
                    Coordinate output_coord = project(input_coord, reduction_axes);

                    T x = arg[input_transform.index(input_coord)];
                    T min = out[output_transform.index(output_coord)];
                    if (x < min)
                    {
                        out[output_transform.index(output_coord)] = x;
                    }
                }
            }
Esempio n. 2
0
BICAPI void safe_compute_transform_from_tags(
    int                 npoints, 
    Real                **tag_list1, 
    Real                **tag_list2, 
    Trans_type          trans_type,
    General_transform   *transform )
{
#if !HAVE_FORK
        compute_transform_from_tags( npoints, tag_list1, tag_list2, trans_type,
                                     transform );
#else
    int                 fildes[2];
    FILE                *fpin, *fpout;
    Status              status;
    int                 statptr;
    General_transform   computed_transform;

    /* Create a pipe */

    if (pipe(fildes)) {
        create_linear_transform(transform, NULL);
        return;
    }

    /* Fork */
    if (fork()) {          /* Parent */
        (void) close(fildes[1]);
        fpin = fdopen(fildes[0], "r");
        status = input_transform(fpin, NULL, transform);
        (void) fclose(fpin);
        do {
            (void) wait(&statptr);
        } while (WIFSTOPPED(statptr));
        if (WEXITSTATUS(statptr) || status != OK) {
           if( status == OK )
               delete_general_transform( transform );
           create_linear_transform(transform, NULL);
           return;
        }
    }

    else {                 /* Child */
        (void) close(fildes[0]);
        fpout = fdopen(fildes[1], "w");
        compute_transform_from_tags(npoints, tag_list1, tag_list2, trans_type,
                                    &computed_transform);
        status = output_transform(fpout, NULL, NULL, NULL, &computed_transform);
        delete_general_transform( &computed_transform );
        (void) fclose(fpout);
        if (status != OK) {
            exit(EXIT_FAILURE);
        }
        else {
           exit(EXIT_SUCCESS);
        }
    }

    return;
#endif
}
Esempio n. 3
0
            void reverse_sequence(const T* arg,
                                  T* out,
                                  const Shape& arg_shape,
                                  size_t batch_axis,
                                  size_t sequence_axis,
                                  U* sequence_lengths)
            {
                CoordinateTransform input_transform(arg_shape);
                for (const Coordinate& in_coord : input_transform)
                {
                    size_t batch_index = in_coord[batch_axis];
                    auto orig_seq_index = static_cast<size_t>(sequence_lengths[batch_index]);

                    if (orig_seq_index > arg_shape.at(sequence_axis))
                    {
                        throw ngraph_error(
                            "One of the elements of sequence lengths is greater than sequence axis "
                            "dimension");
                    }

                    if (orig_seq_index == 0)
                    {
                        orig_seq_index = 1;
                    }

                    size_t sequence_index = in_coord[sequence_axis] < orig_seq_index
                                                ? orig_seq_index - in_coord[sequence_axis] - 1
                                                : in_coord[sequence_axis];

                    //make a copy of in_coord and update sequence_index
                    Coordinate out_coord = in_coord;
                    out_coord[sequence_axis] = sequence_index;
                    out[input_transform.index(out_coord)] = arg[input_transform.index(in_coord)];
                }
            }
Esempio n. 4
0
File: sum.hpp Progetto: okhat/ngraph
            void sum(const T* arg,
                     T* out,
                     const Shape& in_shape,
                     const Shape& out_shape,
                     const AxisSet& reduction_axes)
            {
                CoordinateTransform output_transform(out_shape);

                for (const Coordinate& output_coord : output_transform)
                {
                    out[output_transform.index(output_coord)] = 0;
                }

                CoordinateTransform input_transform(in_shape);

                for (const Coordinate& input_coord : input_transform)
                {
                    Coordinate output_coord = project(input_coord, reduction_axes);

                    out[output_transform.index(output_coord)] +=
                        arg[input_transform.index(input_coord)];
                }
            }
Esempio n. 5
0
File: pad.hpp Progetto: okhat/ngraph
            void pad(const T* arg0,
                     const T* arg1,
                     T* out,
                     const Shape& arg0_shape,
                     const Shape& out_shape,
                     const Shape& padding_below,
                     const Shape& padding_above,
                     const Shape& padding_interior)
            {
                Coordinate input_start(arg0_shape.size(), 0); // start at (0,0,...,0)
                Coordinate input_end =
                    out_shape; // end at (d'0,d'1,...,d'n), the outer corner of the post-padding shape

                Strides input_strides(arg0_shape.size(), 1);

                AxisVector input_axis_order(arg0_shape.size());
                for (size_t i = 0; i < arg0_shape.size(); i++)
                {
                    input_axis_order[i] = i;
                }

                Strides input_dilation(arg0_shape.size());
                for (size_t i = 0; i < arg0_shape.size(); i++)
                {
                    input_dilation[i] = padding_interior[i] + 1;
                }

                // Need to cast these to CoordinateDiff in order to make CoordinateTransform happy.
                CoordinateDiff padding_below_signed;
                CoordinateDiff padding_above_signed;

                for (size_t i = 0; i < padding_below.size(); i++)
                {
                    padding_below_signed.push_back(padding_below[i]);
                    padding_above_signed.push_back(padding_above[i]);
                }

                CoordinateTransform input_transform(arg0_shape,
                                                    input_start,
                                                    input_end,
                                                    input_strides,
                                                    input_axis_order,
                                                    padding_below_signed,
                                                    padding_above_signed,
                                                    input_dilation);
                CoordinateTransform output_transform(out_shape);

                CoordinateTransform::Iterator output_it = output_transform.begin();

                for (const Coordinate& in_coord : input_transform)
                {
                    const Coordinate& out_coord = *output_it;

                    T v = input_transform.has_source_coordinate(in_coord)
                              ? arg0[input_transform.index(in_coord)]
                              : *arg1;

                    out[output_transform.index(out_coord)] = v;

                    ++output_it;
                }
            }