示例#1
0
Relation Relation::join(Relation r2) {
	// Combine the schemes and make a new empty relation that uses the combined schemes
	Relation join_result = Relation("temp_join");
	join_result.scheme = join_scheme(r2);

	// Find which attributes they have in common to prep for the join
	std::vector<std::pair<int, int>> common_attributes = get_common_attributes(r2);

	for (Tuple t1 : this->tuples) {
		for (Tuple t2 : r2.tuples) {
			if (common_attributes.size() > 0) {
				// Check if the tuples can join
				bool join = can_join(t1, t2, common_attributes);
				if (join) {
					// Build the joined tuple and add it to the new relation
					Tuple t = join_tuples(t1, t2, common_attributes);
					join_result.tuples.insert(t);
				}
			}
			else {
				Tuple t = do_product(t1, t2);
				join_result.tuples.insert(t);
			}
		}
	}

	return join_result;
}
示例#2
0
/*---------------------------------------------------------------------------
 *
 * Compute matrix product using naive triple-nested loops.
 *
 * Input
 *   int argc        - length of argv[] array
 *   char* argv[]    - pointer to command line parameter array
 *   int verbosity   - program verification: verbosity > 0 gives more output
 *   char* order     - string indicating loop order, e.g., "ijk" or "jki"
 *
 * Output
 *   double          - elapsed time for product computation
 */
double multiply_by_naive_product( int argc, char* argv[], int verbosity,
                                  char* order )
{
    int rows, cols, mids;
    double **a, **b, **c;
    double t1, t2;
    double sec;
    double gflop_count;

    /*
     * process command line arguments
     */
    rows = atoi( argv[0] );
    mids = atoi( argv[1] );
    cols = atoi( argv[2] );
    gflop_count = 2.0 * rows * mids * cols / 1.0e9;

    if ( verbosity > 0 )
    {
        printf( "naive(%3s): rows = %d, mids = %d, columns = %d\n",
                order, rows, mids, cols );
    }

    /*
     * allocate and initialize matrices
     */
    a = (double**) allocateMatrix( rows, mids );
    b = (double**) allocateMatrix( mids, cols );
    c = (double**) allocateMatrix( rows, cols );
    initialize_matrices( a, b, c, rows, cols, mids, verbosity );

    /*
     * compute product
     */
    t1 = wtime();
    do_product( a, b, c, 0, rows - 1, 0, cols - 1, 0, mids - 1 );
    t2 = wtime();
    sec = t2 - t1;

    if ( verbosity > 1 )
        printf( "checksum = %f\n", checksum( c, rows, cols ) );

    printf( "naive(%s):  %6.3f secs %6.3f gflops ( %5d x %5d x %5d )\n",
            order, sec, gflop_count / sec, rows, mids, cols );

    /*
     * clean up
     */
    deallocateMatrix( a );
    deallocateMatrix( b );
    deallocateMatrix( c );

    return t2 - t1;
}
示例#3
0
文件: ex6-10.c 项目: nflondo/myprog
int main(void){
 
 float num1, num2, result= 0 ;
 
 puts( "\nEnter two values: " );
 scanf( "%f %f", &num1, &num2 );
  
 result = do_product(num1, num2);
 
 printf("The product of a and b is:%f\n", result);
 
 return 0;

}
示例#4
0
/*---------------------------------------------------------------------------
 *
 * Computes block-oriented matrix-matrix product recursively.
 *
 * Input:
 *   double** c       - matrix product C = A * B
 *   double** a       - first factor of product
 *   double** b       - second factor of product
 *   int crow, ccol   - starting row and column of block of C
 *   int arow, acol   - starting row and column of block of A
 *   int brow, bcol   - starting row and column of block of B
 *   int l, m, n      - dims of blocks: A is l x m, B is m x n, C is l x n
 *   int N            - full row length (column dimension) of matrix B
 *   int threshold    - B blocks larger than this are partitioned
 *
 * Output:
 *   double** c       - matrix product C = A * B
 *
 * Algorithm based on one presented on page 276 of "Parallel Programming in
 * C with MPI and OpenMP", Michael J. Quinn, McGraw-Hill, 2004.
 *
 * **** NOTE ****: There is a typo in Quinn's code in the recursive call
 * to mm_rec().  The 5th parameter should be "ccol + nhalf[j]" and not
 * use "mhalf" as shown in the text.  The error only shows up when the
 * dimensions of the matrices are not uniform.
 */
void mm_rec( double** c, double** a, double** b,
             int crow, int ccol, int arow, int acol, int brow, int bcol,
             int l, int m, int n, int N, int threshold )
{
    int lhalf[3], mhalf[3], nhalf[3];
    int i, j, k;
    
    if ( m * n > threshold )
    {
        lhalf[0] = 0; lhalf[1] = l/2; lhalf[2] = l - lhalf[1];
        mhalf[0] = 0; mhalf[1] = m/2; mhalf[2] = m - mhalf[1];
        nhalf[0] = 0; nhalf[1] = n/2; nhalf[2] = n - nhalf[1];
        for ( i = 0; i < 2; i++ )
        {
            for ( j = 0; j < 2; j++ )
            {
                for ( k = 0; k < 2; k++ )
                {
                    mm_rec( c, a, b,
                            crow + lhalf[i], ccol + nhalf[j],
                            arow + lhalf[i], acol + mhalf[k],
                            brow + mhalf[k], bcol + nhalf[j],
                            lhalf[i + 1], mhalf[k + 1], nhalf[j + 1],
                            N, threshold );
                }
            }
        }
    }
    else
    {
        do_product( a, b, c,
                    arow, arow + l - 1,
                    bcol, bcol + n - 1,
                    acol, acol + m - 1 );
    }
}
示例#5
0
/*---------------------------------------------------------------------------
 *
 * Compute matrix product using tiling.  The loop order used for the tile
 * products is specified in string variable "mode".
 *
 * Input
 *   int argc        - length of argv[] array
 *   char* argv[]    - pointer to command line parameter array
 *   int verbosity   - program verification: verbosity > 0 gives more output
 *   char* order     - string indicating loop order, e.g., "ijk" or "jki"
 *
 * Output
 *   double          - elapsed time for product computation
 */
double multiply_by_tiles( int argc, char* argv[], int verbosity, char* order )
{
    int rows, cols, mids;
    int rows_per_tile, cols_per_tile, mids_per_tile;
    int row_start, row_end;
    int col_start, col_end;
    int mid_start, mid_end;
    double **a, **b, **c;
    double t1, t2;
    double sec;
    double gflop_count;

    /*
     * process command line arguments
     */
    rows = atoi( argv[0] );
    mids = atoi( argv[1] );
    cols = atoi( argv[2] );
    rows_per_tile = atoi( argv[3] );
    mids_per_tile = atoi( argv[4] );
    cols_per_tile = atoi( argv[5] );
    gflop_count = 2.0 * rows * mids * cols / 1.0e9;

    if ( verbosity > 0 )
    {
        printf( "Tiles(%3s): rows = %d, mids = %d, columns = %d\n",
                order, rows, mids, cols );
        printf( "block rows = %d, mids = %d, columns = %d\n",
                rows_per_tile, mids_per_tile, cols_per_tile );
    }

    /*
     * allocate and initialize matrices
     */
    a = (double**) allocateMatrix( rows, mids );
    b = (double**) allocateMatrix( mids, cols );
    c = (double**) allocateMatrix( rows, cols );
    initialize_matrices( a, b, c, rows, cols, mids, verbosity );

    /*
     * compute product
     */
    t1 = wtime();
    for ( row_start = 0; row_start < rows; row_start += rows_per_tile )
    {
        row_end = row_start + rows_per_tile - 1;
        if ( row_end >= rows ) row_end = rows - 1;
        for ( col_start = 0; col_start < cols; col_start += cols_per_tile )
        {
            col_end = col_start + cols_per_tile - 1;
            if ( col_end >= cols ) col_end = cols - 1;
            for ( mid_start = 0; mid_start < mids; mid_start += mids_per_tile )
            {
                mid_end = mid_start + mids_per_tile - 1;
                if ( mid_end >= mids ) mid_end = mids - 1;
                do_product( a, b, c, row_start, row_end, col_start,
                            col_end, mid_start, mid_end );
            }
        }
    }
    t2 = wtime();
    sec = t2 - t1;

    if ( verbosity > 1 )
        printf( "checksum = %f\n", checksum( c, rows, cols ) );

    printf( "tiles(%3s):  %6.3f secs %6.3f gflops ",
            order, sec, gflop_count / sec );
    printf( "( %5d x %5d x %5d ) ( %4d x %4d x %4d )\n",
            rows, mids, cols, rows_per_tile, mids_per_tile,
            cols_per_tile );

    /*
     * clean up
     */
    deallocateMatrix( a );
    deallocateMatrix( b );
    deallocateMatrix( c );

    return t2 - t1;
}