【测速】矩阵翻转

最新推荐文章于 2021-10-15 16:05:14 发布
原创 最新推荐文章于 2021-10-15 16:05:14 发布 · 154 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

[size=large]在微博中看到有人分享了篇文章“为什么转置512×512矩阵，会比513×513矩阵慢很多？”[/size][url]http://note.sdo.com/u/1557869253/n/sSPb5~k5HYUMLX0mU000QX[/url]
[size=large]没仔细看原理，但与缓存的命中率有关。
今天写矩阵翻转的代码，突然想到这个问题。测了一下速度：[/size]
[color=red][size=xx-large]结论：[/size][/color][size=large]新建一片内存，顺序访问其中的元素，速度比较快！！！在翻转中能快个两倍左右！！！（注：我的矩阵是行优先存储的）[/size]


[color=red][size=xx-large]有关代码如下（代码不完全）：[/size][/color]
	//水平翻转矩阵中的元素
	void flipHorizontally(){
		T tmp;
		//int halfHeight=height_row/2;
		int halfWidth=width_col/2;
		for (int r=0; r<height_row; r++) {
			for (int c=0; c<halfWidth; c++) {
				int c2=width_col-1-c;
				tmp=getValue(r,c);
				this->operator()(r,c)=this->operator()(r,c2);
				this->operator()(r,c2)=tmp;
			}
		}

	}

	//水平翻转矩阵中的元素
	Matrix flipHorizontallyNewMatrix(){
		Matrix flipped(height_row,width_col);
		int halfWidth=width_col/2;
		for (int r=0; r<height_row; r++) {
			for (int c=0; c<=halfWidth; c++) {
				int c2=width_col-1-c;
				flipped(r,c)=this->operator()(r,c2);
				flipped(r,c2)=this->operator()(r,c);
			}
		}
		return flipped;
	}

	//水平翻转矩阵中的元素
	Matrix flipHorizontallyNewMatrix2(){
		Matrix flipped(height_row,width_col);
		for (int r=0; r<height_row; r++) {
			for (int c=0; c<width_col; c++) {
				int c2=width_col-1-c;
				flipped(r,c)=this->operator()(r,c2);
			}
		}
		return flipped;
	}


	//垂直翻转矩阵中的元素
	Matrix flipVerticallyNewMatrix(){
		Matrix flipped(height_row,width_col);
		int halfHeight=height_row/2;
		for (int r=0; r<=halfHeight; r++) {
			for (int c=0; c<width_col; c++) {
				int r2=height_row-1-r;
				flipped(r,c)=this->operator()(r2,c);
				flipped(r2,c)=this->operator()(r,c);
			}
		}
		return flipped;
	}

	//垂直翻转矩阵中的元素
	Matrix flipVerticallyNewMatrix2(){
		Matrix flipped(height_row,width_col);
		for (int r=0; r<height_row; r++) {
			for (int c=0; c<width_col; c++) {
				int r2=height_row-1-r;
				flipped(r,c)=this->operator()(r2,c);
				//flipped(r2,c)=this->operator()(r,c);
			}
		}
		return flipped;
	}


	//垂直翻转矩阵中的元素
	void flipVertically(){
		T tmp;
		int halfHeight=height_row/2;
		for (int r=0; r<halfHeight; r++) {
			for (int c=0; c<width_col; c++) {
				int r2=height_row-1-r;
				tmp=getValue(r,c);
				this->operator()(r,c)=this->operator()(r2,c);
				this->operator()(r2,c)=tmp;
			}
		}

	}



[color=red][size=xx-large]测试用的代码如下（代码不完全）：[/size][/color]

        for (int n=10; n<1000; n+=33) {


            MatrixInt m(n,n);
            for (int i=0; i<m.getNumEl(); i++) {
                m(i)=i;
            }

            int testNum=10000/n*10000/n;
            Timer timer;

            for(int i=0; i<testNum; i++)
                m.flipVerticallyNewMatrix();
            long tv1=timer.getElapsedTimeAndRestart();

            for(int i=0; i<testNum; i++)
                m.flipVerticallyNewMatrix2();
            long tv2=timer.getElapsedTimeAndRestart();

			for(int i=0; i<testNum; i++)
				m.flipVertically();
			long tvInplace=timer.getElapsedTimeAndRestart();

            for(int i=0; i<testNum; i++)
                m.flipHorizontallyNewMatrix();
            long th1=timer.getElapsedTimeAndRestart();

            for(int i=0; i<testNum; i++)
                m.flipHorizontallyNewMatrix2();
            long th2=timer.getElapsedTimeAndRestart();

			for(int i=0; i<testNum; i++)
				m.flipHorizontally();
			long thInplace=timer.getElapsedTimeAndRestart();
			cout<<"矩阵大小: "<<m.height_row<<"行*"<<m.width_col<<"列"<<endl;
			cout<<"水平翻转耗时：方法1:  "<<th1<<";\t\t方法2:  "<<th2<<";\t\t原位翻转:  "<<thInplace<<endl;
			cout<<"垂直翻转耗时：方法1:  "<<tv1<<";\t\t方法2:  "<<tv2<<";\t\t原位翻转:  "<<tvInplace<<endl;
            cout<<endl;

        }



[color=red][size=xx-large]测试用结果如下：[/size][/color]
矩阵大小: 10行*10列
水平翻转耗时：方法1:  566;		方法2:  340;		原位翻转:  410
垂直翻转耗时：方法1:  652;		方法2:  342;		原位翻转:  450

矩阵大小: 43行*43列
水平翻转耗时：方法1:  364;		方法2:  180;		原位翻转:  390
垂直翻转耗时：方法1:  425;		方法2:  178;		原位翻转:  434

矩阵大小: 76行*76列
水平翻转耗时：方法1:  361;		方法2:  188;		原位翻转:  402
垂直翻转耗时：方法1:  433;		方法2:  183;		原位翻转:  445

矩阵大小: 109行*109列
水平翻转耗时：方法1:  360;		方法2:  180;		原位翻转:  397
垂直翻转耗时：方法1:  411;		方法2:  174;		原位翻转:  440

矩阵大小: 142行*142列
水平翻转耗时：方法1:  357;		方法2:  176;		原位翻转:  406
垂直翻转耗时：方法1:  413;		方法2:  173;		原位翻转:  456

矩阵大小: 175行*175列
水平翻转耗时：方法1:  353;		方法2:  173;		原位翻转:  403
垂直翻转耗时：方法1:  412;		方法2:  171;		原位翻转:  452

矩阵大小: 208行*208列
水平翻转耗时：方法1:  359;		方法2:  176;		原位翻转:  408
垂直翻转耗时：方法1:  417;		方法2:  173;		原位翻转:  455

矩阵大小: 241行*241列
水平翻转耗时：方法1:  349;		方法2:  171;		原位翻转:  400
垂直翻转耗时：方法1:  411;		方法2:  170;		原位翻转:  449

矩阵大小: 274行*274列
水平翻转耗时：方法1:  346;		方法2:  173;		原位翻转:  400
垂直翻转耗时：方法1:  406;		方法2:  167;		原位翻转:  448

矩阵大小: 307行*307列
水平翻转耗时：方法1:  343;		方法2:  170;		原位翻转:  400
垂直翻转耗时：方法1:  402;		方法2:  168;		原位翻转:  443

矩阵大小: 340行*340列
水平翻转耗时：方法1:  360;		方法2:  174;		原位翻转:  420
垂直翻转耗时：方法1:  410;		方法2:  169;		原位翻转:  447

矩阵大小: 373行*373列
水平翻转耗时：方法1:  460;		方法2:  259;		原位翻转:  398
垂直翻转耗时：方法1:  512;		方法2:  261;		原位翻转:  443

矩阵大小: 406行*406列
水平翻转耗时：方法1:  456;		方法2:  262;		原位翻转:  403
垂直翻转耗时：方法1:  516;		方法2:  255;		原位翻转:  452

矩阵大小: 439行*439列
水平翻转耗时：方法1:  450;		方法2:  248;		原位翻转:  401
垂直翻转耗时：方法1:  500;		方法2:  249;		原位翻转:  445

矩阵大小: 472行*472列
水平翻转耗时：方法1:  453;		方法2:  269;		原位翻转:  402
垂直翻转耗时：方法1:  513;		方法2:  265;		原位翻转:  450

矩阵大小: 505行*505列
水平翻转耗时：方法1:  433;		方法2:  252;		原位翻转:  390
垂直翻转耗时：方法1:  489;		方法2:  249;		原位翻转:  436

矩阵大小: 538行*538列
水平翻转耗时：方法1:  440;		方法2:  247;		原位翻转:  398
垂直翻转耗时：方法1:  497;		方法2:  247;		原位翻转:  444

矩阵大小: 571行*571列
水平翻转耗时：方法1:  443;		方法2:  256;		原位翻转:  397
垂直翻转耗时：方法1:  496;		方法2:  248;		原位翻转:  440

矩阵大小: 604行*604列
水平翻转耗时：方法1:  439;		方法2:  252;		原位翻转:  402
垂直翻转耗时：方法1:  494;		方法2:  248;		原位翻转:  438

矩阵大小: 637行*637列
水平翻转耗时：方法1:  436;		方法2:  244;		原位翻转:  397
垂直翻转耗时：方法1:  488;		方法2:  242;		原位翻转:  432

矩阵大小: 670行*670列
水平翻转耗时：方法1:  427;		方法2:  243;		原位翻转:  384
垂直翻转耗时：方法1:  483;		方法2:  238;		原位翻转:  427

矩阵大小: 703行*703列
水平翻转耗时：方法1:  449;		方法2:  257;		原位翻转:  403
垂直翻转耗时：方法1:  527;		方法2:  260;		原位翻转:  459

矩阵大小: 736行*736列
水平翻转耗时：方法1:  432;		方法2:  246;		原位翻转:  395
垂直翻转耗时：方法1:  493;		方法2:  245;		原位翻转:  440

矩阵大小: 769行*769列
水平翻转耗时：方法1:  452;		方法2:  258;		原位翻转:  409
垂直翻转耗时：方法1:  518;		方法2:  256;		原位翻转:  458

矩阵大小: 802行*802列
水平翻转耗时：方法1:  434;		方法2:  248;		原位翻转:  392
垂直翻转耗时：方法1:  492;		方法2:  248;		原位翻转:  433

矩阵大小: 835行*835列
水平翻转耗时：方法1:  415;		方法2:  240;		原位翻转:  372
垂直翻转耗时：方法1:  466;		方法2:  234;		原位翻转:  416

矩阵大小: 868行*868列
水平翻转耗时：方法1:  427;		方法2:  247;		原位翻转:  388
垂直翻转耗时：方法1:  478;		方法2:  239;		原位翻转:  433

矩阵大小: 901行*901列
水平翻转耗时：方法1:  448;		方法2:  262;		原位翻转:  400
垂直翻转耗时：方法1:  499;		方法2:  251;		原位翻转:  449

矩阵大小: 934行*934列
水平翻转耗时：方法1:  422;		方法2:  248;		原位翻转:  380
垂直翻转耗时：方法1:  477;		方法2:  237;		原位翻转:  426

矩阵大小: 967行*967列
水平翻转耗时：方法1:  436;		方法2:  257;		原位翻转:  388
垂直翻转耗时：方法1:  493;		方法2:  248;		原位翻转:  438
雷达盲区盲速计算matlab,线性调频雷达系统的建模，实现对目标的测距和测速
weixin_39529903的博客
03-19 1075
在网上找了一个程序，实现了发射波形，回波的产生，以及通过了匹配滤波器。。现在想实现测距和速度 希望各位帮忙看看接下去怎么做，本人是新手。。。。希望说的详细点C=3.0e8;%光速(m/s)RF=3.140e9/2;%雷达射频 1.57GHzLambda=C/RF;%雷达工作波长PulseNumber=16; %回波脉冲数BandWidth=2.0e6;%发射信号带宽 带宽B...
matlab仿真多普勒相移,有关脉冲多普勒雷达的matlab仿真问题
weixin_27379781的博客
03-17 3836
大家好，最近在研究脉冲多普勒雷达，从网上找到了一个matlab代码：% ===========================================================================================%% 该程序完成16个脉冲信号的【脉压、动目标显示/动目标检测(MTI/MTD)】% ===================...
为什么转置一个512x512的矩阵，会比513x513的矩阵慢很多？
程序员的自我修养_Will.zhang
09-07 1480
谨以此文，纪念刚退休的Professor Sibert以及Professor Goel。你们尽管已年过70，却还仍然坚持在教导学生，实在令人钦佩。我今天所拥有的编程知识，经验，技巧，很大一部分是从你们那儿学来的。谢谢你们。   问题出处：http://stackoverflow.com/questions/11413855/why-is-transposing-a-matrix-of-
【操作系统】为什么转置512*512的矩阵比转置513*513的矩阵慢？
weixin_45618073的博客
10-15 962
问题 操作系统课讲到内存管理部分时，老师谈到了cache技术，并且提出了一个问题：为什么转置512*512的矩阵比转置513*513的矩阵慢？ 我使用c语言进行了测试。程序代码附在文末，感兴趣的朋友可以自行测试。貌似在Linux上效果比较明显。 测试时为使效果明显，我将矩阵换成了1024*1024和1025*1025，测试结果如下： 可以看到经过多次测试，前者都比后者慢很多。显然是cache缓存命中率的问题。那么，到底如何使用cache解释这个现象呢？ 解释 cache的结构有很多种，可以参考下面这篇文
为什么转置512×512矩阵，会比513×513矩阵慢很多？
拳不离手，曲不离口
09-23 1116
原博客：http://blog.jobbole.com/28219/        很普通的一个求矩阵转置的程序。但是，当MATSIZE取512和513的时候，出现了非常有意思的结果：513竟然比512快。更进一步的研究发现，size=512的时候，运算速度会比同数量级的其它数字慢很多很多。这是怎么一回事呢？ #define SAMPLES 1000 #define MATSIZE 513
目标跟踪：卡尔曼滤波（Kalman Filter）到底是怎么工作的？
Felaim的博客
10-22 4631
Kalman filter到底是怎么工作的？ 本文主要参考的文章：https://www.bzarg.com/p/how-a-kalman-filter-works-in-pictures/，图片也基本来自上述博客 其实接触KF已经很久了，听过对应的课程，也跟过参考数进行推导，但总有一种感觉，始终在门外，没有醍醐灌顶，融会贯通的感觉，所以还是写篇博客，毕竟通过强行让自己输出一下，也会帮助理解和记忆。 一、什么是Kalman filter？ 说到KF，就LZ目前有限的接触中来说有SLAM，tracking等一
android安卓源码海量项目合集打包-1
热门推荐
chenhao0568的专栏
06-11 15万+
下载地址 最后更新共计113个分类5177套源码29.2 GB。 卷 新加卷 的文件夹 PATH 列表 卷序列号为 00000200 5E7A:7F30 F:. ├─前台界面 │ ├─3D标签云卡片热门 │ │ Android TagCloudView云标签的灵活运用.rar │ │ Android 实现 标签 拖动 改变位置.rar │ │ android 流式布局和热门标签.zip │ │ ...
2维FFT算法实现——基于GPU的基2快速二维傅里叶变换
痞子龙3D编程
11-29 3133
2维FFT算法实现——基于GPU的基2快速二维傅里叶变换 上篇讲述了一维FFT的GPU实现（FFT算法实现——基于GPU的基2快速傅里叶变换），后来我又由于需要做了一下二维FFT，大概思路如下。 首先看的肯定是公式： 如上面公式所描述的，2维FFT只需要拆分成行FFT，和列FFT就行了，其中我在下面的实现是假设原点在F(0,0)，由于我的代码需要原点在中心，所以在最后我将
MATLAB视频运动目标检测参考源码
m0_55395440的博客
08-30 685
MATLAB视频运动目标检测参考源码将视频截取成帧fileName = 'q.avi'; %此处输入视频名称，要带后缀，注意好像只有wmv和avi格式obj = VideoReader(fileName);numFrames = obj.NumberOfFrames;% 帧的总数 for k = 1 :numFrames% 读取数据 frame = read(obj,k); ims...
FPGA抗单粒子翻转效应设计评估与北斗卫星导航终端效能评估
### FPGA抗单粒子翻转效应设计评估与北斗卫星导航终端效能评估 在航天等领域，FPGA（现场可编程门阵列）和北斗卫星导航终端都扮演着至关重要的角色。FPGA在复杂的空间辐射环境中面临单粒子翻转（SEU）的风险，而...
编码器测速精度提升术：电赛小车速度反馈误差补偿的5种工业级方法
# 编码器测速的深度优化：从理论建模到工业级闭环实践 在智能制造、机器人运动控制和自动化设备日益普及的今天，速度反馈系统的精度与稳定性已成为决定系统性能的关键瓶颈。想象一下，一台高速贴片机正在分秒必争地...
时序一致性难题破解：高端STM32多总线矩阵下外设同步的3种工业级解决方案
# 时序一致性难题的本质与工业场景挑战 在工业自动化与精密控制领域，多外设协同工作的时序一致性直接决定系统可靠性。当ADC采样、PWM输出与编码器反馈不同步时，将引发控制抖动甚至系统失稳。...
%% 参数设置 c = 3e8; % 光速 [m/s] B = 500e6; % 带宽 500MHz Tc = 100e-6; % 调频周期 100μs Fs = 30e6; % 采样率 30MHz N_pulses = 128; % 脉冲数（用于测速） F0 = 24e9; % 载频 24GHz lambda = c/F0; % 波长 N = round(Tc*Fs); % 单个脉冲采样点数 t = (0:N-1)/Fs; % 单个脉冲时间向量 S = B/(Tc/2); % 调频斜率修正 PRI = Tc; % 脉冲重复间隔 %% 目标参数（四个目标：两个真实、两个虚像） targets = [... 50, 10, 1.0; % 真实目标1: 距离100m, 速度15m/s, RCS=1.0 55, 2.8, 1.0; % 真实目标2: 距离150m, 速度-10m/s, RCS=0.8 40, 5, 0.6; % 虚像1: 距离60m, 速度25m/s, RCS=0.6 64, -8, 0.5 % 虚像2: 距离180m, 速度-20m/s, RCS=0.5 ]; %% 窗函数配置（修正维度问题） range_win = hamming(N)'; % 距离维窗（行向量：1×N） doppler_win = hamming(N_pulses); % 速度维窗（列向量：N_pulses×1） win_corr_range = sum(range_win)/N; win_corr_doppler = sum(doppler_win)/N_pulses; %% 发射信号生成 Tx_freq = zeros(1, N); Tx_freq(t <= Tc/2) = S * t(t <= Tc/2); Tx_freq(t > Tc/2) = B - S*(t(t > Tc/2) - Tc/2); phase_tx = 2*pi*cumsum(Tx_freq)/Fs; % 相位积分 Tx_pulse = exp(1j*phase_tx); Tx_signal = repmat(Tx_pulse, N_pulses, 1); % N_pulses×N矩阵 %% 接收信号生成（多目标处理） Rx_signals = zeros(N_pulses, N); % 预分配接收信号矩阵 for pulse_idx = 1:N_pulses rx_pulse = zeros(1, N); % 当前脉冲的回波信号 current_time_offset = (pulse_idx - 1) * PRI; % 处理每个目标 for target_idx = 1:size(targets, 1) dist = targets(target_idx, 1); vel = targets(target_idx, 2); rcs = targets(target_idx, 3); current_dist = dist + vel * current_time_offset; td = 2 * current_dist / c; delay_samples = round(td * Fs); % 确保延迟在合理范围内 if delay_samples >= N delay_samples = N - 1; elseif delay_samples < 0 delay_samples = 0; end % 多普勒相位计算 doppler_phase = exp(1j * 4 * pi * vel * F0 * current_time_offset / c); % 生成时延信号 delayed_tx = [zeros(1, delay_samples), Tx_pulse(1:end-delay_samples)]; % 叠加当前目标的回波信号 rx_pulse = rx_pulse + sqrt(rcs) * delayed_tx * doppler_phase; end Rx_signals(pulse_idx, :) = rx_pulse; end %% 差频信号处理（修正维度问题） IF_signals = Tx_signal .* conj(Rx_signals); % 混频得到差频信号 % 距离维加窗处理（修正维度） IF_windowed_range = IF_signals .* repmat(range_win, N_pulses, 1); % 应用距离窗 range_fft = fft(IF_windowed_range, [], 2); % 对距离维做FFT（保持原始顺序） % 速度维加窗处理（修正维度） IF_windowed_doppler = range_fft .* repmat(doppler_win, 1, N); % 应用速度窗 doppler_fft = fft(IF_windowed_doppler, [], 1); % 对速度维做FFT % FFT移位和幅度校正 range_fft = fftshift(range_fft, 2)/win_corr_range; % 距离维移位 doppler_fft = fftshift(doppler_fft, 1)/win_corr_doppler; % 速度维移位 %% 坐标轴生成（修正计算） % 距离轴 range_bins = linspace(-Fs/2, Fs/2, N); % 频率轴 range_axis = range_bins * c/(2*S); % 转换为距离轴 max_range = c/(2*S) * Fs/2; % 最大显示距离 % 速度轴 doppler_bins = linspace(-1/(2*PRI), 1/(2*PRI), N_pulses); % 多普勒频率轴 velocity_axis = doppler_bins * lambda/2; % 转换为速度轴 max_velocity = lambda/(4*PRI); % 最大无模糊速度 %% 目标检测与虚像识别（改进算法） magnitude_spectrum = abs(doppler_fft); detected_targets = []; % 查找所有显著峰值 threshold = 0.05 * max(magnitude_spectrum(:)); % 动态阈值 [peak_rows, peak_cols] = find(magnitude_spectrum > threshold); % 处理检测到的每个峰值 for idx = 1:length(peak_rows) r_idx = peak_rows(idx); d_idx = peak_cols(idx); dist_val = range_axis(d_idx); vel_val = velocity_axis(r_idx); amp_val = magnitude_spectrum(r_idx, d_idx); % 排除边界附近的假目标 if abs(dist_val) > max_range*0.9 || abs(vel_val) > max_velocity*0.9 continue; end % 虚像检测标准：1.速度接近最大速度 2.幅度异常低 3.距离位置异常 is_ghost = (abs(vel_val) > max_velocity*0.8) || ... % 速度接近极限 (amp_val < threshold*5) || ... % 幅度过低 (dist_val < 10 || dist_val > 190); % 距离边缘异常 detected_targets = [detected_targets; dist_val, vel_val, amp_val, is_ghost]; end %% 绘制结果（优化显示） figure('Position', [100, 100, 1400, 800]); % 1. 距离-速度二维谱图 subplot(2, 2, [1, 3]); imagesc(velocity_axis, range_axis, 20*log10(abs(doppler_fft'))); xlabel('速度 (m/s)'); ylabel('距离 (m)'); title('距离-速度二维谱 (RD谱)'); axis xy; colorbar; colormap(jet); caxis([-50, 0]); % 设置动态范围 grid on; xlim([-35, 35]); ylim([0, 200]); % 标记目标位置 hold on; for i = 1:size(detected_targets, 1) if detected_targets(i, 4) % 虚像 plot(detected_targets(i,2), detected_targets(i,1), 'rx', 'MarkerSize', 12, 'LineWidth', 2); else % 真实目标 plot(detected_targets(i,2), detected_targets(i,1), 'go', 'MarkerSize', 12, 'LineWidth', 2); end end hold off; legend('虚像目标', '真实目标', 'Location', 'northwest'); % 2. 距离维度剖面 subplot(2, 2, 2); range_profile = sum(abs(doppler_fft), 1); plot(range_axis, 20*log10(range_profile)); xlabel('距离 (m)'); ylabel('幅度 (dB)'); title('距离剖面'); xlim([0, 200]); grid on; 分析代码中存在的问题，注：生成的rd谱存在严重错误，补全代码
最新发布
09-17
2. **混频信号维度问题**：`Tx_signal`是一个`N_pulses×N`的矩阵，而`Rx_signals`也是同样大小的矩阵。混频时使用`Tx_signal .* conj(Rx_signals)`，这一步是正确的。 3. **加窗问题**：距离维加窗使用`repmat...
CMake指定目标代码的平台（win32，x64）
LC
06-03 1万+
主要参考自：[url]http://blog.youkuaiyun.com/yxnyxnyxnyxnyxn/article/details/10147461#[/url] cmake-gui用法参见：[url]http://www.cnblogs.com/freedomshe/archive/2013/01/11/win7_vs2012_opencv_rebuild.html[/url] [siz...
矩阵库Eigen的MatrixXd中预定义的类型
LC
04-29 2784
[size=large]在使用Eigen编程时，到处是Curiously recurring template pattern，那么，我们如何知道一个矩阵中存的是double型变量还是float型的变量呢？ 有人会说， MatrixXd中存的就是double型变量MatrixXf中存的是float型变量啊！[/size] 我是无耻的插队者：不了解Curiously recurring te...
Eigen的编译选项；MKL的使用
LC
08-26 2597
[size=large]使用时在工程的property页面的如下图所示位置定义（或者在#include 前使用#define定义）：[/size] [img]http://dl2.iteye.com/upload/attachment/0100/5613/6c060444-c6f7-3f3e-8eb0-bb3ff4768e01.png[/img] [size=x-large][color=...
C++ 获取变量名称 & 获取类型的名称
LC
12-18 2172
[size=x-large][color=blue]1、获取变量名称[/color][/size] [size=large]采用如下宏定义即可，这个宏定义将表达式x直接转换为对应的字符串：[/size] [code="c++"]#define varName(x) #x #define printExp(exp) cout...
【测速】memcpy()对比for循环逐个对象拷贝
LC
11-16 2021
[color=red][size=x-large]结论：[/size][/color][size=large]一般情况下，memcpy()函数比for循环快个一两倍，某些特殊值上稍微慢点儿。[/size] [color=red][size=x-large]注意：[/size][/color][size=large]对于需要构造函数、析构函数的类，可能要在拷贝时重载=运算符，此时memcpy(...
CUDA程序block和thread超出硬件允许值时的异常
LC
07-13 1843
调用CUDA的核函数时指定block 和 thread大小，该大小可以是dim3类型的（三维数组），只用一维时可以是usigned int型的。 以下程序验证了当block或thread大小超出硬件允许值时会产生异常！！！GPU根本不会执行运算！！！ 所以验证结果的正确性很重要！！！ 在VS中创建CUDA项目会有一个模板，里面有更详细的状态验证。 以下程序在K5000GPU上跑的。...
矩阵乘法测速对比：TeeChart5绘制6种循环嵌套性能图
在标题“利用TeeChart5动态绘制不同循环嵌套的矩阵乘法测速折线图”中蕴含的知识点主要涉及矩阵乘法的性能测试，动态数组的应用，以及如何使用TeeChart5控件动态绘制折线图来可视化数据。现在我们将详细阐述这些知识...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值