Skip to main content
All Snippets Java JUnit Hibernate Spring 8086
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');

2 min read 💬 1
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.

1 min read 💬 2
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.

1 min read
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

1 min read
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.

1 min read 💬 1
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.

1 min read 💬 4
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.

1 min read 💬 2
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.

1 min read 💬 4
Ankur in Mix (C++ and Assembly)

Mix (C++ and Assembly) Program to Sort Numbers in Ascending Order

This post demonstrates how to sort an array of integers using inline assembly in C++. Here, we perform sorting in ascending order by comparing and swapping adjacent elements using embedded assembly within a C++ program. #include<iostream.h> #include<conio.h> void main() { int a[5], x, y; int i, j; cout << "\n Enter 5 Numbers:"; for(i = 0; i < 5; i++) { cin >> a[i]; } //Sorting for(i = 0; i < 4; i++) { for(j = 0; j < 4; j++) { x = a[j]; y = a[j + 1]; _asm { mov ax, x mov bx, y cmp ax, bx jl nxt mov cx, ax mov ax, bx mov bx, cx mov x, ax mov y, bx } nxt: a[j] = x; a[j + 1] = y; } } cout << "\n Sorted Array:"; for(i = 0; i < 5; i++) cout << a[i] << " "; getch(); }

1 min read