Пример #1
0
int main() {
    // produce llvm.memcpy's
    char carray[LEN] = {1, 3, 5, 3, 2, 5, 3, 5, 3, 5, -2, 100};
    short int sarray[LEN] = {-1, -3, -5, -3, -2, -5, -3, -5, -3, -5, 2, 100};
    int array[LEN] = {-1, -3, -5, -3, -2, -5, -3, -5, -3, -5, 2, 100};
    long long larray[LEN] = {1, 3, 5, 3, 2, 5, 3, 5, 3, 5, -2, 100};

    int i, sum = arr_sum(carray, sarray, array, larray);

    empty_byte(carray);
    empty_short(sarray);
    empty_word(array);
    empty_long(larray);

    sum += arr_sum(carray, sarray, array, larray);

    printf("Result: %d\n", sum);
    if (sum == 400) {
        printf("RESULT: PASS\n");
    } else {
        printf("RESULT: FAIL\n");
    }

    return sum;
}
Пример #2
0
float arr_average(int arr[], int length)
{
    int sum = arr_sum(arr, length);
    float average = (float)sum / length;
    
    return average;
}
Пример #3
0
int main(int argc, char *argv[])
{
	double arr[] = {1,2,3,-1,5.5,5.5};
	double arrTwo[] ={10,20,30,40,50};
	double *resultArr;
	double number = 5.5;
	int i, arrSize = sizeof(arr)/sizeof(double);

	printf("arr_min = %.3lf \n", arr_min(arr,arrSize));
	printf("arr_max = %.3lf \n", arr_max(arr,arrSize));
	printf("arr_average = %.3lf \n", arr_average(arr,arrSize));
	printf("arr_sum = %.3lf \n", arr_sum(arr,arrSize));
	printf("arr_contains %lf, %d times. \n", number, arr_contains(arr,arrSize,number));
	puts("Now we merge arays");
	resultArr = arr_merge(arr, arrSize, arrTwo,5);
	for (i = 0; i < arrSize +5; ++i)
	{
		printf("arr[%d] = %.3lf \n", i, resultArr[i]);
	}
	puts("After arr_clear:");
	arr_clear(arr,arrSize);
	for (i = 0; i < arrSize; ++i)
	{
		printf("arr[%d] = %.3lf \n", i, arr[i]);
	}

	return 0;

}
double arr_average(double array[], int arrLength)
{
    double sum = arr_sum(array, arrLength);
    double average = sum / arrLength;

    return average;
}
Пример #5
0
int main(void) {
  int a1[] = {3, 4, 5, 6, 7, -1, -6, 19, 8, 9, 15, -4, 3, 3, 10, 11, 12};
  int a2[] = {-1, 1,  40, -2, 3, 4, -7, 4, -9, 5, 6,
              2,  -1, -1, -1, 1, 1, 1,  1, -1, 1, 1};
  int m3[] = {
      -4, 3,  2,  1,  // r1
      5,  6,  -8, -8, // r2
      33, 3,  3,  1,  // r3
      -4, -4, -4, -4, // r4
  };

  puts("Task 1");
  for (unsigned int i = 0; i < LEN(a1); i++)
    printf("%d ", a1[i]);
  puts("");
  print_n_min(a1, LEN(a1), 5);
  puts("\n");

  puts("Task 2");
  place_negatives_first(a2, LEN(a2));
  for (unsigned int i = 0; i < LEN(a2); i++)
    printf("%d ", a2[i]);
  puts("\n");

  puts("Matrix:");
  for (int i = 1; i <= 4; i++) {
    for (int j = 1; j <= 4; j++)
      printf("%d\t", m3[mat_to_arr(i, j, 4)]);
    puts("");
  }
  puts("");

  puts("Task 3");
  printf("Min: %d, max: %d, avg: %lf, sum: %lld, mdsum: %lld, sdsum: %lld\n\n",
         arr_min(m3, LEN(m3)), arr_max(m3, LEN(m3)), arr_avg(m3, LEN(m3)),
         arr_sum(m3, LEN(m3)), arr_diagonal_sum(m3, 4, LEN(m3)),
         arr_subdiagonal_sum(m3, 4, LEN(m3)));

  puts("Task 4");
  swap_ext_rows(m3, 4, 4);
  puts("Matrix:");
  for (int i = 1; i <= 4; i++) {
    for (int j = 1; j <= 4; j++)
      printf("%d\t", m3[mat_to_arr(i, j, 4)]);
    puts("");
  }
  puts("");

  return 0;
}
Пример #6
0
int main()
{   
    double arrayA[size];
    double arrayB[size];
    double searchedElement;
    int isFound;
    printf("Size of arrays is %d.\n", size);
    printf("Enter elements of arrayA\n");
    for(int i=0; i<size; i++)
    {
        scanf("%lf", &arrayA[i]);
    }  
    printf("Min element=%.2lf\n", arr_min(arrayA, size));
    printf("Max element=%.2lf\n", arr_max(arrayA, size));
    printf("Average sum of elements is %lf\n", arr_average(arrayA, size));
    printf("Sum of elements is %lf\n", arr_sum(arrayA, size));
    printf("Enter element you are looking for: ");
    scanf("%lf", &searchedElement);
    isFound=arr_contains(arrayA, size, searchedElement);
    printf(isFound? "The element is in the array\n":"The element is not in the array\n");
    printf("Enter elements of arrayB:\n");
    for(int i=0; i<size; i++)
    {
        scanf("%lf", &arrayB[i]);
    }
    double *mergedArray=arr_merge(arrayA, arrayB, size, size);
    printf("Merged array is:");
    for(int i=0; i< 2*size ; i++)
    {
        printf("%.2lf ", mergedArray[i]);
    }
    free(mergedArray);
    printf("\n");
    printf("Cleared array is: ");
    arr_clear(arrayA, size);
    for(int i=0; i<size; i++)
    {
        printf("%.2lf ", arrayA[i]);
    }
    
    return 0;
}
Пример #7
0
int main()
{
	int numbers[] = { 12, 2, 23, 41, 5, 6, 7, 8, 1 , 4};
	int length = sizeof(numbers) / sizeof(int);

	int mina = arr_min(numbers, length);
	printf("Min is: %d\n", mina);

	int max = arr_max(numbers, length);
	printf("Max is: %d\n", max);
	
	double average = arr_average(numbers, length);
	printf("Average is: %0.4lf\n", average);
	
	long sum = arr_sum(numbers, length);
	printf("Sum is: %u\n", sum);
	
	int element = 431;
	int contains = arr_contains(numbers, length, element);
	if(contains == 1)
	{
		printf("The array contains: %d\n", element);
	} else
	{
		printf("The array does not contain: %d\n", element);
	}

	int *ptr = arr_merge(numbers, length, numbers, length);
	printf("%d == %d %d == %d \n", ptr[0], ptr[10], ptr[1], ptr[11]);
	free(ptr);

	arr_clear(numbers, length);
	printf("%d %d\n", numbers[0], numbers[1]);

	return 0;
}
Пример #8
0
int main(int argc, char *argv[])
{
    /* Important definitions */
    // Lengths
    size_t N = 0;  // Length of time series
    size_t M = 0;  // Length of sampling vector (number of frequencies)

    // Filenames
    char inname[100];
    char outname[100];

    // Sampling
    double low, high, rate;

    // Frequency of window function
    double winfreq = 0;

    // Options
    int quiet = 0;
    int unit = 1;
    int prep = 1;
    int autosamp = 0;
    int fast = 0;
    int useweight = 0;
    int windowmode = 0;
    int Nclean = 0;
    int filter = 0;

    
    /* Process command line arguments and return line count of the input file */
    N = cmdarg(argc, argv, inname, outname, &quiet, &unit, &prep, &low, &high,\
               &rate, &autosamp, &fast, &useweight, &windowmode, &winfreq,\
               &Nclean, &filter, NULL, NULL);
    
    // Pretty print
    if ( quiet == 0 || fast == 1 ){
        if ( windowmode == 0 && useweight != 0 )
            printf("\nCalculating the weighted power spectrum of \"%s\" ...\n",\
                   inname);
        else if ( windowmode == 0 )
            printf("\nCalculating the power spectrum of \"%s\" ...\n", inname);
        else
            printf("\nCalculating the window function of \"%s\" ...\n", inname);
    }
    

    /* Read data (and weights) from the input file */
    if ( quiet == 0 ) printf(" - Reading input\n");
    double* time = malloc(N * sizeof(double));
    double* flux = malloc(N * sizeof(double));
    double* weight = malloc(N * sizeof(double));
    readcols(inname, time, flux, weight, N, useweight, unit, quiet);
    
    // Do if fast-mode and window-mode is not activated
    if ( fast == 0 && windowmode == 0 ) {
        // Calculate Nyquist frequency
        double* dt = malloc(N-1 * sizeof(double));
        double nyquist;
        arr_diff(time, dt, N);
        nyquist = 1.0 / (2.0 * arr_median(dt, N-1)) * 1e6; // microHz !
        free(dt);

        // Calculate suggested sampling (4 times oversampling)
        double minsamp;
        minsamp = 1.0e6 / (4 * (time[N-1] - time[0])); // microHz !
    
        // Display info?
        if ( quiet == 0 ){
            printf(" -- INFO: Length of time series = %li\n", N);
            printf(" -- INFO: Nyquist frequency = %.2lf microHz\n", nyquist);
            printf(" -- INFO: Suggested minimum sampling = %.3lf microHz\n",\
                   minsamp);
        }

        // Apply automatic sampling?
        if ( autosamp != 0 ) {
            low = 5.0;
            high = nyquist;
            rate = minsamp;
        }
    }

    
    /* Prepare for power spectrum */
    // Calculate proper frequency range for window-function-mode
    double limit = 0;
    if ( windowmode != 0 ) {
        limit = low;
        low = winfreq - limit;
        high = winfreq + limit;
    }
    
    // Get length of sampling vector
    M = arr_util_getstep(low, high, rate);

    // Fill sampling vector with cyclic frequencies
    double* freq = malloc(M * sizeof(double));
    arr_init_linspace(freq, low, rate, M);

    // Initialise arrays for data storage
    double* power = malloc(M * sizeof(double));
    double* alpha = malloc(M * sizeof(double));
    double* beta = malloc(M * sizeof(double));


    /* Calculate power spectrum OR window function */
    if ( windowmode == 0 ) {
        // Subtract the mean to avoid "zero-frequency" problems
        if ( prep != 0 ) {
            if ( quiet == 0 ){
                printf(" - Subtracting the mean from time series\n");
            }
            arr_sca_add(flux, -arr_mean(flux, N), N);
        }
        else {
            if ( quiet == 0 )
                printf(" - Time series used *without* mean subtraction!\n");
        }
    
        // Display info
        if ( quiet == 0 ){
            printf(" - Calculating fourier transform\n");
            if ( autosamp != 0 ) {
                printf(" -- NB: Using automatic sampling!\n");
                printf(" -- INFO: Auto-sampling (in microHz): %.2lf to %.2lf"\
                       " in steps of %.4lf\n", low, high, rate);
            }
            else {
                printf(" -- INFO: Sampling (in microHz): %.2lf to %.2lf in"\
                       " steps of %.4lf\n", low, high, rate);
            }
            printf(" -- INFO: Number of sampling frequencies = %li\n", M);
        }

        // Calculate power spectrum with or without weights
        fourier(time, flux, weight, freq, N, M, power, alpha, beta, useweight);
    }
    else {
        if ( quiet == 0 ){
            printf(" - Calculating window function\n");
            printf(" -- INFO: Window frequency = %.2lf microHz\n", winfreq);
            printf(" -- INFO: Sampling in the range +/- %.2lf microHz in" \
                   " steps of %.4lf microHz\n", limit, rate);
            printf(" -- INFO: Number of sampling frequencies = %li\n", M);
        }

        // Calculate spectral window with or without weights
        windowfunction(time, freq, weight, N, M, winfreq, power, useweight);

        if ( quiet == 0 )
            printf(" - Sum of spectral window = %.4lf\n", arr_sum(power, M));

        // Move frequencies to the origin
        arr_sca_add(freq, -winfreq, M);
    }

        
    /* Write data to file */
    if ( quiet == 0 ) printf(" - Saving to file \"%s\"\n", outname);
    writecols(outname, freq, power, M);

    
    /* Free data */
    free(time);
    free(flux);
    free(weight);
    free(freq);
    free(power);
    free(alpha);
    free(beta);


    /* Done! */
    if ( quiet == 0 || fast ==1 ) printf("Done!\n\n");
    return 0; 
}
Пример #9
0
/** Train the unsupervised SOM network.
 *
 * The network is initialized with random (non-graduate) values. It is then
 * trained with the image pixels (RGB). Once the network is done training the
 * centroids of the resulting clusters is returned.
 *
 * @note The length of the clusters depends on the parameter 'n'. The greatest
 *  n, the more colors in the clusters, the less posterized the image.
 *
 * @param[out] res       The resulting R, G and B clusters centroids.
 * @param[in]  imgPixels The original image pixels.
 * @param[in]  nbPixels  The number of pixels of th image (height * width).
 * @param[in]  nbNeurons The posterization leveldefined by its number of 
 *                       neurons.
 * @param[in]  noEpoch   Number of training passes (a too small number of epochs
 *  won't be enough for the network to correctly know the image but a too high
 *  value will force the network to modify the wieghts so much that the image
 *  can actually looks "ugly").
 * @param[in]  thresh    The threshold value. The SOM delta parameter and the
 *  training rate are dicreasing from one epoch to the next. The treshold value
 *  set a stop condifition in case the value has fallen under this minimum 
 *  value.
 *
 * @return SOM_OK if everything goes right or SOM_NO_MEMORY if a memory 
 *  allocation (malloc) fail.
 */
int som_train(float **res, float **imgPixels, unsigned int nbPixels,
              int nbNeurons, int noEpoch, float thresh){
    int mapWidth =              // Map width. This can be calculated from its
        (int)sqrt(nbNeurons);   // number of neurons as the map is square.
    int mapHeight =             // Map height. This can be calculated from its
        (int)sqrt(nbNeurons);   // number of neurons as the map is square.
    float delta = INT_MAX;      // Start with an almost impossible value
    int it = 0;                 // Count the network iterations
    unsigned int pick;          // The choosen input pixel
    float rad;                  // Neighbooring radius (keep dicreasing)
    float eta;                  // Learning rate (keep dicreasing)
    float pickRGB[3] = {0};     // Contains the choosen input RGB vector
    size_t choosen;             // Best Matching Unit (BMU)
    int choosen_x;              // BMU abscissa
    int choosen_y;              // BMU ordinate
    float *neigh =              // Neighbooring mask
        malloc(sizeof(float) * nbNeurons);
	if(neigh == NULL){
		return SOM_NO_MEMORY;
    }
    memset(neigh, 0, nbNeurons);

    float *WR =                 // RED part of the network weight vectors
        malloc(sizeof(float) * nbNeurons);
	if(WR == NULL){
		return SOM_NO_MEMORY;
    }
    memset(WR, 0, nbNeurons);
    float *WG =                 // GREEN part of the network weight vectors
        malloc(sizeof(float) * nbNeurons);
	if(WG == NULL){
		return SOM_NO_MEMORY;
    }
    memset(WG, 0, nbNeurons);
    float *WB =                 // BLUE part of the network weight vectors
        malloc(sizeof(float) * nbNeurons);
	if(WB == NULL){
		return SOM_NO_MEMORY;
    }
    memset(WB, 0, nbNeurons);

    float *deltaR =             // New RED part of the network weight vectors
        malloc(sizeof(float) * nbNeurons);
	if(deltaR == NULL){
		return SOM_NO_MEMORY;
    }
    memset(deltaR, 0, nbNeurons);
    float *deltaG =             // New GREEN part of the network weight vectors
        malloc(sizeof(float) * nbNeurons);
	if(deltaG == NULL){
		return SOM_NO_MEMORY;
    }
    memset(deltaG, 0, nbNeurons);
    float *deltaB =             // New BLUE part of the network weight vectors
        malloc(sizeof(float) * nbNeurons);
	if(deltaB == NULL){
		return SOM_NO_MEMORY;
    }
    memset(deltaB, 0, nbNeurons);

    float *absDeltaR =          // Absolute value of deltaR
        malloc(sizeof(float) * nbNeurons);
	if(absDeltaR == NULL){
		return SOM_NO_MEMORY;
    }
    memset(absDeltaR, 0, nbNeurons);
    float *absDeltaG =          // Absolute value of deltaG
        malloc(sizeof(float) * nbNeurons);
	if(absDeltaG == NULL){
		return SOM_NO_MEMORY;
    }
    memset(absDeltaG, 0, nbNeurons);
    float *absDeltaB =          // Absolute value of deltaB
        malloc(sizeof(float) * nbNeurons);
	if(absDeltaB == NULL){
		return SOM_NO_MEMORY;
    }
    memset(absDeltaB, 0, nbNeurons);

    float *dists =              // Vectors euclidian distances from input form
        malloc(sizeof(float) * nbNeurons);
	if(dists == NULL){
		return SOM_NO_MEMORY;
    }
    memset(dists, 0, nbNeurons);

    /* Randomly initialize weight vectors */
    srand(time(NULL));
    random_sample(WR, nbNeurons);
    random_sample(WG, nbNeurons);
    random_sample(WB, nbNeurons);

    while(it < noEpoch && delta >= thresh){
        /* Randomly choose an input form */
        pick = random_uint(nbPixels);
        pickRGB[0] = imgPixels[pick][0];
        pickRGB[1] = imgPixels[pick][1];
        pickRGB[2] = imgPixels[pick][2];

        /* Compute every vectors euclidian distance from the input form */
        euclidian(dists, nbNeurons, WR, WG, WB, pickRGB);
        /* Determine the BMU */
        choosen = arr_min_idx(dists, nbNeurons);
        choosen_x = (int)choosen % mapWidth;
        choosen_y = choosen / mapHeight;

        /* Compute the new neighbooring radius */
        rad = som_radius(it, noEpoch, mapWidth, mapHeight);
        /* Find the BMU neighboors */
        som_neighbourhood(neigh, choosen_x, choosen_y, rad, mapWidth, 
                          mapHeight);

        /* Compute the new learning rate */
        eta = som_learning_rate(it, noEpoch);
        /* Compute new value of the network weight vectors */
        compute_delta(deltaR, eta, neigh, nbNeurons, pickRGB[0], WR);
        compute_delta(deltaG, eta, neigh, nbNeurons, pickRGB[1], WG);
        compute_delta(deltaB, eta, neigh, nbNeurons, pickRGB[2], WB);
        /* Update the network weight vectors values */
        arr_add(WR, deltaR, nbNeurons);
        arr_add(WG, deltaG, nbNeurons);
        arr_add(WB, deltaB, nbNeurons);

        arr_abs(absDeltaR, deltaR, nbNeurons);
        arr_abs(absDeltaG, deltaG, nbNeurons);
        arr_abs(absDeltaB, deltaB, nbNeurons);
        delta = arr_sum(absDeltaR, nbNeurons) +
                arr_sum(absDeltaG, nbNeurons) +
                arr_sum(absDeltaB, nbNeurons);

        it++;
    }
    res[0] = WR;
    res[1] = WG;
    res[2] = WB;

    free(dists);
    free(deltaR);
    free(deltaG);
    free(deltaB);
    free(absDeltaR);
    free(absDeltaG);
    free(absDeltaB);
    free(neigh);

    return SOM_OK;
}
Пример #10
0
double arr_average(double *arr, int len)
{
    return arr_sum(arr, len)/(double)len;
}
int main()
{
    int n;
    if (scanf("%d", &n) != 1)
    {
        printf("Invalid input!");
        return 1;
    }

    double numbers[n];
    int i;
    for (i = 0; i < n; i++)
    {
        scanf("%lf", &numbers[i]);
    }

    int length = lengthArr(numbers);
    int zeroFraction = count_of_zero_fractions(numbers, length);
    int notZeroFraction = length - zeroFraction;
    double fractioned[notZeroFraction];
    double zeroFractioned[zeroFraction];
    int j= 0, k = 0;
    for (i = 0; i < n; i++)
    {
        if (fmod(numbers[i], 1) == 0)
        {
            zeroFractioned[j] = numbers[i];
            j++;
        }
        else
        {
            fractioned[k] = numbers[i];
            k++;
        }
    }
    double fractionedMin = arr_min(fractioned, notZeroFraction);
    double zeroFractionedMin = arr_min(zeroFractioned, zeroFraction);

    double fractionedMax = arr_max(fractioned, notZeroFraction);
    double zeroFractionedMax = arr_max(zeroFractioned, zeroFraction);

    double fractionedSum = arr_sum(fractioned, notZeroFraction);
    double zeroFractionedSum = arr_sum(zeroFractioned, zeroFraction);

    double fractionedAvg = arr_average(fractioned, notZeroFraction);
    double zeroFractionedAvg = arr_average(zeroFractioned, zeroFraction);

    printf("\n");
    print_array(fractioned, notZeroFraction);
    printf(" -> min: %.3lf", fractionedMin);
    printf(", max: %.3lf", fractionedMax);
    printf(", sum: %.3lf", fractionedSum);
    printf(", avg: %.2lf", fractionedAvg);
    printf("\n");
    print_array(zeroFractioned, zeroFraction);
    printf(" -> min: %.lf", zeroFractionedMin);
    printf(", max: %.lf", zeroFractionedMax);
    printf(", sum: %.lf", zeroFractionedSum);
    printf(", avg: %.2lf", zeroFractionedAvg);

    printf("\n");

    return 0;
}