The link object is used to represent the physical connection (i.e., propagation) between one device object and another.

Propagation from one device to another is modeled by two components, as evidenced by common MIMO formulations:

1. a channel matrix $\mathbf{H}$
2. a large-scale gain $G$

The link object uses a channel object—more likely, one of its subclasses—to handle generation of the channel matrix $\mathbf{H}$.

The link object uses a path_loss object—again, one of its subclasses—to handle generation of the large-scale gain $G$.

In general, it may be the case that the channel and large-scale gain between two devices is not symmetric—or reciprocal—meaning that the link observered in one direction from the first device to the second is not necessarily the link observed from the second device to the first. This can be due to a variety of factors including separate arrays used for transmission and reception or separate bands for uplink and downlink, for example.

To capture this assymetry, the link object actually contains two links:

To define these two links, we must also introduce the nomenclature for the two devices connected by a link:

2. a “tail” device

The head of the link is a device with transmit capability—either a transmitter or a transceiver. The tail of the link is a device with receive capability—either a receiver or transceiver.

If both devices only had transmit capability or only had receive capability, a physical link may exist but would be immaterial. This motivates our “head” and “tail” conventions.

The forward link is defined as from the head to the tail and always has some practical meaning given the fact that the head can transmit and the tail can receive.

The reverse link is defined as from the tail to the head but only has a a practical meaning if both the head and the tail are transceivers.

Propagation between two devices is largely characterized by the carrier frequency of the signal propagating from one device to the other. In some cases, the link is “symmetric”—or “reciprocal”—where a signal going from one device to the other sees the same environment as if it had traveled in the reverse fashion. This is common for time-division duplex systems where transmission by two devices takes place on the same frequency resources (with sufficient stationarity) and thus experiences symmetric transmit and receive channels.

A link object can be created in the follow fashion

lnk = link.create(head,tail)


where head is a device object with transmit capability and tail is a device object with receive capability.

### Key Properties

A link object lnk contains the following important properties, among others.

The head and tail devices are captured by

lnk.head
lnk.tail


The channel object representing the channel model used on the forward link is

lnk.channel_forward


The channel object representing the channel model used on the reverse link is

lnk.channel_reverse


The actual channel matrices for the forward and reverse links, respectively, are stored in

lnk.channel_matrix_forward
lnk.channel_matrix_reverse


The path_loss object representing the path loss model used on the forward link is

lnk.path_loss_forward


The path_loss object representing the path loss model used on the reverse link is

lnk.path_loss_reverse


The large-scale gain on the forward link—which is a product of lnk.path_loss_forward—is

lnk.large_scale_gain_foward


and likewise the large-scale gain on the reverse link is

lnk.large_scale_gain_reverse


The distance of the link in meters—the separation of the head and tail devices—is critical to most path loss models and is stored in

lnk.distance


and is automatically calculated based on the locations of the head and tail devices.

### Symmetric Forward and Reverse Channels

Sometimes it is the case that the forward and reverse channels should be symmetric, meaning reverse channel matrix is equal to the Hermitian of the forward channel matrix.

To achieve this, simply use

lnk.set_channel_symmetric(true)


which will be reflected in the property

lnk.channel_symmetric


Note that this is only possible when the transmit and receive arrays at the head are equal in size and likewise at the tail (and the head and tail are both transceivers). This is often the case in practical transceivers since the same antennas are used for transmission and reception.

This will ensure that lnk.channel_matrix_forward is always the Hermitian of lnk.channel_matrix_reverse.

### Symmetric Forward and Reverse Path Loss

Sometimes it is the case that the forward and reverse path losses should be symmetric, meaning reverse path loss (and thus the reverse large-scale gain) is equal to that of the forward link.

To achieve this, simply use

lnk.set_path_loss_symmetric(true)


which will be reflected in the property

lnk.path_loss_symmetric


This will ensure that lnk.large_scale_gain_forward is always equal to lnk.large_scale_gain_reverse.

### Setting the Forward and Reverse Channel Models

To set the channel model used on the forward and reverse links of a link object lnk, use

lnk.set_channel(chan_fwd,chan_rev)


where chan_fwd and chan_rev are channel objects to use on the forward and reverse links, respectively. Note that chan_fwd and chan_rev can be different channel models if desired.

To set the forward and reverse links to use the same channel model—but not necessarily the same realizations—a simpler method is

lnk.set_channel(chan)


where chan is of course a channel object.

Note that, in all cases, the channel objects that are passed to the link are deep copied before using them, meaning the same chan, chan_fwd, and chan_rev can be used when setting multiple links if desired.

Also, note that the transmit and receive arrays of the head and tail devices are automatically used to set up the forward and reverse channel objects.

### Setting the Forward and Reverse Path Loss Models

To set the path loss model used on the forward and reverse links of a link object lnk, use

lnk.set_channel(path_fwd,path_rev)


where path_fwd and path_rev are path_loss objects to use on the forward and reverse links, respectively. Note that path_fwd and path_rev can be different path loss models if desired.

To set the forward and reverse links to use the same path loss model—but not necessarily the same realizations—a simpler method is

lnk.set_path_loss(path)


where path is of course a path_loss object.

Note that, in all cases, the path_loss objects that are passed to the link are deep copied before using them, meaning the same path, path_fwd, and path_rev can be used when setting multiple links if desired.

### Forward and Reverse SNR

A link object lnk also has properties

lnk.snr_forward
lnk.snr_reverse


which are “large-scale” signal-to-noise ratios (SNRs) defined as

where $P_{\mathrm{tx,head}}$ and $P_{\mathrm{tx,tail}}$ are the transmit energy per symbol at the head and tail devices, respectively; $G_{\mathrm{fwd}}$ and $G_{\mathrm{rev}}$ are the forward and reverse large-scale gains, respectively; and $\sigma_{\mathrm{n,head}}^2$ and $\sigma_{\mathrm{n,tail}}^2$ are the noise energy per symbol at the receiver of the head and tail devices, respectively.

Note that the reverse link SNR is only applicable when the head and tail devices are both transceivers.

### Setting the Forward and Reverse SNR

It is common in MIMO research to evaluate performance for various large-scale SNR values.

Rather than force the user to find a triplet of transmit power, distance/path loss, and noise power to achieve a desired SNR, the user can force the SNR on a link to be a desired value using

lnk.set_snr(snr_fwd,snr_rev,unit)


where snr_fwd and snr_rev are large-scale SNR values and unit is an optional string to specify the units of snr_fwd and snr_rev. If snr_rev = [], then snr_fwd will be set on the forward and reverse links.

For example, to set the large-scale SNR to 10 dB on the forward and reverse links, one would use

lnk.set_snr(10,[],'dB')


The set_snr function adjusts the large-scale gain $G$ to be achieve a desired $\mathrm{SNR}$ based on the transmit energy per symbol and noise energy per symbol. Thus, to use this method, it is essential that the transmit energy per symbol and noise energy per symbol be set as desired and that the path loss not overwrite the newly set large-scale gain.

### List of Properties

The link object contains the following properties:

• link.name
• link.head
• link.tail
• link.channel_symmetric
• link.channel_forward
• link.channel_reverse
• link.channel_matrix_forward
• link.channel_matrix_reverse
• link.large_scale_gain_forward
• link.large_scale_gain_reverse
• link.path_loss_forward
• link.path_loss_reverse
• link.path_loss_symmetric
• link.snr_forward
• link.snr_reverse
• link.distance
• link.line_style
• link.color

### List of Methods

The link object contains the following methods:

#### compute_channel_state_information()

Constrcuts a struct containing channel state information for the forward and reverse links.

Usage:
[csi_forward,csi_reverse] = compute_channel_state_information()
Return Values:
csi_forward — a struct containing CSI values for the forward link
csi_reverse — a struct containing CSI values for the reverse link

Back to methods

#### compute_channel_state_information_forward()

Constrcuts a struct containing channel state information for the forward link.

Usage:
csi = compute_channel_state_information_forward()
Return Values:
csi — a struct containing CSI values

Back to methods

#### compute_channel_state_information_reverse()

Constrcuts a struct containing channel state information for the reverse link.

Usage:
csi = compute_channel_state_information_reverse()
Return Values:
csi — a struct containing CSI values

Back to methods

#### compute_covariance_forward()

Computes the covariance of the received symbols at the tail device from the head device. Also returns the covariance of received noise.

Usage:
[Ry,Rn] = compute_covariance_forward()
Return Values:
Ry — the received desired symbols covariance
Rn — the received noise covariance

Back to methods

#### compute_covariance_reverse()

Computes the covariance of the received symbols at the head device from the tail device. Also returns the covariance of received noise.

Usage:
[Ry,Rn] = compute_covariance_reverse()
Return Values:
Ry — the received desired symbols covariance
Rn — the received noise covariance

Back to methods

Returns a struct of values used for a link budget, in log-scale (e.g., dB, dBm), of the forward link and reverse link.

Usage:
[budget_fwd, budget_rev] = GET_LINK_BUDGET()
Return Values:
budget_fwd — a struct containing link budget quantities in log-scale for the forward link
budget_rev — a struct containing link budget quantities in log-scale for the forward link

Back to methods

Returns a struct of values used for a link budget, in log-scale (e.g., dB, dBm), of the forward link.

Usage:
budget = GET_LINK_BUDGET_FORWARD()
Return Values:
budget — a struct containing link budget quantities in log-scale

Back to methods

Returns a struct of values used for a link budget, in log-scale (e.g., dB, dBm), of the reverse link.

Usage:
budget = compute_link_budget_reverse()
Return Values:
budget — a struct containing link budget quantities in log-scale

Back to methods

#### compute_received_signal()

Usage:
compute_received_signal()

Back to methods

#### compute_received_signal_forward()

Computes the received signal at the tail device from the head device.

Usage:
[z,y,n] = compute_received_signal_forward()
Return Values:
z — the desired signal plus noise
y — the desired signal vector
n — the noise vector

Back to methods

#### compute_received_signal_reverse()

Computes the received signal at the head device from the tail device.

Usage:
[z,y,n] = compute_received_signal_reverse()
Return Values:
z — the desired signal plus noise
y — the desired signal vector
n — the noise vector

Back to methods

#### configure_receiver(strategy)

Configures each device’s receiver according to the current/specified receive strategy, incorporating channel state information as applicable.

Usage:
configure_receiver()
configure_receiver(strategy)
Input Arguments:
strategy — (optional) receive strategy to use; if not passed, each device’s current receive strategy will be used

Back to methods

#### configure_transmitter(strategy)

Configures each device’s transmitter according to the current/specified transmit strategy, incorporating channel state information as applicable.

Usage:
configure_transmitter()
configure_transmitter(strategy)
Input Arguments:
strategy — (optional) transmit strategy to use; if not passed, each device’s current transmit strategy will be used

Back to methods

#### create(head,tail)

Creates a link between two devices: a head device (which has transmit capability) and a tail device (which has receive capability).

Usage:
obj = link.create(head,tail)
Input Arguments:
head — a device with transmit capability
tail — a device with receive capability
Return Values:
obj — a link object

Back to methods

#### initialize()

Executes intialization steps to set up a link.

Usage:
initialize()

Back to methods

#### isbidirectional()

Returns a boolean indicating if the link is bidirectional (i.e., if the head device has receive capability and the tail device has transmit capability).

Usage:
out = isbidirectional()
Return Values:
out — a boolean indicating if the link is bidirectional

Back to methods

Creates an instance of a link object.

Usage:
obj = link(head,tail)
Input Arguments:
head — a device object at the head of the link; device must be a transmitter or transceiver
tail — a device object at the tail of the link; device must be a receiver or transceiver
Return Values:
obj — a link object

Back to methods

#### realization()

Invokes a complete realization of the link.

Usage:
realization()
Notes:
Invokes realizations of the foward and reverse path loss and forward and reverse channels.

Back to methods

#### realization_channel()

Invokes a channel realization on the forward and reverse links.

Usage:
[H_fwd,H_rev] = realization_channel()
Return Values:
H_fwd — the forward channel matrix realization
H_rev — the reverse channel matrix realization

Back to methods

#### realization_channel_forward()

Invokes a realization of the forward channel and sets the forward channel matrix.

Usage:
H = realization_channel_forward()
Return Values:
H — a channel matrix for the forward channel

Back to methods

#### realization_channel_reverse()

Invokes a realization of the reverse channel and sets the reverse channel matrix. If the channel is set to symmetric, the reverse channel will be set to the conjugate transpose of the current forward channel matrix instead of invoking a realization of the reverse channel. Therefore, a forward channel realization should be invoked before a reverse channel realization if the channel is symmetric.

Usage:
H = realization_channel_reverse()
Return Values:
H — a channel matrix for the reverse channel

Back to methods

#### realization_path_loss()

Invokes a realization fo the forward and reverse path loss.

Usage:
[G_forward,G_reverse] = realization_path_loss()
Return Values:
G_forward — the resulting forward large-scale gain
G_reverse — the resulting reverse large-scale gain

Back to methods

#### realization_path_loss_forward()

Invokes a realization of the path loss model on the forward link.

Usage:
G = realization_path_loss_forward()
Return Values:
G — the large-scale gain following the forward path loss realization

Back to methods

#### realization_path_loss_reverse()

Invokes a realization of the path loss model on the reverse link. If the link is set to have symmetric path loss, the current forward path loss is used.

Usage:
G = realization_path_loss_reverse()
Return Values:
G — the large-scale gain following the reverse path loss realization

Back to methods

#### report_mutual_information_forward()

Reports the Gaussian mutual information achieved between the head and tail devices based on the current link realization and transmit-receive configurations. Returns the mutual information in bps/Hz. Discards any residual imaginary component.

Usage:
mi = report_mutual_information_forward()
Return Values:
mi — the mutual information in bps/Hz
Notes:
Will warn the user if a significant imaginary portion exists when computing the mutual information. Ultimately discards it though.

Back to methods

#### report_mutual_information_reverse()

Reports the Gaussian mutual information achieved between the tail and head devices based on the current link realization and transmit-receive configurations. Returns the mutual information in bps/Hz. Discards any residual imaginary component.

Usage:
mi = report_mutual_information_reverse()
Return Values:
mi — the mutual information in bps/Hz
Notes:
Will warn the user if a significant imaginary portion exists when computing the mutual information. Ultimately discards it though.

Back to methods

#### report_symbol_estimation_error_forward()

Returns the squared-error in the estimated receive symbol at the tail compared to the transmit symbol at the head.

Usage:
[mse,mse_dB] = report_symbol_estimation_error_forward()
Return Values:
err — the squared error of the received symbols versus the transmitted symbols
nerr — err normalized to the transmit symbol power

Back to methods

#### report_symbol_estimation_error_reverse()

Returns the squared-error in the estimated receive symbol at the head compared to the transmit symbol at the tail.

Usage:
[mse,mse_dB] = report_symbol_estimation_error_reverse()
Return Values:
err — the squared error of the received symbols versus the transmitted symbols
nerr — err normalized to the transmit symbol power

Back to methods

#### set_arrays(transmit_array,receive_array)

Sets the transmit and receive arrays at the head and tail devices.

Usage:
set_arrays(transmit_array,receive_array)
Input Arguments:
transmit_array — array object to use at the transmitter of the head and tail devices
receive_array — array object to use at the receiver of the head and tail devices

Back to methods

#### set_carrier_frequency(fc)

Sets the carrier frequency of the link. Also sets the carrier frequency of the head and tail devices.

Usage:
set_carrier_frequency(fc)
Input Arguments:
fc — carrier frequency (Hz)
Notes:

Back to methods

#### set_channel(channel_forward,channel_reverse)

Sets the channel used on the forward and reverse channels.

Usage:
set_channel(channel_forward)
set_channel(channel_forward,channel_reverse)
Input Arguments:
channel_forward — a channel object used on the forward link
channel_reverse — (optional) a channel object used on the reverse link; if not provided, the reverse channel will use the same channel object as the forward channel (i.e., channel_reverse = channel_forward)

Back to methods

#### set_channel_forward(channel)

Sets the channel used on the forward link.

Usage:
set_channel_forward(channel)
Input Arguments:
channel — a channel object

Back to methods

#### set_channel_matrices(H_forward,H_forward)

Sets the forward and reverse channel matrices.

Usage:
set_channel_matrices()
set_channel_matrices(H_forward)
set_channel_matrices(H_forward,H_reverse)
Input Arguments:
H_forward — (optional) forward channel matrix
H_forward — (optional) reverse channel matrix

Back to methods

#### set_channel_matrix_forward(H)

Sets the channel matrix of the forward link.

Usage:
set_channel_matrix_forward()
set_channel_matrix_forward(H)
Input Arguments:
H — (optional) a channel matrix; if not passed, the forward channel’s channel matrix will be used

Back to methods

#### set_channel_matrix_reverse(H)

Sets the channel matrix of the reverse link.

Usage:
set_channel_matrix_reverse()
set_channel_matrix_reverse(H)
Input Arguments:
H — (optional) a channel matrix; if not passed, the reverse channel’s channel matrix will be used (if not symmetric); else the forward channel’s channel matrix will be used

Back to methods

#### set_channel_reverse(channel)

Sets the channel used on the reverse link.

Usage:
set_channel_reverse(channel)
Input Arguments:
channel — a channel object

Back to methods

#### set_channel_symmetric(symmetric)

Sets the symmetry of the forward and reverse channels. Note that this is only possible if the transmit array and receive array at the head are equal in size and likewise at the tail.

Usage:
set_channel_symmetric(symmetric)
Input Arguments:
symmetric — a boolean indicating if the forward and reverse channels are symmetric; if so, then the reverse channel matrix is the conjugate-transpose of the the forward channel matrix

Back to methods

#### set_color(color)

Sets the color used when plotting the link.

Usage:
set_color(color)
Input Arguments:
color — an RGB triplet normalized to [0,1] or a MATLAB color code (e.g., ‘k’,’b’,’r’).

Back to methods

#### set_distance(d)

Sets the distance of the link (in meters).

Usage:
set_distance()
set_distance(d)
Input Arguments:
d — (optional) distance of the link (in meters); if not passed, the head and tail devices’ coordinates will be used to calculate the distance of the link

Back to methods

#### set_duplexing(duplex)

Sets the duplexing method at the head and tail devices.

Usage:
set_duplexing(duplex)
Input Arguments:
duplex — a string specifying the duplexing method to use

Back to methods

#### set_head(head)

Usage:
set_head(head)
Input Arguments:
head — a device of type ‘transmitter’ or ‘transceiver’

Back to methods

#### set_large_scale_gain(G_forward,G_reverse)

Sets the large-scale gain of the forward and reverse links to the same value.

Usage:
set_large_scale_gain(G_forward)
set_large_scale_gain(G_forward,G_reverse)
Input Arguments:
G_forward — large-scale gain of the forward link
G_reverse — (optional) large-scale gain of the reverse link; if not passed, G_forward will be used as G_reverse

Back to methods

#### set_large_scale_gain_forward(G)

Sets the large-scale gain of the forward link.

Usage:
set_large_scale_gain_forward(G)
Input Arguments:
G — large-scale amplitude gain (G^2 is power gain)

Back to methods

#### set_large_scale_gain_reverse(G)

Sets the large-scale gain of the reverse link.

Usage:
set_large_scale_gain_reverse(G)
Input Arguments:
G — large-scale amplitude gain (G^2 is power gain)

Back to methods

#### set_line_style(line_style,(dashed), ')

Sets the line style used when plotting the link.

Usage:
set_line_style(line_style)
Input Arguments:
line_style — a MATLAB line style; either ‘-‘ (solid), ‘–’
(dashed), ' — ‘ (dotted), or ‘-.’ (dash-dotted)

Back to methods

#### set_marker(marker_head,marker_tail)

Sets the marker used by the head and tail devices.

Usage:
set_marker(marker_head)
set_marker(marker_head,marker_tail)
Input Arguments:
marker_head — a marker to use at the head device
marker_tail — (optional) a marker to use at the tail device; if not passed, the marker specified for the head will be used

Back to methods

#### set_name(name)

Sets the name of the link.

Usage:
set_name()
set_name(name)
Input Arguments:
name — (optional) a string; if not passed, a name is created

Back to methods

#### set_noise_power_per_Hz(noise_psd,unit)

Sets the noise power per Hz at the receiver of the head and tail devices.

Usage:
set_noise_power_per_Hz(noise_psd)
set_noise_power_per_Hz(noise_psd,unit)
Input Arguments:
noise_psd — the noise power spectral density
unit — (optional) a string specifying the units of noise_psd (e.g., ‘dBm_Hz’ or ‘watts_Hz’); if not passed, the default will be used
Notes:

Back to methods

#### set_num_rf_chains(Lt,Lr)

Sets the number of transmit and receive RF chains at the head and tail devices.

Usage:
set_num_rf_chains(Lt,Lr)
Input Arguments:
Lt — number of transmit RF chains at the head and tail devices
Lr — number of receive RF chains at the head and tail devices

Back to methods

#### set_num_streams(num_streams)

Sets the number of streams at the head and tail devices.

Usage:
set_num_streams(num_streams)
Input Arguments:
num_streams — number of streams to multiplex at the transmitter and receiver of the head and tail devices

Back to methods

#### set_path_loss(path_loss_forward,path_loss_reverse)

Sets the path loss model used on the link.

Usage:
set_path_loss(path_loss_forward)
set_path_loss(path_loss_forward,path_loss_reverse)
Input Arguments:
path_loss_forward — a path loss object used on the forward link
path_loss_reverse — (optional) a path loss object used on the reverse link; if not provided, the reverse path loss will use the same path loss object as the forward one (i.e., path_loss_reverse = path_loss_forward)

Back to methods

#### set_path_loss_forward(path_loss)

Sets the path loss model used on the forward link.

Usage:
set_path_loss_forward(path_loss)
set_path_loss_forward(path_loss,copy)
Input Arguments:
path_loss — a path loss object

Back to methods

#### set_path_loss_reverse(path_loss)

Sets the path loss model used on the reverse link.

Usage:
set_path_loss_reverse(path_loss)
Input Arguments:
path_loss — a path loss object

Back to methods

#### set_path_loss_symmetric(symmetric)

Sets the symmetry of the forward and reverse path loss.

Usage:
set_path_loss_symmetric(symmetric)
Input Arguments:
symmetric — a boolean indicating if the forward and reverse path loss are symmetric; if so, then the reverse large-scale gain will always be equal to the forward large-scale gain

Back to methods

#### set_propagation_velocity(vel)

Sets the propagation velocity of the link. Also sets the propagation velocity of the head and tail devices.

Usage:
set_propagation_velocity(vel)
Input Arguments:
vel — propagation velocity (meters/sec)

Back to methods

#### set_receive_strategy(strategy)

Sets the receive strategy to use at the head and tail devices.

Usage:
set_receive_strategy(strategy)
Input Arguments:
strategy — a string specifying the receive strategy

Back to methods

#### set_snr(snr_forward,snr_reverse)

Sets the SNR of the forward and reverse links.

Usage:
set_snr()
set_snr(snr_forward,snr_reverse)
set_snr(snr_forward,snr_reverse,unit)
Input Arguments:
snr_forward — (optional) the large-scale SNR of the forward link
snr_reverse — (optional) the large-scale SNR of the reverse link; if not passed, the SNR of the forward link is used

Back to methods

#### set_snr_forward(snr,unit)

Sets the SNR of the forward link.

Usage:
set_snr_forward()
set_snr_forward(snr)
set_snr_forward(snr,unit)
Input Arguments:
snr — (optional) the large-scale SNR of the forward link; if passed, the large-scale gain of the forward link is adjusted accordingly; if not passed, the SNR is computed based on the current large-scale gain
unit — (optional) a string specifying the unit of snr

Back to methods

#### set_snr_reverse(snr,unit)

Sets the SNR of the reverse link.

Usage:
set_snr_reverse()
set_snr_reverse(snr)
set_snr_reverse(snr,unit)
Input Arguments:
snr — (optional) the large-scale SNR of the reverse link; if passed, the large-scale gain of the reverse link is adjusted accordingly; if not passed, the SNR is computed based on the current large-scale gain
unit — (optional) a string specifying the unit of snr

Back to methods

#### set_symbol_bandwidth(B)

Sets the symbol bandwidth at the head and tail devices.

Usage:
set_symbol_bandwidth(B)
Input Arguments:
B — the symbol bandwidth (in Hertz) at the transmitter and receiver of the head and tail devices
Notes:

Back to methods

#### set_tail(head)

Sets the tail device of the link.

Usage:
set_tail(tail)
Input Arguments:
head — a device of type ‘receiver’ or ‘transceiver’

Back to methods

#### set_transmit_power(P,unit)

Sets the transmit power at the transmitter of the head and tail devices.

Usage:
set_transmit_power(P)
set_transmit_power(P,unit)
Input Arguments:
P — transmit power (e.g., in watts or dBm)
unit — (optional) a string specifying the units of P (e.g., ‘dBm’); if not passed, the default is used.
Notes:

Back to methods

#### set_transmit_strategy(strategy)

Sets the transmit strategy to use at the head and tail devices.

Usage:
set_transmit_strategy(strategy)
Input Arguments:
strategy — a string specifying the transmit strategy

Back to methods

#### set_transmit_symbol(s)

Sets the transmit symbol at the head and tail devices.

Usage:
set_transmit_symbol(s)
Input Arguments:
s — transmit symbol vector

Back to methods

#### set_transmit_symbol_covariance(Rs)

Sets the transmit covariance of the device.

Usage:
set_transmit_symbol_covariance(Rs)
Input Arguments:
Rs — a covariance matrix

Back to methods

#### show_2d(fignum)

Usage:
show_2d()
show_2d(fignum)
Input Arguments:
fignum — (optional) a figure number; if not passed, a new figure will be created
Return Values:
fig — the resulting a figure handle

Back to methods

#### show_3d(fignum)

show_3d()
show_3d(fignum)
fignum — (optional) a figure number; if not passed, a new figure will be created
fig — the resulting a figure handle