找回密码
 注册
关于网站域名变更的通知
查看: 441|回复: 1
打印 上一主题 下一主题

matlab与c语言混合编程

[复制链接]
  • TA的每日心情

    2019-11-20 15:22
  • 签到天数: 2 天

    [LV.1]初来乍到

    跳转到指定楼层
    1#
    发表于 2020-12-10 13:41 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式

    EDA365欢迎您登录!

    您需要 登录 才可以下载或查看,没有帐号?注册

    x
    前言:

    众所周知对于循环这种运算,matlab的运算速度是不快的

    想起来个冷笑话,黑客帝国里的主角呢奥之所以能快过子弹,因为Matrix是matlab写成的hhhh

    因此将循环部分用C语言写,然后编译成matlab可以调用的mex文件,无疑可以加快循环运算速度,从而加快整个代码速度

    之前因为合并数据需要不会数据库,强行在matlab里利用类似excel的vlookup功能,无奈太慢,只能想办法最后知道了这种方法,最近偶然在桥哥的知识星球里又提到了,也顺便复习和记录一下。

    ps:今天在闲鱼上买了小车车,高兴!


    1.环境配置

    我的是matlab2019a,win10-64bit,c语言编译器我选的是TDM-GCC(gcc/g++),安装起来很简单,推荐matlab2015及以后的选择这种,详细安装过程可以见文末链接1中的For Matlab 2015部分


    " P% J) ]/ M5 m4 ?1 |- U, ]2.如何编写可以被编译成matlab可执行文件的c语言代码

    我是在matlab中文论坛(地址见reference第2条)里找到如何编写的,不过他写的有点乱,我来消化后写一下自己的理解

    mex接口函数跟一般的C语言文件主要是两点区别,

    第一是必须引入头文件mex.h

    #include "mex.h"

    第二是多了一个叫mexFunction的函数

    void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])

    举个栗子:


    • ! G6 ^/ S( A  a% E# {

      / Y. Z  p4 b$ Q8 g9 r# H5 ]#include "mex.h" // 使用MEX文件必须包含的头文件
      4 g5 B; R$ k1 c8 M+ l: G6 Z
      6 H! t, s2 q, N

    • 7 j  N/ j, D' l

      5 N* b$ c9 j" \9 [6 c# o% _// 执行具体工作的C函数+ D: i6 }, ]9 H& O/ @* H7 z9 n4 j
      5 i7 T! U. n" I- ^  M1 x2 c& g

    • ; K1 t+ }- Q4 y- H

      , ?* k5 m: h) K* \& g; odouble add(double x, double y)6 B. L  I6 y* t0 Q% u2 F& t/ ]
      - Z8 h& u0 M4 v) i% ~3 R2 k# P
    • 0 ?2 J$ O' U. G2 g1 g

      * a8 |: b8 T+ g0 {; n5 R2 V6 ^{
      7 e1 V" J: E* L' q8 o& I# m' f* |

      : @9 C% a! |# P% C+ K8 \
    • - Q" W4 t7 }$ M% L) i* C  V+ b7 e

      ' f& I& v! s( q; B+ ~+ Y    return x + y;
      4 [; h/ n. m5 n& E0 g3 S
      5 G! X* N! f0 N! z3 H, X. k
    • + z3 M8 g" _5 h2 D& m7 g

      1 `' H4 y% I3 Q}
      / W0 A' q& K* k' v' I) o  v
      3 T3 c) h$ A/ q0 D2 b
    • + h* ~8 A; p  w- P6 |& F

      & B. p+ ~" M1 l// MEX文件接口函数  n1 w* ?! W8 d% M) o' g
      # Z6 |( E3 G% F# I# M2 Z2 R
    • " U  G. b# ^/ D! H$ X0 J6 k

      ) R7 c) N) x. H9 ?* `# @void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
      % s5 ~+ x/ f9 H4 \
      * M" x- A1 C( ?- r
    • 8 r  B0 _$ t; w( }' ~( j8 Y5 n
      % h- ?, a$ P6 X5 ]; Y. q0 p! e" i  L
      {' e& Z8 e. ~% ]

      + y  k) \) N) k
    • 4 n1 a# u4 x5 G) F* m( z# w

      1 h" e8 T) X6 c# v2 W2 Q& j    double *z;
      * g  o# K! L0 @7 s% H

      % y. j! B  j* H& J

    • & T' Y$ o) @# K& y- ~# H2 V* G, W+ p
      $ b# B7 h' l2 c# f
          double x, y;. f% e3 s0 n3 u5 r
      , z, y# K) j9 U; _

    • 9 f% G; X+ F! k* p+ I+ D
      ' \1 J2 x% a" O
          plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);% o6 [& v  Y+ L! h9 C  t: P: J
      , S9 c" v# q, U7 V$ T+ H9 G
    • 4 @, L+ J: R& M

      6 i4 C+ J4 A4 K3 N1 ^6 a$ `    z = mxGetPr(plhs[0]);, s! P( \# W' x8 `6 L* e, j

      3 g0 Y8 l$ E" K! b1 P- ?- E

    • . i) z! i- y6 k* ~! l

      7 b; b) @1 M/ F8 E8 ~# Q    x = *(mxGetPr(prhs[0]));
      * a8 i# _9 Q- q' K% B) V& I/ r

      8 S0 V7 n6 d7 U6 ^" \/ E- t! v

    • 0 U/ x3 I1 f/ E

        ^8 i5 W' u$ i1 G9 p8 S    y = *(mxGetPr(prhs[1]));) F8 t& o7 l' q% f
      3 ]8 d. j% x' h8 K7 A) {5 E/ N, D
    •   |4 ]4 N! h5 j5 @  R8 R  r
      ' w5 ~1 `+ C1 Q$ v- Q7 k" v
          *z = add(x, y);7 t8 L9 @5 ?6 K
      6 B& Z, M9 t1 p( m. m9 s

    • - i1 L+ M2 I# U
      % V, y2 S) Z7 j6 |2 D: t
      }
      " X+ Y7 d7 a7 E5 O$ y6 m

      6 p  @. F" R; E* H6 w. [) ]: V
      / p2 C% [, O2 }

    也可以写成:

    • * G0 K& c! |7 v1 g4 T/ ^- q
      ! I: E% G) m& t# G' T" A% {! H
      #include "mex.h" // 使用MEX文件必须包含的头文件: J, W# i  F- a3 }
      8 q0 P, E. P& O
    • : w2 ~0 b. {4 c" w
      % U4 T5 u/ z* \# [/ z. |
      // MEX文件接口函数
      0 E' S# n1 Q! V& s/ y* s; \

        Y" N9 p  P6 m
    • * U! y  |0 C6 |7 A0 t

      ) S# ?( p$ A. E, N1 W! t$ R2 kvoid mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])
      * P- _$ ^9 `# d$ M9 w6 W! t
      8 Z/ L# }( F( H; q1 W- I
    • 2 M# Q* F' X) g  U

      * m4 B8 h5 f' I) T- s{4 ]: {- Y# {) n$ D& B
      - ?$ [( _2 L) r6 S# ^
    • 2 g5 I) C% G* c+ V  b. b+ M' m. v
      % o4 E9 j+ @1 C  W5 F4 X! R! K
          double *z;
      * ^8 y  n+ d; L. c3 T( |7 W& N

      * u0 G# d  u, ~% c6 V5 Q" p
    • 3 F6 ~8 a7 B. m0 z5 ^6 J

      0 D6 m- C3 @' E  i" a3 V9 }( S    double x, y;
      ! ~8 o0 U# p* e5 {/ S

      " ~( [! q; g( q$ m2 e
    • 9 ]3 h( Y) c+ B- @" \
      5 u) j5 ~3 n% Y+ f
          plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
      ! w3 _. ^$ w+ y, f% b
      6 a7 g& v' y; n' F! G

    • 4 D2 s; I  E: \2 |' C+ E6 V! g

      % w: P9 x: c# @! C1 d    z = mxGetPr(plhs[0]);
      8 A, B  O, h5 D6 n+ ^

      ; y- z. q; {8 f

    • 7 [+ Z$ R, }- F
      / ]- _2 U. a7 w
          x = *(mxGetPr(prhs[0]));  m1 u* e7 g* r. L: Y. I- X) K

      . g0 D# W+ z* c$ Z
    • % l4 X& |5 I0 R5 N% |0 F% d
      / T) s* M) Q* d1 m" X" K- D
          y = *(mxGetPr(prhs[1]));& X! f* ]0 t' e) D" x
      6 L+ l1 u( {: C. B( R/ K) M# X

    • ; o( `0 y2 O" L) }- U
      + g* S. E. L5 A# Y1 Q/ y
          *z=x+y;
      ) O" m- o" P7 j* {# R

      5 ]+ w) d5 C5 I  J/ P. C

    • 6 g; _6 t: k# a# e

      $ z/ v; R9 C+ O" W}/ b9 P4 B, K1 n( d& u0 j  p

      - Q1 C1 U$ N7 ~" T" Y7 P. t7 e0 v- n5 e9 i; W+ u8 Q

    也就是说执行具体功能可以通过编写一个独立的c语言函数在接口函数里调用,也可以直接写在mexFunction接口函数里

    我个人推荐将具体功能独立出来,这样一来:

    c语言函数负责执行具体功能

    mexFunction接口函数负责数据的输入输出(将matlab数据输入c语言环境,运算后再输出回matlab)形式组织

    再调用c语言函数

    分工明确。

    于是关键问题就是如何编写mexFunction接口函数了

    void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])

    下面解释一下mexFunction各个参数的含义(这里看到是void,即无返回值,因为传值是通过指针数组plhs[]传出的)

    参数
    意义
    英文全称
    类型

    . H. w; u: F, m* E3 \$ Z9 Knlhs左边输出参数的数目number of left-hand side整型(int)
    , [+ c2 @3 U0 G' k2 Z* m2 gplhs指向输出参数的指针pointer of left-hand side指针数组
      n2 \* O9 B  I, ^: z' qnrhs右边输入参数的数目number of right-hand side整型(int)
    + ^' D- o: U6 A+ j9 k1 O5 a, ?prhs指向输入参数的指针pointer of right-hand side指针数组
    , H7 n* O/ x  s$ ~

    第一个参数nlhs是输出参数的数目,第二个参数plhs是指向输出参数的指针

    第三个参数nrhs是输入参数的数目,第四个参数prhs是指向输入参数的指针

    其中plhs和prhs类型都是指向mxArray类型数据的指针,prhs这里还加了个const,这里的const跟之前c语言中是一样的,代表不改变,因为prhs是指向输入参数的指针,mxArray这个数据类型是在头文件mex.h中定义的,in fact ,在matlab中大多数数据都是以这种类型存在。

    还是拿之前的栗子来解释:

    • % |6 e3 h. ^2 q8 v* \$ ]5 E

      4 X3 {% c% G6 w9 @/ U9 n( S#include "mex.h" // 使用MEX文件必须包含的头文件
      / ?+ c  f, Y* |: I# w8 O
        C' Q( z( p$ I" {* P0 y, V( b) ]' L  J4 a
    • ) J9 @" r2 V; F: B6 O

      3 n; M8 }7 g: I4 ^// MEX文件接口函数5 q4 N2 K0 k4 O( j6 B
        ]1 E7 V) E! c8 p1 {

    • ' M! M6 r- t! l, y" _9 Z* E, a
      $ L! _9 A; c/ D4 _- o0 z0 ~7 {
      void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[]), H+ p' R! ^/ J: A* P$ Q2 {

      * k% U/ c8 [+ M" H- K4 V
    • 4 |* D, H9 U1 a* F  l3 j
      8 o- g& ~; N$ T3 Y5 J. _: }
      {
      - N8 u, {+ x* B- w' T2 e
      - h$ h% W/ p, `+ X* ]1 p7 E8 s! t

    • 5 D1 d6 C: l1 R3 i/ i
      # W% J4 t( ]! I; E; B1 Q
          double *z;8 [" c% j' F/ \, I
      7 X0 o3 z4 f1 {. w+ ^
    • * c4 o. m7 |6 K

      + O, G: J) B9 P, @3 z8 k7 }    double x, y;
      ( d( h/ A6 f, X8 O" S
      ( L- q" N& Q* Y4 [" }  _; U$ }: R3 i

    • 3 c- n7 R8 R& s- G+ Y

      ( l5 c, s2 p6 q+ q, [4 y    plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
      4 [; K. ~0 e. q# u% V0 g4 k  F. `

      . Z! [' V4 z8 y7 s2 K: B
    • ! F) b; z2 m# p+ L
      + H4 N* k, c) D8 j# f$ t( D
          z = mxGetPr(plhs[0]);8 W; r( H: Y) `
      # k" n  x6 F1 F

    • ) q8 b. p" e. f/ C% s4 c: i
      " _( Q* A' U" s. u! @. z  C$ v- s
          x = *(mxGetPr(prhs[0]));) f2 c9 m: U- g' S6 T# ]
      : U2 _: B. Q0 ]1 [7 h1 h

    • 3 v3 P/ [6 M: v; c, J+ a/ r) w" u

      ! a5 s! R* M2 o7 b6 p, G    y = *(mxGetPr(prhs[1]));
      ( k% n& z" ]9 i6 D

      6 H6 `( I, M  F' g  Z8 h9 j' Q1 Z

    • - e% C" O  V  y; {- i) l8 I

      ' o* @8 }( L: B& A% }0 v* _    *z=x+y;
      ' T$ D. X; l+ b" \4 c' D7 w) Y

      . T' H; n+ R& w5 P
    •   O  i/ @  Z7 S5 j9 v8 c

      % I+ s# G, b4 r! Y% n  f; Y5 L}9 b" T$ U  [! K# x# ?" j5 I2 Z

      # p. ^- w+ N6 Q( v$ z% H2 K* f# c' L7 y% ?

    在这个栗子中,输入参数是x,y,输入参数是z(虽然没有返回)

    plhs和prhs其实都是指针数组

    prhs[0]代表指向第一个输入数据的指针,mxGetPr代表获得这个指针,后面再加个*就是c语言里面再正常不过的按指针取内容了

    所以就这样x,y通过下面这两句传入到了mexFunction中

    • 0 i* A7 I0 \0 w% h: D

      5 g2 |' u# L' a1 ?x = *(mxGetPr(prhs[0]));
      ( k0 I( @# D9 U" ]5 b$ h# k- N
      # C/ Q3 i% p3 d* `! D& O! U

    • + W3 _. H" {: g; ?* S  T
      0 M: U; L. R6 b/ f
      y = *(mxGetPr(prhs[1]));
      . i" O5 V2 T% y- B

      & z( a( n( f+ ^( F0 X$ h/ Y
      8 n7 c/ J3 C3 n% k4 r" |; l2 b6 p

    mxGetPr函数的功能是从指向mxArray类型数据的指针prhs[0]、prhs[1]中获得了指向double类型的指针

    另一个函数是mxGetScalar,Scalar即标量,功能是把通过prhs传递进来的mxArray类型数据的指针所指向的数据(标量)赋给c程序里的变量。前面的mxGetPr是传递矢量的,否则矩阵或者向量就没有办法传进来

    这里由于传入的每个参数是单个值,于是也可以用mxGetScalar改写:

    • # u$ d$ ]6 X" w; Y3 L
      , F; c+ I0 t- K9 x3 t8 K
      #include "mex.h" // 使用MEX文件必须包含的头文件
      1 R6 n4 j+ k  d" f, C( o

      : l- K. x# G& K1 l; j6 O0 w

    • . Q- M5 L/ ]& K5 v& x, Z! G
      6 `' q, N$ U9 ~
      // MEX文件接口函数
      ; ~2 ^6 Q7 S# L# T5 K' h7 I
      2 ~0 r( b1 b/ y: G4 p
    • 2 b: a# D+ l* z: J/ p- I
      & W! S4 ~) E% S) Y! o. U  u7 f3 t
      void mexFunction(int nlhs,mxArray *plhs[], int nrhs,const mxArray *prhs[])' q' v8 z. z+ B6 z, }
      " O9 p( G$ \5 j! B
    • & G( R6 L4 ]7 v& y1 w, z) B

      - h+ W' f6 ~, z8 r+ h. S( W{2 ], e3 O, A1 j# c& j! V& [
      8 D9 c3 M1 z& O, `3 O* B7 K: U. i
    • , @+ y2 W% W$ @5 w/ M# }- f
      " T! [& Q/ [& x7 [( m
          double *z;2 u0 p- G3 v8 H1 g$ [+ A
      0 A& T" e* y4 K& f' \0 K

    • ( b  W6 ?  H) D. H
      0 L( q7 X+ u' @9 ^! P9 I' E
          double x, y;6 y# |9 Y- u% S4 h. m

      ! H  |9 |6 U! U

    • : o: q7 V9 D- N2 _, w
      8 ?( B# D4 `! I
          plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);
        q( m4 j* Q$ o; j9 W4 z3 z& @! N
      2 ^% O' \. d1 b1 V( ]

    • 7 u6 b1 Q9 o" X3 }" O) A8 m" E

      8 ^% T' P, q+ e/ a    z = mxGetPr(plhs[0]);0 p& u+ Q) f' u/ O, ]( M, \: @6 d
      8 u# k% i' L, V
    • - t. c; W$ n, k4 U0 F

      7 l( H, a8 L- J# o3 j    x = mxGetScalar(prhs[0]));# ~3 v9 V. S( G% n, {% G
      8 H( w# u/ B1 m1 \+ s! v$ g
    • 2 ~! |+ o( [7 I; l
      5 _( h4 p5 n* R6 {8 |. ]& h& A% Y
          y = mxGetScalar(prhs[1]));0 F" S6 `" s# Q7 u3 J, l2 n! Z
      4 F1 u+ w* g2 c, E) [/ j; E7 d
    •   }1 Y: z* v7 X6 A9 V  h) F
      1 ]; o6 j  F) {3 Q
          *z=x+y;7 s* F" |. J# E2 v6 |
      / e8 t, r! U  {- J4 u
    • 4 J4 f3 l! \8 J. I. C8 S) N
      & g3 C/ m; }- i* l
      }
      0 `# `- F0 ~# y; B: S% h

      9 o! d) s9 e2 p( }: c/ l% }5 J9 V, }/ i0 Q$ x/ i7 ?

    (注意:输出参数因为需要通过指针传出,因此这里z必须用mxGetPr这个函数来从mxArray指针获取double指针)

    但是这样还是有个问题:如果输入的不是单个的数据,是向量或者矩阵,即使我们通过mxGetPr获得了矩阵或者向量的指针,但是我们假如不知道矩阵的shape,还是不好取值或者计算,所以这里又有两个函数mxGetM和mxGetN可以通过传入参数指针获得传入参数(矩阵)的行和列数。

    需要注意的是:

    在matlab中矩阵的第一行和第一列的序号是从1开始的,而在c语言中是从0开始的,而且在c语言中的一维数组存储矩阵的数据时,是一列列从上到下,从左到右来存储的,也即

    matlab中一个m*n的矩阵M(i,j)对应于c语言中一维数组N中的N[j*m+i]

    举个栗子:


    • # Z7 G2 U% Y4 Z9 p6 l. l: [: J
      ) L/ _) v! K" v" f7 }
      #include "mex.h"' d0 ]% y- Y  \. P8 H6 E! g

      . L! M% I7 d5 j% Z' O
    • 1 V- T$ I/ R0 \; t8 z1 |6 k
      0 p' x3 g# u% P" I+ w
      void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]){: [6 k( r1 K# W: l- H. P

      $ D5 ?6 s) m8 X5 n& ]; w8 m# x! X

    • 5 c* `: C2 j! }, d

      6 z# G# n) c8 @7 D
      - K. J+ J; [: x9 D5 T

      + h1 R8 v: Z/ N
    • 7 A/ y) V/ x- T; c* W! O6 Y
      3 |6 W( T8 M7 K9 D: r
      double *data;8 D' E/ K: p8 s7 z3 i0 I
      ) e" f$ C) d- w% @5 {5 n5 R

    • 5 c- V( u) U" ?6 H$ o+ J: x

      - L$ N8 S( @8 Nint M,N;
      / v4 S2 @7 o, C6 B) z1 {' ~  m$ i6 X
      * L, M% E, a' @4 |

    • 5 `: T! y* u; E5 L

        |9 ~% D. x) q2 [int i,j;7 }3 h0 B1 }! o) O/ Z4 s
      / K$ ?& m- X( m/ L1 `) m. w2 Y# S8 M

    • ' ^# D( U) z* E$ Q, ?& D
      " [3 Y7 D2 Z2 U3 |1 A! D) V4 Z! l
      data=mxGetPr(prhs[0]); //获得指向矩阵的指针6 D6 C$ Z4 b. B* |, z1 T: `4 a1 U

      ( K  a2 i+ E: T, b* X. \+ x
    • / ~7 {( `9 n& Q& J

      $ x" n' b1 O, _M=mxGetM(prhs[0]); //获得矩阵的行数
      5 }' T  d; S1 }) ~9 z

      9 O( I# Y) j. I8 |* i* P
    • * i1 G5 s$ ^+ v1 y
      : \) r% s8 n+ R# K/ P7 J
      N=mxGetN(prhs[0]); //获得矩阵的列数# m9 v+ V$ ^2 v- }
      + h0 [; v! H1 Q1 o* I
    • 3 g( d& t# k. F  c
      8 |) D8 ]/ v) @
      for(i=0;i<M;i++)- h4 l# }* M0 B- \3 U6 i9 ]; H

      ) \& I  z, B4 v7 o& s2 L& |. Y

    • ' G$ ?0 z8 a0 r) ?

      ( P# H( k$ q9 m) T; l( N{
      % T9 r( X3 Y: X8 A" ?
      ! H3 C( U. f+ ^, y! c! f
    • 3 E; d- U8 y% o

      / k) l( H' Z0 m5 c) b   for(j=0;j<N;j++)( i1 k6 w" x8 u
      " p9 U# \" H) i- L$ m/ h* l

    • 4 v1 B0 j: w" r3 S$ `/ ~8 o

      4 l& q- Z+ o- m6 G' k    mexPrintf("%4.3f  ",data[j*M+i]);
      3 w* f& A# n7 i; j( M3 E

      1 A) m2 d" a. T4 T" C
    • 5 h( }! h* @% G$ K- K
      8 C' n/ r1 X) A  B
         mexPrintf("\n");
      3 L0 ?6 X( L) T) Z9 V4 V

      ! l" R3 J7 m" t+ E  e$ S8 J9 g0 C
    • ) ^* h) G" n& u& [, \. p& N- O

      + C  i2 x+ h  _5 U6 F6 _}
      / }: T$ G" H2 `$ ]$ Q+ S$ Z7 j
      / b/ S2 f1 O1 l% }( M

    • 7 [4 I" I6 Q# O7 k% ~) s3 F
      ! a. O% o; @6 b, r. p0 {. a
      }8 ^: U, K0 g7 k+ _0 N& L; l

      * `- R( [( J6 }
      & b3 O3 S, X, d9 `/ {" R! q. e

    假如是一个形如[1,2,3;4,5,6]的矩阵,则执行上述后会先后打印出1,4,2,5,3,6

    以上讲的都是输入参数,由于输入数据在函数调用前就已经在matlab里申请过内存,由于mex函数与matlab共用一个地址空间,因此通过prhs传递指针即可传入输入参数。但输出参数却需要在mex函数里申请内存,才能将指针放在plhs中传递出去。由于返回指针类似必须是mxArray,所以matlab专门提供了一个函数:mxCreateDoubleMatrix来实现内存申请,函数原型为:

    mxArray * mxCreateDoubleMatrix(int m,int n,mxComplexity ComplexFlag)

    m,n分别是待申请矩阵的行数和列数,需要注意的是为矩阵申请内存后得到的是mxArray类型的指针,就可以放在plhs[]中传递出去了。但是对这个矩阵的处理(包括赋值)却需要在mex函数或者c语言函数中完成,这就需要通过前面的mxGetPr或者mxGetScalar。使用mxGetPr获得指向这个矩阵的double类型指针后,就可以对这个矩阵进行各种操作和运算了。

    还是拿这个栗子讲,这里由于输出是一个数,于是m,n都是1,通过mxGetPr进一步获得指向double数据类型指针z

    • , h5 m. d; w% U% ~

      - p/ G2 p' H6 {& U2 J! r9 R9 B4 i+ H# n/ I6 Z4 r+ K4 B

      & {; O5 N' Z. M& [' u

    • 0 d% ]; K0 O4 p( F" }
      $ h1 z( o9 R2 g4 ]$ k  D9 u! h$ W
          double *z;
      1 g) G9 I" b, |; ~9 l  W

        j4 v+ f" ~7 E/ I3 R0 o4 |* N

    • ; ?- S" ]% R& M

      4 d* I- j, Y" p6 Z2 ^7 {2 n! f    plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL);% n) D, H( r, P) o6 U! N
      : a( J0 q& D- X7 R4 R

    • ) p2 W; w" V6 t' X

      ) H* {& M( L3 |: a' D$ R/ _) O    z = mxGetPr(plhs[0]);6 I: s2 `  y( c9 C6 ~

      1 Q  f$ l2 U: a8 }$ s  U) X6 X4 s

    • ; {. _' s& p6 l, G/ c8 M

      * ^+ f- Y" L, K+ ^' e7 E" Z    x = *(mxGetPr(prhs[0]));
      8 y+ M0 U, p/ n$ T

      9 a4 P+ c# J$ S3 |
    • 6 R5 K! a. v: U5 p+ C
      9 n1 U& b  o$ h
          y = *(mxGetPr(prhs[1]));
      3 k3 z9 U) W5 B: \8 s
      6 C* I& z; B' h" `
    • - N9 \5 C) D* @. Q. \; C

      & h7 @6 l" Z1 o  N6 ]. c    *z=x+y;
        o+ n* c# {+ F1 a
      1 J- ]2 G( s. U

      + m4 {+ V) k) D6 `2 \* \

    当然,matlab里使用到的并不只是double类型这一种矩阵,还有字符串类型,结构类型矩阵等,并也提供了对应的处理函数。


    1 N5 x& t( N; X7 A& C

    该用户从未签到

    2#
    发表于 2020-12-10 15:10 | 只看该作者
    matlab与c语言混合编程
    您需要登录后才可以回帖 登录 | 注册

    本版积分规则

    关闭

    推荐内容上一条 /1 下一条

    EDA365公众号

    关于我们|手机版|EDA365电子论坛网 ( 粤ICP备18020198号-1 )

    GMT+8, 2025-10-31 23:38 , Processed in 0.156250 second(s), 26 queries , Gzip On.

    深圳市墨知创新科技有限公司

    地址:深圳市南山区科技生态园2栋A座805 电话:19926409050

    快速回复 返回顶部 返回列表