@ankurm

Ankur in DSIP

Plotting sin and cos Function in MATLAB

In this post, we plot the discrete-time sine and cosine functions in MATLAB using the stem() function. Sine and cosine are the most fundamental periodic signals in signal processing. Visualising them in the discrete-time domain helps build intuition for sampling, frequency analysis, and filter design. MATLAB Code % Plotting Discrete-Time sin and cos in MATLAB % The user supplies n; the time axis runs from -n to +n. clc; % Clear the command window clear all; % Clear all workspace variables % --- Sine plot --- nSin = input('Enter n for sin plot : '); % e.g. 5 tSin = -nSin:1:nSin; % Time axis: -n, ..., 0, ..., +n ysin = sin(tSin); % Compute sin at each sample subplot(1, 2, 1); stem(tSin, ysin); title('sin(n)'); xlabel('n'); ylabel('Amplitude'); ylim([-1.5, 1.5]); % Fix y-axis for readability % --- Cosine plot --- nCos = input('Enter n for cos plot : '); % e.g. 5 tCos = -nCos:1:nCos; % Time axis: -n, ..., 0, ..., +n ycos = cos(tCos); % Compute cos at each sample subplot(1, 2, 2); stem(tCos, ycos); title('cos(n)'); xlabel('n'); ylabel('Amplitude'); ylim([-1.5, 1.5]); % Fix y-axis for readability

Ankur in DSIP

Plotting Unit Impulse, Unit Step, Unit Ramp and Exponential Function in MATLAB

In this post, we use MATLAB to plot four fundamental discrete-time signals: the Unit Impulse, Unit Step, Unit Ramp, and Exponential Function. These signals are the building blocks of digital signal processing (DSP) and control systems theory. Understanding how to generate and visualize them in MATLAB is the first step towards analyzing more complex systems. MATLAB Code % Plotting Unit Impulse, Unit Step, Unit Ramp and Exponential Function % All four signals are plotted in a 2x2 subplot grid. clc; % Clear the command window clear all; % Clear all workspace variables % --- 1. Unit Impulse (delta function) --- % Non-zero only at n=0; value = 1 at origin, 0 elsewhere t = -2:1:2; % Time axis: -2, -1, 0, 1, 2 impulse = [zeros(1,2), 1, zeros(1,2)]; % 1 only at center (t=0) subplot(2, 2, 1); stem(t, impulse); title('Unit Impulse'); xlabel('n'); ylabel('delta(n)'); % --- 2. Unit Step --- % Value = 1 for all n >= 0 nStep = input('Enter length for unit step : '); % e.g. 5 tStep = 0:1:nStep - 1; % Time axis: 0, 1, ..., nStep-1 stepSignal = ones(1, nStep); % All ones subplot(2, 2, 2); stem(tStep, stepSignal); title('Unit Step'); xlabel('n'); ylabel('u(n)'); % --- 3. Unit Ramp --- % Value increases linearly: r(n) = n for n >= 0 nRamp = input('Enter length for unit ramp : '); % e.g. 4 tRamp = 0:1:nRamp - 1; % Time axis: 0, 1, ..., nRamp-1 subplot(2, 2, 3); stem(tRamp, tRamp); % y = n (ramp equals the index) title('Unit Ramp'); xlabel('n'); ylabel('r(n) = n'); % --- 4. Exponential Function --- % y(n) = exp(a*n); decaying when a0 nExp = input('Enter length for exponential : '); % e.g. 5 tExp = 0:1:nExp - 1; % Time axis a = input('Enter exponent value (a) : '); % e.g. -0.5 or 2 expSignal = exp(a * tExp); subplot(2, 2, 4); stem(tExp, expSignal); title('Exponential Function'); xlabel('n'); ylabel('e^{an}');

Ankur in DSIP

Plotting Liner and Circular Convolution with MATLAB

In this post, we implement Linear Convolution and Circular Convolution in MATLAB and plot both results side by side. Convolution is a fundamental operation in signal processing used to find the output of a Linear Time-Invariant (LTI) system when an input signal is applied to it. Linear convolution computes the full convolution of two sequences, producing an output of length M + N - 1. Circular convolution (also called cyclic convolution) wraps around the result and is the basis of fast frequency-domain filtering using the DFT. MATLAB Code % Linear and Circular Convolution in MATLAB % Reads two sequences from the user, computes both convolutions, % displays the numerical results and plots all four signals. clc; % Clear the command window clear all; % Clear all workspace variables % --- Input --- x = input('Enter first sequence : '); % e.g. [1 1 2 2] y = input('Enter second sequence : '); % e.g. [1 2 3 4] % --- Linear Convolution --- % conv() returns a vector of length length(x)+length(y)-1 z = conv(x, y); disp('Linear convolution result:'); disp(z); % --- Circular Convolution --- % cconv(x, y) uses the length of the longer sequence by default c = cconv(x, y); disp('Circular convolution result:'); disp(c); % --- Plot all four signals --- figure; subplot(4, 1, 1); stem(x); title('First Input Sequence (x)'); xlabel('Sample Index'); ylabel('Amplitude'); subplot(4, 1, 2); stem(y); title('Second Input Sequence (y)'); xlabel('Sample Index'); ylabel('Amplitude'); subplot(4, 1, 3); stem(z); title('Linear Convolution (z = x * y)'); xlabel('Sample Index'); ylabel('Amplitude'); subplot(4, 1, 4); stem(c); title('Circular Convolution (c = x ⊛ y)'); xlabel('Sample Index'); ylabel('Amplitude');

Ankur in Snippets

Implementation of Bottom-Up (Shift-Reduce) Parsing in C++

Bottom-up parsing is a strategy used by compilers to analyse source code by building the parse tree from the leaves (terminal symbols) up to the root (start symbol). The most common bottom-up technique is shift-reduce parsing, which uses a stack and a set of production rules. At each step the parser either shifts the next input symbol onto the stack, or reduces the top of the stack by replacing a substring that matches the right-hand side of a production rule with the corresponding left-hand side symbol. This C++ program implements a simple shift-reduce parser. It reads a set of production rules and an input string from the user, then processes the string step by step, displaying the stack contents, remaining input, and the action taken (Shifted or Reduced) at every stage.

Ankur in Snippets

Implementing Lexical Analyser in C++

Lexical analysis (also called scanning or tokenisation) is the very first phase of a compiler. The lexical analyser reads the raw source text character by character and groups characters into meaningful units called tokens. Each token belongs to a category: an identifier (variable or function name), a literal (numeric constant), or a terminal (operator or punctuation symbol found in a predefined database file). This C++ program reads an expression string (terminated by $) from the user, classifies each character, and builds a Uniform Symbol Table (UST) that records every token together with its type (LIT, IDN, or TER) and a pointer (sequential index within its type). The results are written to four files and then displayed on the console. Required file: Before running the program you must create D:andb.txt containing all operator/punctuation characters that should be recognised as terminals (e.g. =+-*/()/), one or more per line.

Ankur in Snippets

Implementing Code Generator in C++

Code generation is the final back-end phase of a compiler. It takes the intermediate representation (IR) of the program — typically a sequence of three-address instructions — and translates each one into the equivalent target machine instructions. For a register-based architecture like the 8086, this means emitting MOV, ADD, SUB, MUL, DIV, and assignment instructions that use the AX and BX registers. This C++ program reads three-address IR instructions from an input file (AIP.TXT), generates the corresponding 8086-style assembly code, and writes it to an output file (ANOP.TXT). Each IR instruction has the form: operator operand1 operand2 result

Ankur in Snippets

Implementing Absolute Loader in C++

A loader is a system program responsible for placing a program into memory so it can be executed. An absolute loader is the simplest type: it loads a program at a fixed, pre-determined memory address (the starting address is embedded in the object file itself and cannot be changed). This contrasts with a relocating loader, which can place the program anywhere in memory and patches all address-dependent instructions accordingly. This C++ program simulates an absolute loader. You provide a starting address and the values to be placed at consecutive bytes, and the program then lets you query what the value at any relocation address (offset from the starting address) would be — mimicking the act of loading and then reading back memory.

Ankur in Snippets

Implementing Macro Processor in C

A macro processor is a system program that expands macros in a source file before the code is assembled or compiled. A macro is a named block of assembly statements; every time its name appears in the program the processor substitutes the full block in place of the call. This eliminates repetition and makes large assembly programs easier to maintain. This C implementation reads an assembly program from MACIN.TXT, detects MACRO / MEND delimiters to populate a Macro Definition Table (MDT), and then expands every macro call by inline-substituting the stored body. The expanded output is written to MACOUT.TXT and the raw MDT is saved to MDT.TXT.

Ankur in Snippets

Implementing Multi-pass Assembler in C

An assembler is a system software tool that translates an assembly language program (ALP) into machine code. A multi-pass assembler does this translation in two distinct passes over the source program. In Pass 1, it scans the ALP to build a Symbol Table (ST) that maps all labels and symbols to their memory addresses. In Pass 2, it uses the symbol table along with a Machine Opcode Table (MOT) and a Pseudo Opcode Table (POT) to generate the final object code. This C implementation reads the assembly program from alp.txt, the machine opcode table from mot.txt, and the pseudo opcode table from pot.txt. The generated object code is written to OUTPUTNEW.txt and the symbol table is saved to SymT.txt.

Ankur in 8086

8086 Assembly Program to Find Largest Number from Given Numbers

In this blog post, we'll delve into the world of assembly language programming using the 8086 microprocessors. We'll explore a practical example: creating an assembly program to determine the largest number from a given set of values.