**System object: **phased.ScatteringMIMOChannel

**Package: **phased

Propagate signals in scattering MIMO channel

Instead of using the `step`

method to perform the
operation defined by the System
object™, you can call the object with arguments, as if it were a function. For
example, `Y = step(obj,X)`

and `Y = obj(X)`

perform equivalent operations.

uses the scattering MIMO channel, `Y`

= step(`channel`

,`X`

)`channel`

, to propagate a
signal, `X`

, from a transmitting array towards multiple
scatterers, and returns the scattered signals, `Y`

, to a
receiving array.

To enable this syntax, set the `TransmitArrayMotionSource`

, `ReceiveArrayMotionSource`

,
and `ScattererSpecificationSource`

properties to `'Property'`

.

`[___] = step(___,`

specifies the scatterer positions and velocities, and the scattering
coefficients.`scatpos`

,`scatvel`

,`scatcoef`

)

To enable this syntax, set the `TransmitArrayMotionSource`

and
`ReceiveArrayMotionSource`

properties to
`'Property'`

, set
`ScattererSpecificationSource`

to ```
'Input
port'
```

, and set the `Polarization`

property to
`'None'`

.

`[___] = step(___,`

specifies the scatterer positions, `scatpos`

,`scatvel`

,`scatmat`

,`scataxes`

)`scatpos`

, and velocities,
`scatvel`

, the scattering matrix,
`scatmat`

, and the scatterer orientation axes,
`scataxes`

.

To enable this syntax, set the `TransmitArrayMotionSource`

and
`ReceiveArrayMotionSource`

properties to
`'Property'`

, set
`ScattererSpecificationSource`

to ```
'Input
port'
```

, and set the `Polarization`

property to
`'Combined'`

or `'Dual'`

.

`[___,`

also returns the channel response matrices, `CR_HH`

,`CR_HV`

,`CR_VH`

,`CR_V`

,`TAU`

]
= step(`channel`

,___)`CR_HH`

,
`CR_HV`

, `CR_VH`

, and
`CR_V`

, using any of the previous input argument
combinations.

To enable this syntax, set the `ChannelResponseOutputPort`

property to `true`

and set the `Polarization`

property to `'Dual'`

.

The object performs an initialization the first time the `step`

method
is executed. This initialization locks nontunable properties and input
specifications, such as dimensions, complexity, and data type of the
input data. If you change a nontunable property or an input specification,
the System
object issues an error. To change nontunable properties
or inputs, you must first call the `release`

method
to unlock the object.

`channel`

— Scattering MIMO channel`phased.ScatteringMIMOChannel`

System
objectScattering MIMO channel, specified as a `phased.ScatteringMIMOChannel`

System
object.

**Example: **`phased.ScatteringMIMOChannel`

`X`

— Transmitted narrowband signalTransmitted narrowband signal, specified as an
*M*-by-*N _{t}*
complex-valued matrix. The quantity

The size of the first dimension of the input matrix can vary to simulate a changing signal length. A size change can occur, for example, in the case of a pulse waveform with variable pulse repetition frequency.

**Example: **`[1,1;j,1;0.5,0]`

To enable this argument, set the `Polarization`

property to `'None'`

or
`'Combined'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`XH`

— Transmitted narrowband H-polarization signalTransmitted narrowband *H*-polarization signal, specified
as an *M*-by-*N _{t}*
complex-valued matrix. The quantity

The size of the first dimension of the input matrix can vary to simulate a changing signal length. A size change can occur, for example, in the case of a pulse waveform with variable pulse repetition frequency.

**Example: **`[1,1;j,1;0.5,0]`

To enable this argument, set the `Polarization`

property to `'Dual'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`XV`

— Transmitted narrowband V-polarization signalTransmitted narrowband *V*-polarization signal, specified
as an *M*-by-*N _{t}*
complex-valued matrix. The quantity

The size of the first dimension of the input matrix can vary to simulate a changing signal length. A size change can occur, for example, in the case of a pulse waveform with variable pulse repetition frequency.

**Example: **`[1,1;j,1;0.5,0]`

To enable this argument, set the `Polarization`

property to `'Dual'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`txpos`

— Position of transmitting antenna arrayreal-valued three-element column vector

Position of transmitting antenna array, specified as real-valued three-element column vector
taking the form `[x;y;z]`

. The vector elements correspond
to the *x*, *y*, and *z*
positions of the array. Units are in meters.

**Example: **`[1000;100;500]`

To enable this argument, set the `TransmitArrayMotionSource`

property
to `'Input port'`

.

**Data Types: **`double`

`txvel`

— Velocity of transmitting antenna arrayreal-valued three-element column vector

Velocity of transmitting antenna array, specified as a real-valued
three-element column vector taking the form `[vx;vy;vz]`

.
The vector elements correspond to the *x*, *y*,
and *z* velocities of the array. Units are in meters
per second.

**Example: **`[10;0;5]`

To enable this argument, set the `TransmitArrayMotionSource`

property
to `'Input port'`

.

**Data Types: **`double`

`txaxes`

— Axes orientation of transmitting antenna arrayreal-valued 3-by-3 real orthonormal matrix

Axes orientation of transmitting antenna array, specified as a real-valued 3-by-3 real
orthonormal matrix. The matrix defines the orientation of the array local
coordinate system with respect to the global coordinates. Matrix columns
correspond to the directions of the *x*,
*y*, and *z* axes of the local
coordinate system. Units are dimensionless.

**Example: **`rotx(35)`

To enable this argument, set the `TransmitArrayMotionSource`

property
to `'Input port'`

.

**Data Types: **`double`

`rxpos`

— Position of receiving antenna arrayreal-valued three-element column vector

Position of receiving antenna array, specified as a real-valued
three-element column vector taking the form `[x;y;z]`

.
The vector elements correspond to the *x*, *y*,
and *z* positions of the array. Units are in meters.

**Example: **`[1000;100;500]`

To enable this argument, set the `ReceiveArrayMotionSource`

property
to `'Input port'`

.

**Data Types: **`double`

`rxvel`

— Velocity of receiving antenna arrayreal-valued three-element column vector

Velocity of receiving antenna array, specified as a real-valued three-element column vector
taking the form `[vx;vy;vz]`

. The vector elements
correspond to the *x*, *y*, and
*z* velocities of the array. Units are in meters per
second.

**Example: **`[10;0;5]`

To enable this argument, set the `ReceiveArrayMotionSource`

property
to `'Input port'`

.

**Data Types: **`double`

`rxaxes`

— Axes orientation of receiving antenna arrayreal-valued 3-by-3 real orthonormal matrix

Axes orientation of receiving antenna array, specified as a real-valued 3-by-3 real
orthonormal matrix. The matrix defines the orientation of the array local
coordinate system with respect to the global coordinates. Matrix columns
correspond to the directions of the *x*,
*y*, and *z* axes of the local
coordinate system. Units are dimensionless.

**Example: **`rotx(35)`

To enable this argument, set the `ReceiveArrayMotionSource`

property
to `'Input port'`

.

**Data Types: **`double`

`scatpos`

— Positions of scatterersreal-valued 3-by-

Positions of scatterers, specified as a real-valued
3-by-*N _{s}* matrix. The matrix
contains the

`[x;y;z]`

. Units are in meters.**Example: **`[1000;100;500]`

To enable this argument, set the `ScattererSpecificationSource`

property
to `'Input port'`

.

**Data Types: **`double`

`scatvel`

— Velocities of scatterersreal-valued 3-by-

Velocities of scatterers, specified as a real-valued
3-by-*N _{s}* matrix. The matrix
contains the

`[vx;vy;vz]`

Units are in
meters per second.**Example: **`[1000;100;500]`

To enable this argument, set the `ScattererSpecificationSource`

property
to `'Input port'`

.

**Data Types: **`double`

`scatcoef`

— Scattering coefficientscomplex-valued 1-by-

Scattering coefficients, specified as a complex-valued
1-by-*N _{s}*row vector. Each vector
element specifies the scattering coefficient of the corresponding scatterer.
Units are dimensionless.

**Example: **`[5+3*1i;4+1i;2]`

To enable this argument, set the `ScattererSpecificationSource`

property to
`'Input port'`

and the
`Polarization`

property to
`'None'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`scatmat`

— Scattering matrices`[1 0;0 1]`

| complex–valued 2-by-2-by-Scattering matrices of the scatterers, specified as a complex–valued
2-by-2-by-*N*_{s} array where
*N*_{s} is the number of
scatterers. Each page of this array represents the scattering matrix of a
scatterer. Each scattering matrix has the form ```
[s_hh s_hv;s_vh
s_vv]
```

. For example, the component `s_hv`

specifies the complex scattering response when the input signal is
vertically polarized and the reflected signal is horizontally polarized. The
other components are defined similarly. Units are in square meters.

To enable this property, set the
`ScattererSpecificationSource`

property to
`'Input port'`

and the
`Polarization`

property to
`'Combined'`

or `'Dual'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`scataxes`

— Scatterer orientation axesreal-valued 3-by-3-by-

Scatterer orientation axes, specified as a real-valued
3-by-3-by-*N*_{s} array where
*N*_{s} is the number of
scatterers. Each page of this array represents the orientation axes matrix
of a scatterer. The columns of the matrix represent the
*x*- ,*y*-, and *z*-axes
of the scatterer. Units are dimensionless.

To enable this property, set the
`ScattererSpecificationSource`

property to
`'Input port'`

and the
`Polarization`

property to
`'Combined'`

or `'Dual'`

.

**Data Types: **`double`

`Y`

— Received narrowband signalcomplex-valued

Received narrowband signal, returned as an
*M*-by-N_{r} complex-valued matrix.
*M* is the number of samples in the signal, and
*N _{r}* is the number of
receiving array elements. Each column represents the signal received by the
corresponding array element.

**Example: **`[1,1;j,1;0.5,0]`

To enable this argument, set the `Polarization`

property to `'None'`

or
`'Combined'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`YH`

— Received narrowband H-polarization signalcomplex-valued

Received narrowband *H*-polarization signal, returned as
a complex-valued
*M*-by-*N _{r}*
matrix.

**Example: **`[1,1;j,1;0.5,0]`

To enable this argument, set the `Polarization`

property to `'Dual'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`YV`

— Received narrowband V-polarization signalcomplex-valued

Received narrowband *V*-polarization signal, returned as
a complex-valued
*M*-by-*N _{r}*
matrix.

**Example: **`[1,1;j,1;0.5,0]`

To enable this argument, set the `Polarization`

property to `'Dual'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`CR`

— Channel responsecomplex-valued

Channel response, returned as an
*N _{t}*-by-

*N*is the number of transmitting array elements._{t}*N*is the number of receiving array elements._{r}When you specify

`SimulateDirectPath`

as`false`

,*N*=_{c}*N*, the number of scatterers._{s}When you specify

`SimulateDirectPath`

as`true`

,*N*=_{c}*N*+ 1 to account for the direct path._{s}

Each page of the array corresponds to the channel response matrix for a specific scatterer.

To enable this argument, set the
`ChannelResponseOutputPort`

property to
`true`

and the `Polarization`

property to `'None'`

or
`'Combined'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`CR_HH`

— Channel response for H-input to H-outputcomplex-valued

Channel response from H-polarization input to H-polarization output
returned as a complex-valued
*N _{t}*-by-

*N*is the number of transmitting array elements._{t}*N*is the number of receiving array elements._{r}When you specify

`SimulateDirectPath`

as`false`

,*N*=_{c}*N*, the number of scatterers._{s}When you specify

`SimulateDirectPath`

as`true`

,*N*=_{c}*N*+ 1 to account for the direct path._{s}

Each page of the array corresponds to the channel response matrix for a specific scatterer.

To enable this argument, set the
`ChannelResponseOutputPort`

property to
`true`

and the `Polarization`

property to `'Dual'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`CR_HV`

— Channel response for H-input to V-outputcomplex-valued

Channel response from H-polarization input to V-polarization output
returned as a complex-valued
*N _{t}*-by-

*N*is the number of transmitting array elements._{t}*N*is the number of receiving array elements._{r}When you specify

`SimulateDirectPath`

as`false`

,*N*=_{c}*N*, the number of scatterers._{s}When you specify

`SimulateDirectPath`

as`true`

,*N*=_{c}*N*+ 1 to account for the direct path._{s}

Each page of the array corresponds to the channel response matrix for a specific scatterer.

To enable this argument, set the
`ChannelResponseOutputPort`

property to
`true`

and the `Polarization`

property to `'Dual'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`CR_VH`

— Channel response for V-input to H-outputcomplex-valued

Channel response from V-polarization input to H-polarization output
returned as a complex-valued
*N _{t}*-by-

*N*is the number of transmitting array elements._{t}*N*is the number of receiving array elements._{r}When you specify

`SimulateDirectPath`

as`false`

,*N*=_{c}*N*, the number of scatterers._{s}When you specify

`SimulateDirectPath`

as`true`

,*N*=_{c}*N*+ 1 to account for the direct path._{s}

Each page of the array corresponds to the channel response matrix for a specific scatterer.

To enable this argument, set the
`ChannelResponseOutputPort`

property to
`true`

and the `Polarization`

property to `'Dual'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`CR_VV`

— Channel response for V-input to V-outputcomplex-valued

Channel response from V-polarization input to V-polarization output
returned as a complex-valued
*N _{t}*-by-

*N*is the number of transmitting array elements._{t}*N*is the number of receiving array elements._{r}When you specify

`SimulateDirectPath`

as`false`

,*N*=_{c}*N*, the number of scatterers._{s}When you specify

`SimulateDirectPath`

as`true`

,*N*=_{c}*N*+ 1 to account for the direct path._{s}

Each page of the array corresponds to the channel response matrix for a specific scatterer.

`ChannelResponseOutputPort`

property to
`true`

and the `Polarization`

property to `'Dual'`

.

**Data Types: **`double`

**Complex Number Support: **Yes

`TAU`

— Path delays1-by-

Path delays, returned as a
1-by-*N _{C}* real-valued vector.
Each element corresponds to the path time delay from the transmitting array
phase center to a scatterer and then to the receiving array phase center.

When you specify

`SimulateDirectPath`

as`false`

,*N*=_{c}*N*, the number of scatterers._{s}When you specify

`SimulateDirectPath`

as`true`

,*N*=_{c}*N*+ 1 to account for the direct path._{s}

To enable this argument, set the
`ChannelResponseOutputPort`

property to
`true`

.

**Data Types: **`double`

Create a 30 GHz MIMO channel with random scatterers. The scenario contains a stationary 21-element transmitting ULA array and a stationary 15-element receiving ULA array. The transmitting antennas have cosine responses and the receiving antennas are isotropic. Element spacing for both arrays is less than one-half wavelength. The channel has 50 randomly generated static scatterers within a specified bounding box. The transmit array is located at [0;20;50] meters and the receive array is located at [200;10;10] meters. Compute the propagated signal through this channel. The sample rate for the signal is 10 MHz.

fc = 30e9; c = physconst('LightSpeed'); lambda = c/fc; fs = 10e6; txarray = phased.ULA('Element',phased.CosineAntennaElement,... 'NumElements',21,'ElementSpacing',0.45*lambda); rxarray = phased.ULA('Element',phased.IsotropicAntennaElement,... 'NumElements',15,'ElementSpacing',0.45*lambda); channel = phased.ScatteringMIMOChannel('TransmitArray',txarray,... 'ReceiveArray',rxarray,'PropagationSpeed',c,'CarrierFrequency',fc,... 'SampleRate',fs,'TransmitArrayPosition',[0;20;50],... 'ReceiveArrayPosition',[200;10;10],'NumScatterers',50,... 'ScattererPositionBoundary',[10 180; -30 30; -30 30]);

Create a random data signal of ones and zeros for each transmitter.

x = randi(2,[100 21]) - 1;

Compute the received signals after propagating through the channel.

y = channel(x);

Create a MIMO channel containing 3 fixed scatterers. The scenario contains a 21-element transmitting ULA array operating at 72 GHz, and a 15-element receiving ULA array. The transmitting elements have cosine response shapes and the receiving antennas are isotropic. Only the transmitting antenna is moving. Element spacing for both arrays is less than one-half wavelength. The transmitting array starts at (0,20,50) meters and moves towards the receiver at 2 m/s. The receiving array is located at (200,10,10) meters. Compute the propagated signal through this channel. The sample rate for the signal is 10 MHz.

fc = 72e9; c = physconst('LightSpeed'); lambda = c/fc; fs = 10e6; txplatform = phased.Platform('MotionModel','Velocity','InitialPosition', ... [0;20;50],'Velocity',[2;0;0]); txarray = phased.ULA('Element',phased.CosineAntennaElement, ... 'NumElements',21,'ElementSpacing',0.45*lambda); rxarray = phased.ULA('Element',phased.IsotropicAntennaElement, ... 'NumElements',15,'ElementSpacing',0.45*lambda); channel = phased.ScatteringMIMOChannel('TransmitArray',txarray, ... 'ReceiveArray',rxarray,'PropagationSpeed',c,'CarrierFrequency',fc,... 'SampleRate',fs,'TransmitArrayMotionSource','Input port', ... 'ReceiveArrayMotionSource','Property','ReceiveArrayPosition',[200;10;10],... 'ReceiveArrayOrientationAxes',rotz(180),... 'ScattererSpecificationSource','Property','ScattererPosition', ... [75 100 120; -10 20 12; 5 -5 8],'ScattererCoefficient',[1i,2+3i,-1+1i]);

Move the platforms for two time steps at one second intervals. For each time instance:

Create a random data signal of ones and zeros for each transmitter element.

Move the transmitter and receiver. The orientations are fixed.

Propagate the signals from transmitters to scatterers to receiver.

for k =1:2 x = randi(2,[100 21]) - 1; [txpos,txvel] = txplatform(1); txaxes = eye(3); y = channel(x,txpos,txvel,txaxes); end

Create a MIMO channel containing 3 fixed scatterers. The scenario contains a 21-element transmitting ULA array and a 15-element receiving ULA array. Both arrays operating at 72 GHz. The transmitting elements have cosine response shapes and the receiving antennas are isotropic. Only the receiving antenna is moving. Element spacing for both arrays is less than one-half wavelength. The transmitting array is located at (0,20,50) meters. The receiving array starts at (200,10,10) meters and moves toward the transmitter at 2 m/s. Compute the propagated signal through this channel. The sample rate for the signal is 10 MHz.

fc = 72e9; c = physconst('LightSpeed'); lambda = c/fc; fs = 10e6; rxplatform = phased.Platform('MotionModel','Velocity','InitialPosition',... [200;10;10],'Velocity',[-2;0;0]); txarray = phased.ULA('Element',phased.CosineAntennaElement, ... 'NumElements',21,'ElementSpacing',0.45*lambda); rxarray = phased.ULA('Element',phased.IsotropicAntennaElement, ... 'NumElements',15,'ElementSpacing',0.45*lambda); channel = phased.ScatteringMIMOChannel('TransmitArray',txarray, ... 'ReceiveArray',rxarray,'PropagationSpeed',c,'CarrierFrequency',fc, ... 'SampleRate',fs,'TransmitArrayMotionSource','Property',... 'TransmitArrayPosition',[0;20;50],'TransmitArrayOrientationAxes',eye(3,3), ... 'ReceiveArrayMotionSource','Input port','ScattererSpecificationSource', ... 'Property','ScattererPosition',[75 100 120; -10 20 12; 5 -5 8], ... 'ScattererCoefficient',[1i,2+3i,-1+1i],'SpecifyAtmosphere',false);

Move the platforms for two time steps at one-second intervals. For each time instance:

Create a random data signal of ones and zeros for each transmitter element.

Move the transmitter and receiver. Fix the array orientations.

Propagate the signals from transmitters to scatterers to receiver.

for k =1:2 x = randi(2,[100 21]) - 1; [rxpos,rxvel] = rxplatform(1); rxaxes = rotz(45); y = channel(x,rxpos,rxvel,rxaxes); end

Create a MIMO channel containing 3 moving scatterers. The scenario contains a 21-element transmitting ULA array and a 15-element receiving ULA array. Both arrays operate at 72 GHz. The transmitting elements have cosine responses and the receiving antennas are isotropic. Element spacing for both arrays is less than one-half wavelength. The transmitting array is located at (0,20,50) meters. The receiving array is located at (200,10,10) meters. Compute the propagated signal through this channel. The sample rate for the signal is 10 MHz. Obtain the channel response matrix and time delays.

fc = 30e9; c = physconst('LightSpeed'); lambda = c/fc; fs = 10e6; txarray = phased.ULA('Element',phased.CosineAntennaElement, ... 'NumElements',21,'ElementSpacing',0.45*lambda); rxarray = phased.ULA('Element',phased.IsotropicAntennaElement, ... 'NumElements',15,'ElementSpacing',0.45*lambda); channel = phased.ScatteringMIMOChannel('TransmitArray',txarray, ... 'ReceiveArray',rxarray,'PropagationSpeed',c,'CarrierFrequency',fc, ... 'SampleRate',fs,'TransmitArrayPosition',[0;20;50], ... 'ReceiveArrayPosition',[200;10;10],'ScattererSpecificationSource','Input port', ... 'ChannelResponseOutputPort',true);

Create a random data signal of ones and zeros for each transmitter.

x = randi(2,[100 21]) - 1;

Compute the received signals after propagating through the channel. Also return the channel matrix and delays.

scatpos = [75 100 120; -10 20 12; 5 -5 8]; scatvel = [0 0.5 0; -0.1 1.2 0.04; .05 -0.45 0.8]; scatcoef = [1i,2+3i,-1+1i]; [y,chmat,delays] = channel(x,scatpos,scatvel,scatcoef);

Display the dimensions of the channel matrix.

size(chmat)

`ans = `*1×3*
21 15 3

Display the time delays in microseconds.

delays*1e6

`ans = `*1×3*
0.7310 0.7196 0.6919

Create a MIMO channel at 30 GHz with an 16-element transmit array and a 64-element receive array. Assume the elements are short-dipole antennas and the arrays are uniform linear arrays. The transmit array is located at [0;0;50] meters.

The receive array has an initial position at [200;0;0] meters and is moving at a speed of [10;0;0] meters/second. There are 200 static scatterers randomly located on the *xy* plane within a square centered at [200;0;0] and with a side length of 100 meters.

Use the channel to compute the propagated polarized signal. Assume the sample rate for the signal is 10 MHz and the frame length is 1000 samples. Collect 5 frames of received signal.

fc = 30e9; c = 3e8; lambda = c/fc; fs = 10e6; txarray = phased.ULA('Element',phased.ShortDipoleAntennaElement,... 'NumElements',16,'ElementSpacing',lambda/2); rxarray = phased.ULA('Element',phased.ShortDipoleAntennaElement,... 'NumElements',64,'ElementSpacing',lambda/2); Ns = 200; scatpos = [100*rand(1,Ns) + 150; 100*rand(1,Ns) + 150; zeros(1,Ns)]; temp = randn(1,Ns) + 1i*randn(1,Ns); scatcoef = repmat(eye(2),1,1,Ns).*permute(temp,[1 3 2]); scatax = repmat(eye(3),1,1,Ns); Nframesamp = 1000; Tframe = Nframesamp/fs; rxmobile = phased.Platform('InitialPosition',[200;0;0],... 'Velocity',[10;0;0],'OrientationAxesOutputPort',true); chan = phased.ScatteringMIMOChannel(... 'TransmitArray',txarray,... 'ReceiveArray',rxarray,... 'PropagationSpeed',c,... 'CarrierFrequency',fc,... 'SampleRate',fs,... 'Polarization','Dual',... 'TransmitArrayPosition',[0;0;50],... 'ReceiveArrayMotionSource','Input port',... 'ScattererSpecificationSource','Property',... 'ScattererPosition',scatpos,... 'ScatteringMatrix',scatcoef,... 'ScattererOrientationAxes',scatax); xh = randi(2,[Nframesamp 16])-1; xv = randi(2,[Nframesamp 16])-1; for m = 1:5 [rxpos,rxvel,rxax] = rxmobile(Tframe); [yh,yv] = chan(xh,xv,rxpos,rxvel,rxax); end

A modified version of this example exists on your system. Do you want to open this version instead? (ko_KR)

아래 MATLAB 명령에 해당하는 링크를 클릭하셨습니다.

이 명령을 MATLAB 명령 창에 입력해 실행하십시오. 웹 브라우저에서는 MATLAB 명령을 지원하지 않습니다.

Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .

Select web siteYou can also select a web site from the following list:

Select the China site (in Chinese or English) for best site performance. Other MathWorks country sites are not optimized for visits from your location.

- América Latina (Español)
- Canada (English)
- United States (English)

- Belgium (English)
- Denmark (English)
- Deutschland (Deutsch)
- España (Español)
- Finland (English)
- France (Français)
- Ireland (English)
- Italia (Italiano)
- Luxembourg (English)

- Netherlands (English)
- Norway (English)
- Österreich (Deutsch)
- Portugal (English)
- Sweden (English)
- Switzerland
- United Kingdom (English)