Exemplo n.º 1
0
  static void exec(DstBlock& dst, SrcBlock const& src)
  {
    VBlock const& vblock = src.get_vblk();
    MBlock const& mblock = src.get_mblk();

    cuda::Device_memory<DstBlock> dev_dst(dst, SYNC_OUT);
    cuda::Device_memory<VBlock const> dev_v(vblock);
    cuda::Device_memory<MBlock const> dev_m(mblock);

    // The ct_valid check above ensures that the order taken 
    // matches the storage order if reaches this point.
    if (SD == row && Type_equal<order_type, row2_type>::value)
    {
      cuda::vmmul_row(
        dev_v.data(),
        dev_m.data(),
        dev_dst.data(),
        dst.size(2, 0),    // number of rows
        dst.size(2, 1)     // length of each row
      );
    }
    else if (SD == col && Type_equal<order_type, row2_type>::value)
    {
      cuda::vmmul_col(
        dev_v.data(),
        dev_m.data(),
        dev_dst.data(),
        dst.size(2, 0),    // number of rows
        dst.size(2, 1)     // length of each row
      );
    }
    else if (SD == col && Type_equal<order_type, col2_type>::value)
    {
      cuda::vmmul_row(
        dev_v.data(),
        dev_m.data(),
        dev_dst.data(),
        dst.size(2, 1),    // number of cols
        dst.size(2, 0)     // length of each col
      );
    }
    else // if (SD == row && Type_equal<order_type, col2_type>::value)
    {
      cuda::vmmul_col(
        dev_v.data(),
        dev_m.data(),
        dev_dst.data(),
        dst.size(2, 1),    // number of cols
        dst.size(2, 0)     // length of each col
      );
    }
  }
Exemplo n.º 2
0
bool alhena_module_peaklow_record_pre( void *h, alhena_data_t *p_data, 
                                       int i_day, int i_end )
{
    peak_low_t *p_stat = (peak_low_t *)h;
    float f_highest, f_lowest;
    float f_flag_close = p_data->f_close[i_day];
    int i_record = p_stat->i_records;
    int i, i_start = 0;

    i_end = MIN( i_end, i_day + p_stat->i_max_stat_days );
    if( i_day >= i_end - 2 )
        return false;

#define RATIO1   (4.0f)

    for( i=1; i < i_day; i++ )
    {
        // FIXME: 80
        if( p_stat->fi[i_day-i] > avg_v( p_stat->fi, i_day - i, 80 )
                                  + RATIO1 * dev_v( p_stat->fi, i_day - i, 80 ) )
        {
            i_start = i_day - i;
            break;
        }
    }

    assert( i_start );

    p_stat->go_days[i_record] = i_day - i_start;

    for( i=1; i < i_start; i++ )
    {
        if( p_data->f_close[i_start - i] > p_data->f_close[i_start - i + 1] )
            break;

        p_stat->up_days[i_record]++;
    }

    if( i_start + 1 == i_day )
        p_stat->go_down[i_record] = (p_data->f_high[i_day] + p_data->f_low[i_day]) / 2;
    else
        p_stat->go_down[i_record] = avg_v( p_data->f_close, i_day, i_day - i_start - 1 );

    p_stat->go_down[i_record] = (p_stat->go_down[i_record] - p_data->f_close[i_start]) 
                              / p_data->f_close[i_start];

    /* find lowest */
    f_highest = .0f;
    f_lowest  = 8000.0f;

    for( i=i_day+1; i<i_end; i++ )    
    {
        if( p_data->f_high[i] > f_highest )
        {
            f_highest = p_data->f_high[i];
            p_stat->highest_day[i_record] = i - i_day;
        }
    }

    p_stat->highest[i_record] = (f_highest - f_flag_close) / f_flag_close;
    i_end = i_day + p_stat->highest_day[i_record];

    for( i=i_day+1; i<=i_end; i++ )
    {
        if( p_data->f_low[i] < f_lowest )
        {
            f_lowest = p_data->f_low[i];
            p_stat->lowest_day1[i_record] = i - i_day;
        }
    }

    p_stat->lowest1[i_record] = (f_lowest - f_flag_close) / f_flag_close;

    p_stat->day[i_record].i_day   = p_data->day[i_day].i_day;
    p_stat->day[i_record].i_month = p_data->day[i_day].i_month;
    p_stat->day[i_record].i_year  = p_data->day[i_day].i_year;    

    p_stat->i_records++;

    return true;
#undef RATIO1
}