LiuYuanchi
/
phytium-vsipl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

init

This commit is contained in:
liuyuanchi 2024-05-25 21:05:46 +08:00
parent fb143565cb
commit c9b3f9bf2b
11 changed files with 137 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/hamming.h
View File

@ -1,5 +1,5 @@
#ifndef RADAR_HAMMING_H_
#define RADAR_HAMMING_H_
#ifndef _HAMMING_H_
#define _HAMMING_H_
#include "vsip.h"

4
include/hilbertFilter.h
View File

@ -1,5 +1,5 @@
#ifndef RADAR_FILTER_H_
#define RADAR_FILTER_H_
#ifndef _FILTER_H_
#define _FILTER_H_
#include "vsip.h"

16
include/signal.h
View File

@ -1,20 +1,20 @@
#ifndef RADAR_SIGNAL_H_
#define RADAR_SIGNAL_H_
#ifndef _SIGNAL_H_
#define _SIGNAL_H_
#include "vsip.h"
void generate_lfm_signal(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
void create_lfm_signal(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
vsip_scalar_f f_freq_low, vsip_scalar_f f_band_width,
vsip_cvview_f *p_vector_dst);
void generate_lfm_signal_real(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
void create_lfm_signal_real(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
vsip_scalar_f f_freq_low, vsip_scalar_f f_band_width,
vsip_vview_f *p_vector_dst);
void generate_radar_signal(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
void create_radar_signal(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
vsip_scalar_f f_freq_low, vsip_scalar_f f_band_width,
vsip_scalar_f f_distance, vsip_vview_f *p_vector_dst);
void generate_wgn_signal(vsip_vview_f *p_vector_signal, vsip_scalar_f f_snr,
void create_wgn_signal(vsip_vview_f *p_vector_signal, vsip_scalar_f f_snr,
vsip_vview_f *p_vector_dst);
void pulse_compress(vsip_cvview_f *p_vector_signal_src, vsip_cvview_f *p_vector_signal_ref,
@ -23,4 +23,8 @@ void pulse_compress(vsip_cvview_f *p_vector_signal_src, vsip_cvview_f *p_vector_
void detect_signal(vsip_cvview_f *p_vector_signal, vsip_scalar_f f_threshold,
vsip_cvview_f *p_vector_dst);
void outputRealVector(vsip_vview_f *p_vector, char *p_name);
void outputComplexVector(vsip_cvview_f *p_vector,char *p_name);
#endif

11
include/tool.h
View File

@ -1,11 +0,0 @@
#ifndef RADAR_UTILS_H_
#define RADAR_UTILS_H_
#include "vsip.h"
void outputRealVector(vsip_vview_f *p_vector, char *p_name);
void outputComplexVector(vsip_cvview_f *p_vector,char *p_name);
#endif

0
script/plot.py → script/makeImg.py
View File

66
script/test.py → script/testThreshold.py
View File

@ -2,51 +2,47 @@ import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
def wgn(signal, snr=0):
snr = 10 ** (snr / 10)
xpower = np.sum(signal ** 2) / len(signal)
npower = xpower / snr
noise = np.random.randn(len(signal)) * np.sqrt(npower)
signal_power = np.mean(signal ** 2)
noise_power = signal_power / (10 ** (snr / 10))
noise = np.random.normal(0, np.sqrt(noise_power), len(signal))
return noise
def hilbert(signal, num_hilbert=11):
hilbert_transformer = np.zeros(num_hilbert, dtype=np.complex128)
for i in range(-num_hilbert // 2, num_hilbert // 2 + 1, 1):
if i % 2 == 0:
hilbert_transformer[i + num_hilbert // 2] = 0
else:
hilbert_transformer[i + num_hilbert // 2] = 2j / (np.pi * i)
hilbert_transformer[0 + num_hilbert // 2] = 1
signal_hilbert = np.convolve(signal, hilbert_transformer, mode='same')
return signal_hilbert
n = np.arange(-num_hilbert // 2, num_hilbert // 2 + 1)
hilbert_transformer = np.where(n % 2 != 0, 2j / (np.pi * n), 0)
hilbert_transformer[num_hilbert // 2] = 1
return np.convolve(signal, hilbert_transformer, mode='same')
def pulse_compress(signal_src, signal_ref):
signal_src_length = len(signal_src)
signal_ref_length = len(signal_ref)
fft_len = 2 * signal_src_length - 1
fft_len = np.ceil(0.5 + np.log2(fft_len))
fft_len = np.floor(0.5 + 2 ** fft_len)
signal_ref = np.conjugate(signal_ref)
signal_ref = np.flip(signal_ref)
window = np.hamming(signal_ref_length)
# signal_ref = signal_ref * window
signal_src = np.pad(signal_src, (0, int(fft_len - signal_src_length)), 'constant')
signal_ref = np.pad(signal_ref, (0, int(fft_len - signal_ref_length)), 'constant')
# 计算所需的FFT长度
fft_len = 2 * len(signal_src) - 1
fft_len = int(2 ** np.ceil(np.log2(fft_len)))
# 对参考信号进行共轭翻转
signal_ref = np.conj(np.flip(signal_ref))
# 对信号进行Hamming窗加权
window = np.hamming(len(signal_ref))
signal_ref *= window
# 对输入信号和参考信号进行零padding
signal_src = np.pad(signal_src, (0, fft_len - len(signal_src)), 'constant')
signal_ref = np.pad(signal_ref, (0, fft_len - len(signal_ref)), 'constant')
# 进行FFT和卷积
signal_src_fft = np.fft.fft(signal_src, fft_len)
signal_ref_fft = np.fft.fft(signal_ref, fft_len)
signal_dst_fft = signal_src_fft * signal_ref_fft
# 执行IFFT得到脉冲压缩信号
signal_dst = np.fft.ifft(signal_dst_fft, fft_len)
return signal_dst
def lfm(tau, fs, fl, bw):

9
src/hamming.c
View File

@ -11,14 +11,13 @@ void hamming(vsip_vview_f *p_vector_dst)
vsip_length n_length = vsip_vgetlength_f(p_vector_dst);
// 汉明窗参数
const vsip_scalar_f f_a0 = (float)0.53836;
const vsip_scalar_f f_a1 = (float)(1.0f - f_a0);
const vsip_scalar_f f_a0 = 0.54;
const vsip_scalar_f f_a1 = 0.46;
// 生成汉明窗
for (vsip_length n_index = 0; n_index < n_length; n_index++)
{
vsip_scalar_f f_element =
f_a0 - f_a1 * (float)vsip_cos_f(2.0 * VSIP_PI * n_index / (n_length - 1));
vsip_vput_f(p_vector_dst, n_index, f_element);
vsip_vput_f(p_vector_dst, n_index,
f_a0 - f_a1 * cos(2.0 * VSIP_PI * n_index / (n_length - 1)));
}
}

90
src/hilbertFilter.c
View File

@ -1,10 +1,9 @@
#include "hilbertFilter.h"
#include "tool.h"
void hilbert(vsip_vview_f *p_vector_src, vsip_scalar_i n_filter_length, vsip_cvview_f *p_vector_dst)
{
vsip_length n_signal_length = vsip_vgetlength_f(p_vector_src);
if (p_vector_src == NULL)
{
fprintf(stderr, "hilbert: p_vector_src is NULL\n");
@ -15,85 +14,40 @@ void hilbert(vsip_vview_f *p_vector_src, vsip_scalar_i n_filter_length, vsip_cvv
fprintf(stderr, "hilbert: p_vector_dst length is not equal to p_vector_src\n");
return;
}
else
{
;
}
vsip_cvview_f *p_vector_hilbert_transformer = vsip_cvcreate_f(n_filter_length, VSIP_MEM_NONE);
// 正负半轴元素个数
vsip_scalar_i n_half_filter_length = n_filter_length / 2;
// 计算 Hilbert 变换滤波器的系数
vsip_vview_f *p_vector_hilbert_coeff = vsip_vcreate_f(n_filter_length, VSIP_MEM_NONE);
for (vsip_length n_index = 0; n_index < n_filter_length; n_index++)
{
// 计算索引偏移
vsip_scalar_i n_index_offset = (vsip_scalar_i)n_index - n_half_filter_length;
// 默认 0
vsip_cscalar_f c_value = vsip_cmplx_f(0.0f, 0.0f);
vsip_scalar_i n_index_offset = (vsip_scalar_i)n_index - n_filter_length / 2;
if (n_index_offset == 0)
{
// 0 处的冲激响应
c_value = vsip_cmplx_f(1.0f, 0.0f);
}
else if (n_index_offset % 2 != 0)
{
// 2j / (pi * n)
c_value = vsip_cmplx_f(0.0f, 2.0f / (VSIP_PI * n_index_offset));
vsip_vput_f(p_vector_hilbert_coeff, n_index, 1.0f);
}
else
{
;
vsip_vput_f(p_vector_hilbert_coeff, n_index, 2.0f / (VSIP_PI * n_index_offset));
}
vsip_cvput_f(p_vector_hilbert_transformer, n_index, c_value);
}
outputComplexVector(p_vector_hilbert_transformer, "./data/hilbert_coefficients.txt");
// 得到滤波器系数的实部和虚部
vsip_vview_f *p_vector_hilbert_transformer_real =
vsip_vcreate_f(n_filter_length, VSIP_MEM_NONE);
vsip_vview_f *p_vector_hilbert_transformer_imag =
vsip_vcreate_f(n_filter_length, VSIP_MEM_NONE);
vsip_vreal_f(p_vector_hilbert_transformer, p_vector_hilbert_transformer_real);
vsip_vimag_f(p_vector_hilbert_transformer, p_vector_hilbert_transformer_imag);
// 用于卷积结果的实部和虚部
vsip_vview_f *p_vector_cmplx_signal_real = vsip_vcreate_f(n_signal_length, VSIP_MEM_NONE);
vsip_vview_f *p_vector_cmplx_signal_imag = vsip_vcreate_f(n_signal_length, VSIP_MEM_NONE);
// 当前 VSIPL 版本中没有复数卷积的操作，由于希尔伯特滤波器系数为实数或虚数而没有复合，
// 所以可以分别对实部和虚部进行卷积操作。
// 实部卷积核
vsip_conv1d_f *p_filter_real =
vsip_conv1d_create_f(p_vector_hilbert_transformer_real, VSIP_NONSYM, n_signal_length, 1,
VSIP_SUPPORT_SAME, 0, VSIP_ALG_TIME);
// 虚部卷积核
vsip_conv1d_f *p_filter_imag =
vsip_conv1d_create_f(p_vector_hilbert_transformer_imag, VSIP_NONSYM, n_signal_length, 1,
VSIP_SUPPORT_SAME, 0, VSIP_ALG_TIME);
// 实部卷积
vsip_convolve1d_f(p_filter_real, p_vector_src, p_vector_cmplx_signal_real);
// 虚部卷积
vsip_convolve1d_f(p_filter_imag, p_vector_src, p_vector_cmplx_signal_imag);
// 合成复信号
// 对输入信号进行卷积
vsip_vview_f *p_vector_real = vsip_vcreate_f(n_signal_length, VSIP_MEM_NONE);
vsip_vview_f *p_vector_imag = vsip_vcreate_f(n_signal_length, VSIP_MEM_NONE);
vsip_conv1d_f *p_filter_real = vsip_conv1d_create_f(p_vector_hilbert_coeff, VSIP_NONSYM, n_signal_length, 1, VSIP_SUPPORT_SAME, 0, VSIP_ALG_TIME);
vsip_conv1d_f *p_filter_imag = vsip_conv1d_create_f(p_vector_hilbert_coeff, VSIP_NONSYM, n_signal_length, 1, VSIP_SUPPORT_SAME, 0, VSIP_ALG_TIME);
vsip_convolve1d_f(p_filter_real, p_vector_src, p_vector_real);
vsip_convolve1d_f(p_filter_imag, p_vector_src, p_vector_imag);
// 将结果复制到输出向量
for (vsip_length n_index = 0; n_index < n_signal_length; n_index++)
{
vsip_cscalar_f c_value = vsip_cmplx_f(vsip_vget_f(p_vector_cmplx_signal_real, n_index),
vsip_vget_f(p_vector_cmplx_signal_imag, n_index));
vsip_cscalar_f c_value = vsip_cmplx_f(vsip_vget_f(p_vector_real, n_index), vsip_vget_f(p_vector_imag, n_index));
vsip_cvput_f(p_vector_dst, n_index, c_value);
}
// 释放
// 释放资源
vsip_conv1d_destroy_f(p_filter_real);
vsip_conv1d_destroy_f(p_filter_imag);
vsip_vdestroy_f(p_vector_cmplx_signal_imag);
vsip_vdestroy_f(p_vector_cmplx_signal_real);
vsip_vdestroy_f(p_vector_hilbert_transformer_imag);
vsip_vdestroy_f(p_vector_hilbert_transformer_real);
vsip_cvalldestroy_f(p_vector_hilbert_transformer);
vsip_vdestroy_f(p_vector_real);
vsip_vdestroy_f(p_vector_imag);
}

9
src/main.c
View File

@ -1,7 +1,6 @@
#include "hilbertFilter.h"
#include "hamming.h"
#include "signal.h"
#include "tool.h"
#include "vsip.h"
#include <stdio.h>
@ -28,7 +27,7 @@ int main(int argc, char *argv[])
// 创建一个用于存储雷达信号的实数向量
vsip_vview_f *p_vector_radar_signal = vsip_vcreate_f(total_signal_length, VSIP_MEM_NONE);
// 生成雷达信号
generate_radar_signal(pulse_width, sampling_rate, lower_limit_frequency, band_width, 600.0f,
create_radar_signal(pulse_width, sampling_rate, lower_limit_frequency, band_width, 600.0f,
p_vector_radar_signal);
// 将实数雷达信号输出到文件
@ -46,7 +45,7 @@ int main(int argc, char *argv[])
// 创建一个用于存储参考信号的复数向量
vsip_cvview_f *p_vector_signal_ref = vsip_cvcreate_f(signal_length, VSIP_MEM_NONE);
// 生成参考信号
generate_lfm_signal(pulse_width, sampling_rate, lower_limit_frequency, band_width, p_vector_signal_ref);
create_lfm_signal(pulse_width, sampling_rate, lower_limit_frequency, band_width, p_vector_signal_ref);
// 计算进行脉冲压缩的快速傅里叶变换长度
vsip_length fft_len = 2 * total_signal_length - 1;
@ -65,7 +64,7 @@ int main(int argc, char *argv[])
// 创建一个用于存储经过阈值检测的雷达信号的复数向量
vsip_cvview_f *p_vector_radar_signal_reduced = vsip_cvcreate_f(fft_len, VSIP_MEM_NONE);
// 对雷达信号进行阈值检测
detect_signal(p_vector_radar_signal_compressed, 20.0f, p_vector_radar_signal_reduced);
detect_signal(p_vector_radar_signal_compressed, 25.0f, p_vector_radar_signal_reduced);
// 将经过阈值检测的雷达信号输出到文件
outputComplexVector(p_vector_radar_signal_reduced, "./data/signal_reduced.txt");
@ -102,7 +101,7 @@ int main(int argc, char *argv[])
// 如果不是第一个目标,计算距离并记录时间
vsip_scalar_f distance = 3e8 * (curr_time - prev_time) / 2.0f;
prev_time = curr_time;
printf("Second record: %fs, \nDistance: %fm\n", curr_time, distance);
printf("Second record: %fs, \nDistance: %fm\n\n", curr_time, distance);
}
// 继续寻找目标
while (curr_mag > next_mag)

79
src/signal.c
View File

@ -1,6 +1,5 @@
#include "signal.h"
#include "hamming.h"
#include "tool.h"
#include <time.h>
// 信号翻转
@ -81,7 +80,7 @@ void cvpad_f(vsip_cvview_f *p_vector_src, vsip_cvview_f *p_vector_dst)
}
}
void generate_lfm_signal(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
void create_lfm_signal(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
vsip_scalar_f f_freq_low, vsip_scalar_f f_band_width,
vsip_cvview_f *p_vector_dst)
{
@ -90,13 +89,13 @@ void generate_lfm_signal(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
if (p_vector_dst == NULL)
{
fprintf(stderr, "generate_lfm_signal: p_vector_dst is NULL.\n");
fprintf(stderr, "create_lfm_signal: p_vector_dst is NULL.\n");
return;
}
else if (vsip_cvgetlength_f(p_vector_dst) != signal_length)
{
fprintf(stderr,
"generate_lfm_signal: p_vector_dst length is not equal to signal_length.\n");
"create_lfm_signal: p_vector_dst length is not equal to signal_length.\n");
return;
}
else
@ -131,7 +130,7 @@ void generate_lfm_signal(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
vsip_valldestroy_f(p_vector_temp_1);
}
void generate_lfm_signal_real(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
void create_lfm_signal_real(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
vsip_scalar_f f_freq_low, vsip_scalar_f f_band_width,
vsip_vview_f *p_vector_dst)
{
@ -140,13 +139,13 @@ void generate_lfm_signal_real(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling
if (p_vector_dst == NULL)
{
fprintf(stderr, "generate_lfm_signal: p_vector_dst is NULL.\n");
fprintf(stderr, "create_lfm_signal: p_vector_dst is NULL.\n");
return;
}
else if (vsip_vgetlength_f(p_vector_dst) != signal_length)
{
fprintf(stderr,
"generate_lfm_signal: p_vector_dst length is not equal to signal_length.\n");
"create_lfm_signal: p_vector_dst length is not equal to signal_length.\n");
return;
}
else
@ -181,7 +180,7 @@ void generate_lfm_signal_real(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling
vsip_valldestroy_f(p_vector_temp_1);
}
void generate_radar_signal(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
void create_radar_signal(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
vsip_scalar_f f_freq_low, vsip_scalar_f f_band_width,
vsip_scalar_f f_distance, vsip_vview_f *p_vector_dst)
{
@ -198,14 +197,14 @@ void generate_radar_signal(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
if (p_vector_dst == NULL)
{
fprintf(stderr, "generate_radar_signal: p_vector_dst is NULL.\n");
fprintf(stderr, "create_radar_signal: p_vector_dst is NULL.\n");
return;
}
else if (vsip_vgetlength_f(p_vector_dst) != total_signal_length)
{
fprintf(
stderr,
"generate_radar_signal: p_vector_dst length is not equal to total_signal_length.\n");
"create_radar_signal: p_vector_dst length is not equal to total_signal_length.\n");
return;
}
else
@ -220,8 +219,8 @@ void generate_radar_signal(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
// 第二个目标返回的信号
vsip_vview_f *p_vector_signal_1 = vsip_vcreate_f(signal_length, VSIP_MEM_NONE);
generate_lfm_signal_real(f_tau, f_freq_sampling, f_freq_low, f_band_width, p_vector_signal_0);
generate_lfm_signal_real(f_tau, f_freq_sampling, f_freq_low, f_band_width, p_vector_signal_1);
create_lfm_signal_real(f_tau, f_freq_sampling, f_freq_low, f_band_width, p_vector_signal_0);
create_lfm_signal_real(f_tau, f_freq_sampling, f_freq_low, f_band_width, p_vector_signal_1);
// 延长原始信号向量
vsip_vview_f *p_vector_signal_0_extended = vsip_vcreate_f(total_signal_length, VSIP_MEM_NONE);
@ -247,7 +246,7 @@ void generate_radar_signal(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
// 高斯白噪声，SNR=0dB
vsip_vview_f *p_vector_wgn_signal = vsip_vcreate_f(total_signal_length, VSIP_MEM_NONE);
generate_wgn_signal(p_vector_dst, 0.0f, p_vector_wgn_signal);
create_wgn_signal(p_vector_dst, 0.0f, p_vector_wgn_signal);
// 叠加噪声
vsip_vadd_f(p_vector_dst, p_vector_wgn_signal, p_vector_dst);
@ -260,19 +259,19 @@ void generate_radar_signal(vsip_scalar_f f_tau, vsip_scalar_f f_freq_sampling,
vsip_valldestroy_f(p_vector_wgn_signal);
}
void generate_wgn_signal(vsip_vview_f *p_vector_signal, vsip_scalar_f f_snr,
void create_wgn_signal(vsip_vview_f *p_vector_signal, vsip_scalar_f f_snr,
vsip_vview_f *p_vector_dst)
{
vsip_length length = vsip_vgetlength_f(p_vector_signal);
if (p_vector_dst == NULL)
{
fprintf(stderr, "generate_wgn_signal: p_vector_dst is NULL.\n");
fprintf(stderr, "create_wgn_signal: p_vector_dst is NULL.\n");
return;
}
else if (vsip_vgetlength_f(p_vector_dst) != length)
{
fprintf(stderr, "generate_wgn_signal: p_vector_dst length is not equal to length.\n");
fprintf(stderr, "create_wgn_signal: p_vector_dst length is not equal to length.\n");
return;
}
else
@ -428,4 +427,50 @@ void detect_signal(vsip_cvview_f *p_vector_signal, vsip_scalar_f f_threshold,
vsip_cvput_f(p_vector_dst, index, vsip_cvget_f(p_vector_signal, index));
}
}
}
}
void outputRealVector(vsip_vview_f *p_vector, char *p_name)
{
if (p_vector == NULL)
{
fprintf(stderr, "outputRealVector: p_vector is NULL\n");
return;
}
FILE *p_file = fopen(p_name, "w+");
if (p_file == NULL)
{
fprintf(stderr, "vdebug_f: unable to open file `%s`\n", p_name);
return;
}
vsip_length n_length = vsip_vgetlength_f(p_vector);
for (vsip_index n_index = 0; n_index < n_length; n_index++)
{
fprintf(p_file, "%f\n", vsip_vget_f(p_vector, n_index));
}
fclose(p_file);
}
void outputComplexVector(vsip_cvview_f *p_vector,char *p_name)
{
if (p_vector == NULL)
{
fprintf(stderr, "outputRealVector: p_vector is NULL\n");
return;
}
FILE *p_file = fopen(p_name, "w+");
if (p_file == NULL)
{
fprintf(stderr, "cvdebug_f: unable to open file `%s`\n", p_name);
return;
}
vsip_length n_length = vsip_cvgetlength_f(p_vector);
for (vsip_index n_index = 0; n_index < n_length; n_index++)
{
vsip_cscalar_f c_value = vsip_cvget_f(p_vector, n_index);
fprintf(p_file, "%+9.4f%+9.4fj\n", vsip_real_f(c_value), vsip_imag_f(c_value));
}
fclose(p_file);
}

47
src/tool.c
View File

@ -1,47 +0,0 @@
#include "tool.h"
void outputRealVector(vsip_vview_f *p_vector, char *p_name)
{
if (p_vector == NULL)
{
fprintf(stderr, "outputRealVector: p_vector is NULL\n");
return;
}
FILE *p_file = fopen(p_name, "w+");
if (p_file == NULL)
{
fprintf(stderr, "vdebug_f: unable to open file `%s`\n", p_name);
return;
}
vsip_length n_length = vsip_vgetlength_f(p_vector);
for (vsip_index n_index = 0; n_index < n_length; n_index++)
{
fprintf(p_file, "%f\n", vsip_vget_f(p_vector, n_index));
}
fclose(p_file);
}
void outputComplexVector(vsip_cvview_f *p_vector,char *p_name)
{
if (p_vector == NULL)
{
fprintf(stderr, "outputRealVector: p_vector is NULL\n");
return;
}
FILE *p_file = fopen(p_name, "w+");
if (p_file == NULL)
{
fprintf(stderr, "cvdebug_f: unable to open file `%s`\n", p_name);
return;
}
vsip_length n_length = vsip_cvgetlength_f(p_vector);
for (vsip_index n_index = 0; n_index < n_length; n_index++)
{
vsip_cscalar_f c_value = vsip_cvget_f(p_vector, n_index);
fprintf(p_file, "%+9.4f%+9.4fj\n", vsip_real_f(c_value), vsip_imag_f(c_value));
}
fclose(p_file);
}