How to use #pragma omp task with #pragma omp simd - c

Question

I want to write a parallel program that computes a perimeter, area and diagonal of multiple rectangles. The way I thought is to use a functional parallelism to build my program.
First, the perimeter, area and diagonal measures will be parallelized.
In my program, to compute these measures, I'm using #pragma omp for to divide loop iterations into threads and #pragma omp simd to vectorize the computation. But the problem is that I need to use #pragma omp task that represents a non-structured functional parallelism in the code but I don´t know how to use it with #pragma omp simd.
I know if I use in the way shown below, I'll be vectorizing the task creation, what makes no sense to SIMD architecture.
If someone could explain how to use #pragma omp for, #pragma omp simd and #pragma omp task, I'll be very grateful.
My code:
#include<stdio.h>
#include<stdlib.h>
#include<omp.h>
#include<math.h>
#include<time.h>
#define NUM_THREADS 4
/**
* This program computes three measures of a rectangle
* 1. Perimeter ==> P = 2B + 2H
* 2. Area ==> A = BH
* 3. Diagonal ==> D^2 = B^2 + H^2
*
*
*
* You must use these 4 directives: parallel, for, simd, task
*/
enum {
BASE = 0,
HEIGHT = 1,
};
#pragma omp declare simd
double compute_perimeter(double base, double height){ return (2 * base + 2 * height); }
#pragma omp declare simd
double compute_area(double base, double height){ return (base * height); }
#pragma omp declare simd
double compute_diagonal(double base, double height){ return (sqrt((base * base) + (height * height))); }
double ** generate_rectangles(size_t n){
double ** rectangles = (double **)malloc(n * sizeof(double *));
for(size_t i = 0; i < n; ++i){
rectangles[i] = (double *)malloc(n * sizeof(double));
for(size_t j = 0; j < n; ++j) rectangles[i][j] = rand() % 100;
}
return rectangles;
}
void destroy_rectangles(double ** rectangles, size_t n){
for(size_t i = 0; i < n; ++i) free(rectangles[i]);
free(rectangles);
}
int main(){
srand(time(NULL));
size_t n = rand() % 100000;
double * perimeters = (double *)malloc(n * sizeof(double));
double * areas = (double *)malloc(n * sizeof(double));
double * diagonals = (double *)malloc(n * sizeof(double));
double ** rectangles = generate_rectangles(n);
#pragma omp parallel for simd num_threads(NUM_THREADS) schedule(static)
for(size_t i = 0; i < n; ++i){
#pragma omp task
{perimeters[i] = compute_perimeter(rectangles[i][BASE], rectangles[i][HEIGHT]);}
#pragma omp task
{areas[i] = compute_area(rectangles[i][BASE], rectangles[i][HEIGHT]);}
#pragma omp task
{diagonals[i] = compute_diagonal(rectangles[i][BASE], rectangles[i][HEIGHT]);}
}
for(size_t i = 0; i < n; ++i) printf("rectangle %d:\n base = %lf, height = %lf, perimeter = %lf, area = %lf, diagonal = %lf\n\n", i, rectangles[i][BASE], rectangles[i][HEIGHT], perimeters[i], areas[i], diagonals[i]);
free(perimeters);
free(areas);
free(diagonals);
destroy_rectangles(rectangles, n);
return 0;
}