A complex number is a number that can be expressed in the form `a + bi`, where `a` and `b` are real numbers and `i` is the imaginary unit, satisfying the equation `i*i=−1`. In this expression, `a` is the real part and `b` is the imaginary part of the complex number.

From wikipedia

The following code, will open a file where each line contains one complex number, read the number and store it into the appropriate variables.

```#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {

const char *filename = argv;
FILE *fin = fopen(filename, "r");

// Making sure we managed to open the file
if (fin != NULL) {

//Initially this pointer will hold the whole line, eventually the data for the second Component will be removed
char *first_value = NULL;
size_t length_of_buffer = 0;

// Read Line by line until end of file:
// If *line is set to NULL and *length_of_buffer is set 0 before the call, then getline() will allocate a buffer for storing the line.
// This buffer should be freed by the user program even if getline() failed.
while ((bytes_read = getline(&first_value, &length_of_buffer, fin)) != -1) {
printf("Data = '%s' : Length = %zu\n", first_value, bytes_read);

// Create char string to store the second Component
char *second_value;
// We are a bit wasteful here but it makes the code simpler
second_value = (char *) malloc(bytes_read * sizeof(char));

// Create Imaginary flag to distinguish real values from imaginary values - One for each Component
char imaginary_flag = {0, 0};

// Initialize Iterators
// i: for pointing to characters of current line
// j: for pointing to characters in first Component
// k: for pointing to characters in second Component
int i, j = 0, k = 0;
// Flag to indicate that first character if the first Component was found - This helps distinguish between first and second Component
char met_a_number = 0;
// Flag to indicate first Component ends and we should process the second Component
char copy_to_second_value = 0;
// To store the previous character value, we use it to check that when a sign is found, it does not belong to an exponential
char previous_character = '\0';

for (i = 0; i < bytes_read; i++) {
// Initialize current character being processed/evaluated from the line
const char current_character = first_value[i];

// Find the 'j' character that shows that this number is imaginary, then drop the character
if (current_character == 'j') {
if (copy_to_second_value == 0) {
// First Component is the imaginary part
imaginary_flag = 1;
} else {
// Second Component is the imaginary part
imaginary_flag = 1;
}
continue;
}

//We check that the current character is useful to us
if (!(current_character == ' ' || current_character == '(' || current_character == ')')) {
// If current character still part of first Component [based on flag]
if (copy_to_second_value == 0) {
// Check when second Component begins
// When we find one of the sign characters and it is not part of an exponential, then we switch to the second Component
// Exclude if previous character was "e" because after "e" a sign is followed
if (current_character == '-' || current_character == '+') {
if (met_a_number == 1 && previous_character != 'e') {
// Update Flag to indicate that second Component/Value begins
copy_to_second_value = 1;
// Terminate first Component/Value of current Line
first_value[i] = '\0';
second_value[k++] = current_character;
} else {
// Update First Component with the current character value
first_value[j++] = current_character;
}
}
// If current character still part of the first Component
else {
// Update First Component with the current character value
first_value[j++] = current_character;
// A valid character of a number was found, so we are processing a number.
// If this is the first time it happens, we are processing the first Component
met_a_number = 1;
}
}
// If current character part of second Component [based on flag]
else {
second_value[k++] = current_character;
}
}
// If current character belongs in one of the garbage characters
else {
// If current character is garbage number and we already met a number
// then we start copying to the second Component
if (met_a_number == 1) {
copy_to_second_value = 1;
first_value[i] = '\0';
}
}

// Store current_character before reading the next
previous_character = current_character;
}

// Properly terminate first Component
if (first_value[j - 1] == '\n') {
first_value[j - 1] = '\0';
} else {
first_value[j] = '\0';
}

// Properly terminate second Component
second_value[k - 1] = '\0';

// To store the first and second Components in float format
double numbers;

// Convert to float and Print first Component
sscanf(first_value, "%lf", &(numbers));
printf("%.f = '%s' is imaginary = %s\n", numbers, first_value, imaginary_flag == 0 ? "FALSE" : "TRUE");

// Convert to float and Print second Component if it exists
if (copy_to_second_value == 1) {
sscanf(second_value, "%lf", &(numbers));
printf("%.f = '%s' is imaginary = %s\n", numbers, second_value, imaginary_flag == 0 ? "FALSE" : "TRUE");
}

free(second_value);

double real = 0, imaginary = 0;
if (copy_to_second_value == 1) {
if (imaginary_flag == imaginary_flag) {
fprintf(stderr, "Invalid input line.\n");
if (imaginary_flag == 0) {
fprintf(stderr, "None of the components is imaginary\n");
} else {
fprintf(stderr, "Both components are imaginary.\n");
}
continue;
}
if (imaginary_flag == 0) {
real = numbers;
imaginary = numbers;
} else {
real = numbers;
imaginary = numbers;
}

} else {
if (imaginary_flag == 0) {
real = numbers;
} else {
imaginary = numbers;
}
}
printf("Real part: '%f'\tImaginary part: '%f'\n", real, imaginary);
printf("\n");
}
free(first_value);
fclose(fin);
} else {
fprintf(stderr, "Failed to open file '%s'\n", filename);
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}

```

This application will only perform some basic checks on the input, a lot of invalid data can pass as valid..
What this application expects though is the following:

• On each line, there can be either one or two numbers.
• The numbers can be encapsulated in parenthesis ()
• The first number can have a sign or not
• There might be space between the characters or not
• There might be space between the sign characters and the numbers
• The imaginary part of the number will have the character `j` either before the number or after, attached to the number

This post is also available in: Αγγλικα

Αυτός ο ιστότοπος χρησιμοποιεί το Akismet για να μειώσει τα ανεπιθύμητα σχόλια. Μάθετε πώς υφίστανται επεξεργασία τα δεδομένα των σχολίων σας.