CMS-A-DSE-A--4-P: Multimedia and its Applications Lab. DSE-A: Choice-4: Practical, Credit:02, Contact hour: 40.

 Sample practical problems can be included related to theory.

CMS-A-DSE-A--4-TH: Multimedia and its Applications DSE-A: Choice-4, Theory, Credit:04, Contact hours: 60.

 Multimedia

Introduction to multimedia, Components, uses of multimedia.

04 hours

Making Multimedia

Stages of a multimedia project, requirements to make good multimedia, Multimedia

Hardware - Macintosh and Windows production Platforms, Hardware peripherals -

Connections, Memory and storage devices, Multimedia software and Authoring tools.

06 hours

Text

Fonts & Faces, Using Text in Multimedia, Font Editing & Design Tools, Hypermedia

& Hypertext.

04 hours

Images

Still Images – Bitmaps, Vector Drawing, 3D Drawing & rendering, Natural Light &

Colors, Computerized Colors, Color Palettes, Image File Formats.

06 hours

Sound

Digital Audio, MIDI Audio, MIDI vs Digital Audio, Audio File Formats.

06 hours

Video

How Video Works, Analog Video, Digital Video, Video File Formats, Video Shooting

and Editing.

06 hours

Animation

Principle of Animations. Animation Techniques, Animation File Formats.

08 hours

Multimedia System

An overview of multimedia system and media streams, Source representation and

compression techniques text, speech and audio, still image and video, Graphics and

animation.

10 hours

Multi-modal Communication

Video conferencing, networking support, Trans-coding.

CMS-A-DSE-A--3-P: Embedded Systems Lab. DSE-A: Choice-3, Practical, Credit: 02, Contact hours: 40 hours

 CMS-A-DSE-A--3-P: Embedded Systems Lab.

DSE-A: Choice-3, Practical, Credit: 02, Contact hours: 40 hours

Practical: Sample practical problems can be included related to theory.

1. Assembly Language Programming related to Microcontroller 8051.

2. Programming Using Embedded C for 8051.

3. VHDL programs for construction and simulation of various digital circuits.

CMS-A-DSE-A--3-TH: Embedded Systems DSE-A: Choice-3: Theory, Credit:04, Contact hours: 60.

 Introduction to 8051

Overview of Microcontroller, Memory, I/O interface

Intel Microcontroller 8051: Architecture, Peripheral Interface Controller (PIC).

15 hours

Assembly Language Programming

Instruction set, Addressing Modes, Jump, Loop and Call instructions, I/O Manipulation,

Serial communication, Arithmetic and logical instructions.

10 hours

Introduction to Embedded System Programming

Data types and time delays, I/O programming, Logic operations, Data conversions, Data

serialization, Interrupt programming, LCD and Keyboard interfacing, ADC, DAC,

sensors interfacing, interfacing 8255, I/O interfacing for 8051, interfacing 8255, 8257,

8259/ 8279, ADC, DAC, Motor control using 8051 C.

15 hours

Programmable logic devices and Hardware description Language

PAL, PLA, PLD, ASIC, FPGA (Qualitative study).

10 hours

Hardware Description Language (VHDL):

Basic Terminology, Entity Declaration, Architecture body, Configuration and package

declaration, Package body, Model analysis and Simulation.

Basic Language elements, Behavioral Model, Dataflow Model, Structural Model,

Subprogram and overloading, Applications.

CMS-A-CC-6-14-P: ProjectWork Core Course-14, Practical, Credit:04, Contact hours: 60.

 

Candidates have to do their project in any relevant topic, under the supervision

of teachers.

CMS-A-CC-6-14-TH: Theory of Computation. Core Course-14: Theory, Credit:04, Contact hours: 60.

 Finite Automata

Definition of a Finite Automaton, Model, Representation, Classification – with respect to

output function Mealy and Moore Machines, with respect to State Transition –

Deterministic and Non-Deterministic Machine, Examples, conversion algorithms Mealy

to Moore and Moore to Mealy, Finite and Infinite state machines, Finite Automaton,

Deterministic and Non-Deterministic Finite automaton, Non-Deterministic to equivalent

Deterministic Automaton-Optimized and Non-optimized technique ideas and algorithms,

Acceptability of String by a Finite Automaton.

15 hours

Formal Languages and Grammar

Introduction to Formal Grammar and Language, Chomsky’s Classification of Grammar –

Type-0, Type-1 or Context Sensitive, Type-2 or Context Free and Type-3 or Regular

Grammar, Illustration of each of these classes with example, Sentential form, Sentences –

Languages or strings, Derivations, Ambiguous Grammar and Language, Designing of

Grammar for a language, Find the Language for given Grammar, Definition and basic

idea about Push Down Automaton.

15 hours

Regular Expression:

Basic Idea and Definition, Regular Expression basic Identities, Arden’s Theorem –

Statement (without Proof) and application for reduction of equivalent regular expressions,

Regular expression to Finite Automata conversion, State Transition System to Regular

Expression conversion algorithm by Arden’s Algebraic Method, FA to Regular Grammar

and Regular Grammar to FA conversion algorithms and applications.

15 hours

Turing Machine

Concepts of Turing Machine, Formal Definitions, Classifications – Deterministic and

Non-Deterministic Turing Machines, Simple Design of Turing Machines: Odd / even

count and concepts of Universal Turing Machines, Difference and Similarities between

Turing Machine and a General Purpose Computer, Definition and significant of Halting

Problem in Turing Machine.

CMS-A-CC-6-13-TH: Software Engineering. Core Course-13: Theory, Credit:04, Contact hours 60.

 Introduction

Defining system, open and closed system, modeling of system through computer

hardware, communication systems, external agents and software systems; Importance of

Engineering Methodology towards computerization of a system.

03 hours

Software Life Cycle

Classical and Iterative Waterfall Model; Spiral Model; Prototype Model; Evolutionary

model and its importance towards application for different system representations,

Comparative Studies.

07 hours

Software Requirement and Specification Analysis

Requirements Principles and its analysis principles; Specification Principles and its

representations

Software Design Analysis – Different level of DFD Design, Physical and Logical DFD,

Use and Conversions between them, Decision Tables and Trees, Structured analysis,

Coupling and Cohesion of different modules

Software Cost Estimation Modeling –COCOMO.

23 hours

Software Testing

Software Verification and Validation; Testing objectives, Testing Principles, Testability;

Error and Faults; Unit Testing, White Box and Blank Box Testing, Test Case Design:

Test Vector, Test Stub.

17 hours

Software Quality Assurances

Concepts of Quality, Quality Control, Quality Assurance, IEEE Standard for Statistical

Software Quality Assurances (SSQA) criterions.

CMS-A-DSE-B--2-P: Python 3 Programming Lab. DSE-B: Choice-2, Practical, Credit: 02, Contact hours: 40 hours.

 Use Python 3.6 or above. Use a text editor sensitive to whitespace like Notepad++, gedit, vim,

Sublime Text, and NOT Notepad / WordPad. The following exercises are suggestive in nature.

1. The Interpreter as a calculator. Basic arithmetic operations. Introduction to the simple

numeric data types – integers, floating point numbers, Boolean, complex numbers.

Inter conversion of data types.

a. Use the Python prompt as a basic calculator. Explore the order of operations

using parentheses.

b. Explore the various functions in the math module. Eg: find GCD of two

numbers, area and perimeter of circle using math.pi, etc.

c. Exploring the complex data type and their operations, eg: finding the modulus

and phase angle of a complex number.

d. The print function – Printing values. Repeat the previous experiments now

using the print function

2. Basic user interactions using the print() and input() functions.

a. Write a simple python script using the print function in a text editor, save it

with the extension “.py”. Run it in the terminal / command prompt.

b. Take input two strings from the user, and print the first one twice, and the

other one thrice.

c. Ask the user to enter two numbers, and output the sum, product, difference,

and the GCD.

d. More programs that test concepts learned in week 1 which involves the usage

of the print and input functions.

3. Strings, List, Tuples, the re (regular expression) module

a. Ask the user for two strings, print a new string where the first string is

reversed, and the second string is converted to upper case. Sample strings:

“Pets“, “party”, output: “steP PARTY”. Only use string slicing and +

operators.

b. From a list of words, join all the words in the odd and even indices to form

two strings. Use list slicing and join methods.

c. Simulate a stack and a queue using lists. Note that the queue deletion

operation won’t run in O(1) time.

d. Explore the ‘re’ module, especially re.split, re.join, re.search and re.match

methods.

4. Conditionals, looping constructs, and generators

a. Use list comprehension to find all the odd numbers and numbers divisible by

3 from a list of numbers.

b. Using while loops to do Gaussian addition on a list having an even number of

numbers. Print each partial sum. Eg: if the list is [1, 2, 3, 4, 5, 6], the program

should output “1 + 6”, “2 + 5”, and “3+4” in separate lines, and the result of

the addition “21”. Extend it to handle lists of odd length.

c. Primarily testing using for and while loops.

d. Use (c) to generate a list of primes within a user-given range.

e. Explore the ‘key’ function of sum( ), min( ), max( ), and sort( ) functions

using lambdas.

5. User defined functions

a. Implement popular sorting algorithms like quick sort and merge sort to sort

lists of numbers.

b. Implement the Pascal’s triangle.

c. Three positive integers a, b, and c are Pythagorean triples if a2+ b2 =c2. Write

a function to generate all Pythagorean triples in a certain range.

d. Write two functions that simulate the toss of a fair coin, and the roll of an

unbiased ‘n’ sided die using the random module.

e. Like (d), but now the coin and the die are not fair, with each outcome having

a given probability.

6. File handling, sys, pickle and csv modules

a. Basic file operations. Explore the different file modes.

b. Emulate the unix ‘cp’, ‘grep’, ‘cat’ programs in Python. In each case, the user

should pass the arguments to the program as command line arguments.

c. Use pickle for persistent storage of variables

7. Sets and dictionaries

a. Use sets to de-duplicate a list of numbers, and a string such that they contain

only the unique elements

b. Use the set union and intersection operations to implement the Jaccard and

Cosine similarity of two sets.

c. Use dictionaries to count the word and letter occurrences in a long string of

text.

d. Invert a dictionary such the previous keys become values and values keys.

Eg: if the initial and inverted dictionaries are d1 and d2, where d1 = {1: ‘a’, 2:

‘b’, 3: 120}, then d2 = {‘a’: 1, 2: ‘b’, 120: 3}.

e. What if the values in (d) are not immutable? Use frozensets. For repeated

values, use lists. Eg: if d1 = {1: ‘a’, 2: ‘a’, 4: [1, 2]}, then d2 = {‘a’: [1, 2],

frozenset([1, 2]): 4}.

f. Write a function to generate the Fibonacci numbers in (a) exponential time

using the naïve algorithm, and (b) in linear time using dynamic programming

(memorization) with a dictionary.

8. Object Oriented Programming

a. Create a ‘Graph’ class to store and manipulate graphs. It should have the

following functions:

i. Read an edge list file, where each edge (u, v) appears exactly once in

the file as space separated values.

ii. Add and remove nodes and edges

iii. Print nodes, and edges in a user readable format

iv. Computes basic statistics of the graph like degree distribution,

clustering coefficient, and the number of connected components.

v. Finding all the neighbors of a node

vi. Finding all the connected components and storing them as individual

Graph objects inside the class

vii. Finding single source shortest paths using Breadth First Search

b. Make a ‘DiGraph’ class to handle directed graphs which inherits from the

‘Graph’ class. In addition to all of the functionalities of (a), it should support

the following operations

i. Finding the predecessors and successors of a node

ii. Creating a new ‘DiGraph’ object where all the edges are reversed.

iii. Finding the strongly connected components

c. Extend (a) and (b) to handle weighted graphs, and implement Dijkstra’s and

Floyd-Warshall algorithms to compute the single source and all pairs shortest

paths.

d. Use the graph containers in (a), (b), and (c) to implement additional graph

algorithms.

CMS-A-DSE-B--2-TH: Programming using Python 3 DSE-B: Choice-2: Theory, Credit: 04, Contact hour: 60.

 Introduction to the Python

Interpreted vs. compiled languages. Bytecodes. The importance of whitespace.

Variables and the lack of explicit data types and how Python uses the concepts of duck,

strong, and static typing, to figure out data types in runtime.

The assignment operator, the binding of names to objects, and aliasing.

Keywords and their significance.

04 hours

Strings: definition, declaration, and immutability, string constants, declaration, and the

equivalence of single and double quotes. Multi-line strings. Raw strings. String formatting

using the format function and the % operator. f-strings in Python 3.6+. Built-in functions:

count, find, replace, upper, lower, strip, etc. Time and space complexities of the functions

and operations.

Lists: definition, declaration, and mutability. Nested lists. Indexing and slicing: same as

strings. List comprehensions. The split and join methods. Built-in list functions – append,

extend, count, find, index, etc. Time and space complexities of the functions and

operations.

Tuples: definition, declaration, and immutability. Packing and unpacking lists and tuples.

The + and * operators on strings, lists, and tuples. Indexing and slicing strings, lists, and

tuples.

06 hours

Conditionals, Iterators, and Generators

Conditionals: If, elif, and else statements. Nested conditionals. Containment checking in

containers using the in keyword.

Looping constructs: while and for loops. Flow control using break, continue, and pass.

Nested loops.

Generators: range, zip, sorted, reversed, and enumerate.

15 hours

User-defined Functions and Recursion

Functions: definition, function signature, positional, default, and keyword arguments.

Documentation strings. Unnamed functions – lambda, filter, and map.

Recursion: basic idea, implementing recursion, sharing variables across the recursion

stack, modifying the size of the recursion stack.

10 hours

File Handling and Exception Handling

File handling: open and close methods, the different read and write modes. Using the with

open approach to files. read, readline, readlines functions. The csv module for efficient

read/write of structured data. The pickle module for persistent storage of variables in a

program.

Exception handling: the popular errors- Name Error, Value Error, Syntax Error, Key

Error, Attribute Error, etc, and their cause and effects. Using try-except blocks for

graceful handling of exceptions.

05 hours

Unordered data types - Sets and Dictionaries

Basic concepts of hashing: hash functions, open chain, closed chain, advantages and

disadvantages compared to conventional ordered data types. The hash() function in

Python.

Sets and frozensets: definition, declaration, mutability, and advantages over lists / tuples.

05 hours

Insertion, deletion, union, intersection, and other built-in operations. Time and space

complexities of the functions and operations.

Dictionaries: Concept of keys and values. Immutability requirement for keys. Basic

operations on dictionaries. Iterating over the keys and key, value pairs of a dictionary.

Dictionary inversions

Intro to Object Oriented Programming

The Python data model, magic methods (__init__, __str__, __eq__, etc) and their utilities,

accessing and mutating data, constructors, class methods, and the lack of explicit access

modifiers of class methods – naming conventions of private, protected, and public

variables and methods.

Inheritance: inheriting a parent class, the super() method. Basic multiple inheritance.

CMS-A-DSE-B-1-P:Operation Research (O.R)Lab using C DSE-B: Choice-1: Practical, Credit: 02, Contact hours: 40.

  Lab sessions related to Simplex Method, Transportation Problem and Assignment Problem.