Algorithmic Trading Explained

Algorithmic Trading

• Algorithmic trading employs computer programs that follow a defined set of instructions, or algorithms, to place trades.
• Algorithms are based on timing, price, quantity, or a mathematical model.
• Algorithmic trading increases market liquidity.
• Algorithmic trading introduces systematic processes by minimizing the impact of human emotion on trading activities.

How Algorithmic Trading Systems Work:

• A trader creates an algorithm by inputting trading instructions into a computer based on parameters like timing, price, quantity, or mathematical models.
• The algorithm undergoes backtesting using historical data to assess its viability.
• Successful algorithms are deployed for live trading.
• The computer program then monitors instrument prices and automatically executes trades according to defined conditions.

Algorithmic Trading Strategies:

• Trend-following algorithms capitalize on market trends using moving averages and support/resistance levels to generate buy/sell signals.
• Arbitrage exploits price differences in different markets by simultaneously buying and selling an asset using real-time monitoring.
• Index fund rebalancing automates adjustments to asset weightings in a fund to match its benchmark index.
• Mathematical model-based strategies employ statistical analysis and econometrics to identify trading opportunities.

Algorithmic Trading: Pros

• Executes trades at optimal prices.
• Reduces transaction costs.
• Facilitates simultaneous and automated order checks.
• Minimizes risk of manual trading errors.
• Enables backtesting to evaluate trading strategies.
• Reduces emotion-based decisions in trading.

Algorithmic Trading: Cons

• Susceptible to system failures.
• Can be affected by technological issues.
• Requires continuous monitoring.
• Dependent on effective algorithm design.
• May lead to unexpected trade outcomes.

Modeling the Dynamics of a Driven Robot

• This lab focuses on modeling the dynamics of a simple robot and simulating its behavior in MATLAB.
• It involves linearizing a dynamic model around an operating point.

Introduction

• Understanding robot dynamics is vital for designing controllers that can accurately manage its motion.

Robot Model

• Considers a robot with two independently driven wheels, possessing two degrees of freedom: position (x, y) and orientation (θ).
• Variables:
  • r: Wheel radius
  • L: Distance between wheels
  • m: Robot mass
  • I: Moment of inertia
• Configuration is described by $q = [x, y, \theta]^T$.
• $v_R$ and $v_L$ represent the linear velocities of the right and left wheels.

Kinematic Equations

• Define the robot's motion:
  • $\dot{x} = \frac{v_R + v_L}{2} \cos(\theta)$
  • $\dot{y} = \frac{v_R + v_L}{2} \sin(\theta)$
  • $\dot{\theta} = \frac{v_R - v_L}{L}$
• These relate wheel velocities to the robot’s linear and angular velocities.

Equations of Motion

• Consider forces and torques acting on the robot.
• $F_R$ and $F_L$ represent forces applied to the right and left wheels, respectively.
  • $m\ddot{x} = (F_R + F_L) \cos(\theta)$
  • $m\ddot{y} = (F_R + F_L) \sin(\theta)$
  • $I\ddot{\theta} = (F_R - F_L) \frac{L}{2}$
• Relates forces on the wheels to the robot's accelerations.

Linearization

• Simplifies controller design by linearizing the model around a desired operating point ($x_0, y_0, \theta_0$).
• Uses Taylor series expansion, keeping only first-order terms.
• Let $\delta x = x - x_0$, $\delta y = y - y_0$, and $\delta \theta = \theta - \theta_0$:
  • $m\delta\ddot{x} = (F_R + F_L) \cos(\theta_0) - (F_R + F_L) \sin(\theta_0) \delta\theta$
  • $m\delta\ddot{y} = (F_R + F_L) \sin(\theta_0) + (F_R + F_L) \cos(\theta_0) \delta\theta$
  • $I\delta\ddot{\theta} = (F_R - F_L) \frac{L}{2}$

Homework

• Tasks include system modeling and simulation of robot.
• Implement simple controller.
• Report includes description of models, simulation script, plots, analysis, and controller evaluation.

Heat Capacity

• Heat capacity ($C$) measures the heat required to change a substance's temperature by 1°C.
• SI unit: J/K.
• It can also be measured in J/°C, cal/°C, BTU/°F.
• Heat capacity is an extensive property.

Constant Pressure

$- C_p = (\frac{\partial H}{\partial T})_p$ - $C_p$ is heat capacity at constant pressure - $H$ is enthalpy - $T$ is temperature - $p$ is pressure

Constant Volume

$- C_v = (\frac{\partial U}{\partial T})_v$ - $C_v$ is heat capacity at constant volume - $U$ is internal energy - $T$ is temperature - $v$ is volume

Molar Heat Capacity

• Molar heat capacity ($C_m$) measures the heat to raise one mole of a substance by one degree Celsius.
• Units: J/(mol⋅K) or J/(mol⋅°C).
• $C_m = \frac{C}{n}$, where:
  • $C_m$ is molar heat capacity
  • $C$ is heat capacity
  • $n$ is number of moles

Specific Heat Capacity

• Specific heat capacity ($c$ or $s$) measures the heat raise one gram of a substance by one degree Celsius.
• Units: J/(g⋅K), J/(g⋅°C), cal/(g⋅°C), BTU/(lb⋅°F).
• Formula: $c = \frac{C}{m}$, where:
  • $c$ is specific heat capacity
  • $C$ is heat capacity
  • $m$ is mass
• Water's specific heat capacity is 4.184 J/(g⋅°C).

Typing: Static vs. Dynamic

Static Typing

• Types are checked during compilation.
• Examples include C++, Java, C#, Scala, Go, Rust, and Fortran.
• Static typing helps catch errors early and allows for more efficient code.
• Static typing often requires explicit type annotations.
• Example C++ add function which expects to integers for arguments.

int add(int x, int y) {
    return x + y;
}

int main() {
    int a = 10;
    int b = 20;
    int sum = add(a, b);
    std::cout << "Sum: " << sum << std::endl;
    return 0;
}

Dynamic Typing

• Types are checked during runtime.
• Examples include Python, JavaScript, and Ruby.
• Dynamic typing is typically more flexible and might reduce the amount of boilerplate code required.
• Can cause runtime errors if the types are not what is expected.
• Example Python add function which can expect different datatypes, flexibility.

def add(x, y):
    return x + y

a = 10
b = 20
sum = add(a, b)
print(f"Sum: {sum}")

Algorithmic Complexity

• Algorithmic complexity measures the time (time complexity) and space (space complexity) an algorithm requires relative to input size ($n$).
• Helps to objectively compare different algorithms.
• Instead of precise time and space measurements, it uses asymptotic notation to describe resource usage as input scales.

Asymptotic Notation

• Big O Notation ($O(f(n))$): Represents the upper bound, or worst-case scenario, for resource usage.
• Omega Notation ($\Omega(f(n))$): Represents the lower bound, or best-case scenario, for resource usage.
• Theta Notation ($\Theta(f(n))$): Represents the tight bound, representing both the upper and lower bounds for average-case scenarios.

Common Complexities

• $O(1)$: Constant time. Performance is consistent, regardless of input size.
• $O(log n)$: Logarithmic time. Time increases logarithmically with input size, as in binary search.
• $O(n)$: Linear time. Time increases linearly with input size, such as in linear search.
• $O(n log n)$: Time increases linearly and logarithmically, common in merge sort.
• $O(n^2)$: Quadratic time. Time increases quadratically, such as in bubble sort.
• $O(2^n)$: Exponential time. Time increases exponentially, like the traveling salesman problem.
• $O(n!)$: Factorial time. Time increases factorially, like brute-force TSP solutions.

How to Determine Complexity?

1. Identify Input size.
2. Count Operations.
3. Express as a function of n.
4. Simplify by dropping constants and lower-order terms.
5. Express in Asymptotic Notation.

Tips

• Focus on dominant operations.
• Ignore constant factors.
• Consider the worst-case scenario.

Channel Capacity

Definition

Channel capacity is the maximum rate at which information can be reliably transmitted over a communication channel, given noise.

Discrete Memoryless Channel (DMC)

• The channel is discrete when both input and output alphabets are discrete.
• Channel is memoryless when the output at time $i$ depends only on the input at time $i$ and is conditionally independent of the previous inputs or outputs.
• DMCs are defined by transition probabilities $P(y|x)$.
  • $P(Y=y|X=x)=P(y|x)$

Channel Capacity Formula

• The information channel capacity is expressed as $C = max_{p(x)} I(X;Y)$, where $I(X;Y)$ is the mutual information between input and output.
• Since $I(X;Y) = H(Y) - H(Y|X)$, the channel capacity can be calculated as $C = max_{p(x)} [H(Y) - H(Y|X)]$, where $H(Y|X)$ represents information loss.

Examples of Channel Capacity

• Find channel capacity of various channels.
• Noiseless Binary Chanel: $C=1$ bit.
• Noisy Channel With Nonoverlapping Outputs: $C=1$ bit.
• Binary Symmetric Channel (BSC) − $C = 1 - H(p)$
• Binary Erasure Channel (BEC) $C = 1 - \alpha$

Radiative Heat Transfer

Heat Transfer Occurs Due To

• Temperature difference
• Phase change
• Electromagnetic Radiation (EM)

Electromagnetic Spectrum

• Thermal radiation is emitted by matter as a result of its temperature for T > 0 K.
• Radiation is a volumetric phenomenon.

Blackbody Radiation

• Idealized physical body absorbing all incident electromagnetic radiation.
• Blackbody in thermal equilibrium emits electromagnetic radiation.
• Blackbody Emission
• $E_b = \sigma T^4$, where:
• $E_b \equiv$ blackbody emissive power $[W/m^2]$
• $\sigma = 5.67 * 10^{-8} [W/m^2K^4]$ Stefan Boltzmann constant

Real Surface Emission

• $E = \epsilon \sigma T^4$
• $\epsilon \equiv$ emissivity, $0 \le \epsilon \le 1$

Photosynthesis

Photosynthesis Nourishes Life on Earth

• Autotrophs (producers) sustain themselves without consuming other organisms.
• Photosynthesis: uses light to synthesize organic molecules.
• Heterotrophs (consumers) obtain organic material from other organisms.

Chloroplasts: Sites of Photosynthesis

• Chloroplasts are organelles where photosynthesis occurs.
• Stroma is the fluid-filled space