FIZIKA MIND

Subscribe to FIZIKA MIND feed
Updated: 11 hours 31 min ago

Computer Application with JAVA for Class X ICSE

19 November 2016 - 11:18pm

FIZIKA MIND is Providing coaching tuitions on JAVA Programing Language. Simplicity in training make us remarkable  Computer Application with JAVA for Class X in Bareilly. Emphasis on correct syllabus oriented training help you score high marks in examination. Short term course will save your time and effort. All teaching will be provided by Er. Swami sir (Electronics Engineer ). Swamisir get Engineering degree from SRMS College of Engineering and Technology Bareilly

Computer Application with JAVA for Class X ICSE:There is one written paper of two hours duration carrying 100 marks and Internal Assessment of 100 marks. The paper i divided into two sections: A and B. Section A (Compulsory - 40 marks) consists of compulsory short answer questions covering the entire syllabus. Section B (60 marks) consists of questions which require detailed answers and there is choice of questions in this section.

1. Revision of Class IX Syllabus

(i) Elementary Concept of Objects and Classes.

(ii) Values and types.

(iii) Conditionals and non-nested loops.

Topics include 

2. Class as the Basis of all Computation

Objects and Classes

Objects encapsulate state and behaviour – numerous examples; member variables; attributes or features. Variables define state; member functions; Operations/methods/ messages/ functions define behaviour.

Classes as abstractions for sets of objects; class as an object factory; concept of type, primitive data types, composite data types. Variable declarations for both types; difference between the two types. Objects as instances of a class.

Consider real life examples for explaining the concept of class and object.

3. Constructors

Constructor and its types.

Default constructor, parameterized constructor, constructor with default parameter and constructor overloading.

4. Functions

Functions and its types

Need of functions. Types of functions (pure and impure). Function declaration and definition, ways of calling functions (call by value and call by reference) Returning information/messages from the functions and use of multiple functions and more than one function with the same name (function overloading). Use of static data member with static member function. Discuss invocation of functions on objects (through the reference). Discuss the concept of this with a reference to the object on which the invocation is made again.

5. Class as a User Defined Type

Class as a composite type, distinction between primitive type and composite or class types.

Class may be considered as a new data type created by the user, that has its own functionality.

The distinction between primitive and composite types should be discussed through examples. Show how classes allow user defined types in programs. All primitive types have corresponding class wrappers.

The following methods are to be covered:

int parseInt(String s), int valueOf(String s), long parseLong(String s), long valueOf(String s), float parseFloat(String s), float valueOf(String s), double parseDouble(String s), double valueOf(String s), boolean isDigit(char ch), boolean isLetter(char ch), boolean isLetterOrDigit(char ch), boolean isLowerCase(char ch), boolean isUpperCase(char ch), boolean isWhitespace(char ch), char to LowerCase (char ch), char to UpperCase(char ch)

6. Iterations

Loops, nested loops, break and continue.

Revision of loops (while, do while and for). Show how each kind of loop can be converted to the other form of the loop. Introduce nested loops through some simple examples. Demonstrate break and continue statements with the help of loops/nested loops.

7. Using Library Classes

Simple input/output. String, packages and import statements.

Browsing the documentation for classes in the libraries and illustrating their use. The following functions have to be covered:

String library functions:

  • Char charAt (int n)
  • int compareTo(String1, String2)
  • String concat(String str)
  • boolean endsWith(String str)
  • boolean equals(String str)
  • boolean equalsIgnoreCase(String str)
  • int indexOf(char ch)
  • int lastIndexOf(char ch)
  • int length( )
  • String replace (char oldChar,char newChar)
  • boolean startsWith(String str)
  • String substring(int beginIndex, int endIndex)
  • String toLowerCase( )
  • String toUpperCase( )
  • String trim( )
  • String valueOf(all types)

Mathematical Library Functions:

pow(x,y), log(x), sqrt(x), ceil(x), floor(x), rint(x), abs(a), max(a, b), min(a,b), random( ), sin(x), cos(x), tan(x).

Introduce the concept of packages and import statement (Avoid discussing the details of libraries).

8. Encapsulation

Access specifiers and scope and visibility

Access specifiers – private and public. Visibility rules for private, package and public access specifiers. Scope of variables, instance variables, argument variables, local variables.

9. Arrays

Arrays – storing, retrieving and arranging data

Arrays and their uses, sorting algorithms - selection sort and bubble sort; Search algorithms – linear search and binary search Example of a composite type. Array creation. Sorting and searching algorithms should be discussed (single dimensional array only).

10. Input/Output

Basic input/output using Scanner and Printer classes from JDK.

The Scanner class can be used for input of various types of data (e.g. int, float, char etc.) from the standard input stream.

Tags:  JAVA ICSE

Computer Application with JAVA for Class IX ICSE

19 November 2016 - 11:17pm

FIZIKA MIND is Providing coaching tuitions on JAVA Programing Language. Simplicity in training make us remarkable  Computer Application with JAVA for Class IX in Bareilly. Emphasis on correct syllabus oriented training help you score high marks in examination. Short term course will save your time and effort. All teaching will be provided by Er. Swami sir (Electronics Engineer ). Swamisir get Engineering degree from SRMS College of Engineering and Technology Bareilly

There is one written paper of two hours duration carrying 100 marks and Internal Assessment of 100 marks. The paper is divided into two sections: A and B. Section A (Compulsory - 40 marks) consists of compulsory short answer questions covering the entire syllabus. Section B (60 marks) consists of questions which require detailed answers and there is a choice of questions in this section.

 

Topics include  1. Operating System

i) Introduction to Operating System

The need for an operating system, features and functions of an operating system and familiarity with installing and uninstalling software.

Functions and features of an operating system (examples of single user and multiple users); familiarize the students with installation and un-installation of connected peripherals and other related softwares like dictionaries, encyclopedias, etc.

ii) Graphic User Interface

Working with the Graphical User Interface (GUI), Elements of a GUI, handling files and directories under GUI, managing the desktop.

Concept of an active window. Familiarity with the icons, the buttons and the task bar. Resizing a window. Handling multiple windows. Creating folders. Copying items. Moving items. Deleting Items. Setting attributes of items. Creating shortcuts on the desktop, arranging the folders on the desktop.

2. The Internet

Internet, e-mail, WWW, modem and related protocols.

Working of internet, creating an e-mail account, sending and receiving e-mails, web servers, search engines to perform a simple search and Boolean operators to fine tune a search, basic working of a modem (modulation and demodulation) through block diagrams only. Protocols and its need (FTP, HTTP, IMAP, POP, SMTP). Downloading information.

3. Computing and Ethics

Ethical issues in computing.

Intellectual property rights; protection of individual’s right to privacy; data protection on the internet; protection against Spam; software piracy, cyber crime, hacking, protection against malicious intent and malicious code.

The stress should be on good etiquette and ethical practices.

4. Office Application Software

Word processor, Multimedia presentation and Spreadsheets.

Discuss the following features for Word Processor, Multimedia Presentation and Spreadsheets: Opening and closing, saving, editing, formatting, printing, spell check, grammar and header/footer.

Special features:

Word Processor – inserting a table and working with tables.

Multimedia Presentation – the students should be able to create a presentation using images / pictures, sound, video and custom animation. Students should be able to import material from word processors, spreadsheets, databases and internet.

Spreadsheets – Using formulae functions (mathematical), working with ranges, graphs and charts. Difference between absolute and relative references.

5. Database Packages

The need for database management; creating and saving a database; editing a database; performing calculations; modifying the structure of a database; sorting, indexing; querying; report generation. Working with multiple databases, object linking and embedding, creating applications.

The need for database management for handling vast amount of data - storing, sorting, summarizing, classifying and retrieving quickly.

Defining the structure of a database, entering data of various types, saving it in an appropriate area. Adding, deleting and modifying records, global editing.

Performing calculations on one record or a group of records. Modifying the structure of a database by inserting, deleting or modifying fields. Sorting on one field/ multiple fields, sorting selected records/ all the records.

Indexing on one field/ multiple fields. The need for re- indexing. Sorting vs. Indexing. Setting query condition, Relational and Logical Operators, setting query using multiple conditions. Generating detailed or summary reports.

Working with multiple databases and explain the relationship (one to one, one to many, many to one and many to many) through real life examples.

Linking objects/embedding objects, linking vs. embedding. Creating database applications depending upon the requirement of the user.

6. Elementary Concept of Objects and Classes

Modelling entities and their behaviour by objects; a class as a specification for objects and as an object factory; computation as message passing/function calls between objects (many examples should be done to illustrate this). Objects encapsulate state (attributes) and have behaviour (functions). Class as a user defined type.

A class may be regarded as a blueprint to create objects. It may be viewed as a factory that produces similar objects. A class may also be considered as a new data type created by the user, that has its own functionality.

All the four features of Object Oriented Programming should be defined and explained using real life examples.

Analyze each object and show how each contains attributes and responds to certain messages or permits certain operations.

Emphasize that an object is an instance of a class. A single object is just a bundle of values, one for each attribute in the class.

7. Values and types

Tokens and its types, Primitive types, operations on primitive values, expressions, assignment (assignment is also an expression).

Introduce the primitive types and the range of values each represents. Discuss all the operations that can be done with primitive types namely mathematical, relational and logical. Discuss precedence and associativity of operators.

Introduce the concept of type casting. Introduce System.out.println and System.out.print, for simple output.

Discuss different types of errors occurring during execution and compilation of the program (syntax errors, runtime errors and logical errors).

8. Conditionals and non-nested loops

Application of if else, if else if ladder, switch-case (default, break).

Fixed number of iterations- the for loop. Unknown number of iterations - while loop, do-while loop.

The conditional/ternary operator (? : ) should be introduced at this point.

Loops are fundamental to computation and their need should be shown by examples.

Examples: various number based problems: prime numbers, composite numbers, perfect numbers, fibonacci numbers, etc.

Tags:  JAVA ICSE

Computer Science with JAVA for Class XII ISC

19 November 2016 - 11:15pm

FIZIKA MIND is Providing coaching tuitions on JAVA Programing Language. Simplicity in training make us remarkable  Computer Science with JAVA for Class XII ISC in Bareilly. Emphasis on correct syllabus oriented training help you score high marks in examination. Short term course will save your time and effort. All teaching will be provided by Er. Swami sir (Electronics Engineer ). Swamisir get Engineering degree from SRMS College of Engineering and Technology Bareilly

Topics include 

Class XII

Section A

1. Boolean Algebra

(a) Propositional logic, well formed formulae, truth values and interpretation of well formed formulae (wff), truth tables, satisfiable, unsatisfiable and valid formulae. Equivalence laws and their use in simplifying wffs.

Propositional variables; the common logical connectives (~ (not), ∧ (and), ∨ (or), ⇒ (implication), ⇔ (biconditional); definition of a well-formed formula (wff); representation of simple word problems as wff (this can be used for motivation); the values true and false; interpretation of a wff; truth tables; satisfiable, unsatisfiable and valid formulae.

Equivalence laws: commutativity of ∧, ∨; associativity of ∧, ∨; distributivity; de Morgan’s laws; law of implication (p ⇒ q ≡ ~p ∨ q); law of biconditional ((p ⇔ q) ≡ (p ⇒ q) ∧ (q ⇒ p)); identity (p ≡ p); law of negation (~ (~p) ≡ p); law of excluded middle (p ∨~p ≡ true); law of contradiction (p∧~p ≡ false); simplification rules for ∧, ∨.

p ∨ p ≡ p
p ∧ p ≡ p
p ∨ true ≡ true
p ∧ true ≡ p
p ∨ false ≡ p
p ∧ false ≡ false
p ∨ (p ∧ q) ≡ p
p ∧ (p ∨ q) ≡ p

The equivalence rules can be used to simplify propositional wffs, for example:

1) (p ⇒ q) ∧ (p ⇒ r) to p ⇒ (q ∧ r)

2) ((p ⇒ q) ∧ p) ⇒ q to true etc.

(b) Binary valued quantities; basic postulates of Boolean algebra; operations AND, OR and NOT; truth tables.

(c) Basic theorems of Boolean algebra (e.g. Duality, idempotence, commutativity, associativity, distributivity, operations with 0 and 1, complements, absorption, involution); De Morgan’s theorem and its applications; reducing Boolean expressions to sum of products and product of sums forms; Karnaugh maps (up to four variables).

Verify the laws of boolean algebra using truth tables. Inputs, outputs for circuits like half and full adders, majority circuit etc., SOP representation; reduction using Karnaugh maps and boolean algebra.

2. Computer Hardware

(a) Elementary logic gates (NOT, AND, OR, NAND, NOR, XOR, XNOR) and their use in circuits.

(b) Applications of Boolean algebra and logic gates to half adders, full adders, encoders, decoders, multiplexers, NAND, NOR as universal gates.

Show the correspondence between boolean functions and the corresponding switching circuits or gates. Show that NAND and NOR gates are universal by converting some circuits to purely NAND or NOR gates.

Section B

The programming element in the syllabus (Sections B and C) is aimed at algorithmic problem solving and not merely rote learning of Java syntax. The Java version used should be 1.5 or later. For programming, the students can use any text editor and the javac and java programs or any development environment: for example, BlueJ, Eclipse, NetBeans etc. BlueJ is strongly recommended for its simplicity, ease of use and because it is very well suited for an ‘objects first’ approach.

3. Implementation of algorithms to solve problems

The students are required to do lab assignments in the computer lab concurrently with the lectures. Programming assignments should be done such that each major topic is covered in at least one assignment. Assignment problems should be designed so that they are non-trivial and make the student do algorithm design, address correctness issues, implement and execute the algorithm in Java and debug where necessary.

Self explanatory.

4. Programming in Java (Review of Class XI Sections B and C)

Note that items 4 to 8 will get introduced almost simultaneously when classes and their definitions are introduced.

5. Objects

(a) Objects as data (attributes) + behaviour (methods or functions); object as an instance of a class. Constructors.
Difference between object and class should be made very clear. BlueJ (www.bluej.org) and Greenfoot (www.greenfoot.org) can be profitably used for this purpose. Constructor as a special kind of function; the new operator; multiple constructors with different argument structures; constructor returns a reference to the object.

(b) Analysis of some real world programming examples in terms of objects and classes.
Use simple examples like a calculator, date, number, etc. to illustrate how they can be treated as objects that behave in certain well-defined ways and how the interface provides a

way to access behaviour. Illustrate behaviour changes by adding new functions, deleting old functions or modifying existing functions.

6. Primitive values, wrapper classes, types and casting

Primitive values and types: int, short, long, float, double, boolean, char. Corresponding wrapper classes for each primitive type. Class as type of the object. Class as mechanism for user defined types. Changing types through user defined casting and automatic type coercion for some primitive types.

Ideally, everything should be a class; primitive types are defined for efficiency reasons; each primitive type has a corresponding wrapper class. Classes as user defined types. In some cases types are changed by automatic coercion or casting – e.g. mixed type expressions. However, casting in general is not a good idea and should be avoided, if possible.

7. Variables, expressions

Variables as names for values; expressions (arithmetic and logical) and their evaluation (operators, associativity, precedence). Assignment operation; difference between left hand side and right hand side of assignment.

Variables denote values; variables are already defined as attributes in classes; variables have types that constrain the values it can denote. Difference between variables denoting primitive values and object values – variables denoting objects are references to those objects. The assignment operator = is special. The variable on the lhs of = denotes the memory location while the same variable on the rhs denotes the contents of the location e.g. i=i+2.

8. Statements, scope

Statements; conditional (if, if-then-else, switch-break, ?: ternary operator), looping (for, while-do, do-while, continue, break); grouping statements in blocks, scope and visibility of variables.

Describe the semantics of the conditional and looping statements in detail. Evaluation of the condition in conditional statements (esp. difference between || and | and && and &).

Emphasize fall through in switch statement. Many small examples should be done to illustrate control structures. Printing different kinds of patterns for looping is instructive. When number of iterations are known in advance use the for loop otherwise the while-do or do-while loop. Express one loop construct using the others. For e.g.:

for (<init>; <test>; <inc>) <stmt>; is equivalent to:

Using while

<init>; while <test> {<stmt>; <inc> }

Using do-while

<init>; if !<test> do <stmt>; <inc> while <test>;
Nesting of blocks. Variables with block scope, function scope, class scope. Visibility rules when variables with the same name are defined in different scopes.

9. Functions

Functions/methods (as abstractions for complex user defined operations on objects), functions as mechanisms for side effects; formal arguments and actual arguments in functions; different behaviour of primitive and object arguments. Static functions and variables. The this variable. Examples of algorithmic problem solving using functions (various number theoretic problems, finding roots of algebraic equations).

Functions are like complex operations where the object is implicitly the first argument. Variable this denotes the current object. Functions typically return values, they may also cause side-effects (e.g. change attribute values of objects) – typically functions that are only supposed to cause side-effects return void (e.g. Set functions). Java passes argument by value. Illustrate the difference between primitive values and object values as arguments (changes made inside functions persist after the call for object values). Static definitions as class variables and class functions visible and shared by all instances. Need for static functions and variables. Introduce the main method – needed to begin execution.

10. Arrays, strings

(a) Structured data types – arrays (single and multi-dimensional), strings. Example algorithms that use structured data types (e.g. searching, finding maximum/minimum, sorting techniques, solving systems of linear equations, substring, concatenation, length, access to char in string, etc.).

Storing many data elements of the same type requires structured data types – like arrays. Access in arrays is constant time and does not depend on the number of elements. Sorting techniques (bubble, selection, insertion). Structured data types can be defined by classes – String. Introduce the Java library String class and the basic operations on strings (accessing individual characters, various substring operations, concatenation, replacement, index of operations). The Class StringBuffer should be introduced for those applications that involve heavy manipulation of strings.

(b) Basic concept of a virtual machine; Java virtual machine; compilation and execution of Java programs (the javac and java programs).

The JVM is a machine but built as a program and not through hardware. Therefore it is called a virtual machine. To run, JVM machine language programs require an interpreter (the java program). The advantage is that such JVM machine language programs (.class files) are portable and can run on any machine that has the java program.

(c) Compile time and run time errors; basic concept of an exception, the Exception class, catch and throw.

Differentiate between compile time and run time errors. Run time errors crash the program. Recovery is possible by the use of exceptions. Explain how an exception object is created and passed up until a matching catch is found. This behaviour is different from the one where a value is returned by a deeply nested function call. It is enough to discuss the Exception class. Sub-classes of Exception can be discussed after inheritance has been done in Class XII.

(d) Class as a contract; separating implementation from interface; encapsulation; private and public.

Class is the basic reusable unit. Its function prototypes (i.e. the interface) work as a visible contract with the outside world since others will use these functions in their programs. This leads to encapsulation (i.e. hiding implementation information) which in turn leads to the use of private and public for realizing encapsulation.

(e) Interfaces in Java; implementing interfaces through a class; interfaces for user defined implementation of behaviour.

Motivation for interface: often when creating reusable classes, some parts of the exact implementation can only be provided by the final end user. For example, in a class that sorts records of different types the exact comparison operation can only be provided by the end user. Since only he/she knows which field(s) will be used for doing the comparison and whether sorting should be in ascending or descending order be given by the user of the class.

Emphasize the difference between the Java language construct interface and the word interface often used to describe the set of function prototypes of a class.

(e) Basic input/output using Scanner and Printer classes from JDK; files and their representation using the File class, file input/output; input/output exceptions. Tokens in an input stream, concept of whitespace, extracting tokens from an input stream (StringTokenizer class).
The Scanner class can be used for input of various types of data (e.g. int, float, char etc.) from the standard input stream or a file input stream. The File class is used model file objects in the underlying system in an OS independent manner. Similarly, the Printer class handles output. Only basic input and output using these classes should be covered.
Discuss the concept of a token (a delimited continuous stream of characters that is meaningful in the application program – e.g.

words in a sentence where the delimiter is the blank character). This naturally leads to the idea of delimiters and in particular whitespace and user defined characters as delimiters. As an example show how the StringTokenizer class allows one to extract a sequence of tokens from a string with user defined delimiters.

(g) Concept of recursion, simple recursive functions (e.g. factorial, GCD, binary search, conversion of representations of numbers between different bases). Recursive sorting techniques.

Many problems can be solved very elegantly by observing that the solution can be composed of solutions to ‘smaller’ versions of the same problem with the base version having a known simple solution. Recursion can be initially motivated by using recursive equations to define certain functions. These definitions are fairly obvious and are easy to understand. The definitions can be directly converted to a program. Emphasize that any recursion must have a base case. Otherwise, the computation can go into an infinite loop. Illustrate this by removing the base case and running the program. Examples:

(i) Definition of factorial:

factorial(0) = 1 //base case
factorial(n) = n * factorial(n-1)

(ii) Definition of GCD:

gcd(m, n) =
if (m==n) then n //base case
else if (m>n) then gcd(m-n, n)
else gcd(m, n-m)

(iii) Definition of Fibonacci numbers:

fib(0) = 1 //base case
fib(1) = 1 //base case
fib(n) = fib(n-1)+ fib(n-2)

The tower of Hanoi is a very good example of how recursion gives a very simple and elegant solution where as non-recursive solutions are quite complex. Discuss the use of a stack to keep track of function calls. A stack can also be used to solve the tower of Hanoi problem non-recursively. Merge sort and Quick sort on arrays.

Section C

Inheritance, polymorphism, data structures, computational complexity

11. Inheritance and polymorphism

Inheritance; base and derived classes; member access in derived classes; redefinition of variables and functions in subclasses; abstract classes; class Object; protected visibility. Subclass polymorphism and dynamic binding.
Emphasize the following:

– inheritance as a mechanism to reuse a class by extending it.
– inheritance should not normally be used just to reuse some functions defined in a class but only when there is a genuine

specialization (or subclass) relationship between objects of the base class and that of the derived class.

– Allows one to implement operations at the highest relevant level of abstraction.
– Freezes the interface in the form of abstract classes with abstract functions that can be extended by the concrete

implementing classes. For example, an abstract class Shape can have an abstract function draw that is implemented differently in the sub-classes like Circle, Quadrilateral etc.

– how the exact function call at run time depends on the type of the object referenced by the variable. This gives sub-class

polymorphism. For example in the code fragment:

Shape s1=new Circle(), s2=new Quadrilateral();

s1.draw(); //the draw is the draw in Circle

s2.draw(); //the draw is the draw in Quadrilateral

the two draw function invocations on s1, s2 invoke different draw functions depending on the type of objects referenced by s1 and s2 respectively.

12. Data structures

(a) Basic data structures (stack, queue, dequeue); implementation directly through classes; definition through an interface and multiple implementations by implementing the interface. Basic algorithms and programs using the above data structures.
A data structure is a data collection with well defined operations and behaviour or properties. The behaviour or properties can usually be expressed formally using equations or some kind of logical formulae. Consider for e.g. a stack with operations defined as follows:

void push(Object o)

Object pop()
boolean isEmpty()
Object top()

Then, for example the LIFO property can be expressed by (assume s is a stack):

if s.push(o); o1=pop() then o ≡ o1

What the rule says is: if o is pushed on the stack s and then it is popped and o1 is the object obtained then o, o1 are identical.
Another useful property is:

if s.isEmpty() == true then s.pop() = ERROR
It says that popping an empty stack gives ERROR.

Similarly, several other properties can also be specified. It is important to emphasize the behavioural rules or properties of a data structure since any implementation must guarantee that the rules hold.

Some simple algorithms that use the data structures:

(i) For stack: parentheses matching, tower of Hanoi, nested function calls; solving a maze.

(ii) For queue: scheduling processes, printers, jobs in a machine shop.

(b) Recursive data structures: single linked list (Algorithm and programming), binary trees, tree traversals (Conceptual)

Data structures should be defined as abstract data types with a well defined interface (it is instructive to define them using the Java interface construct) – see the comments in (a) above. Emphasize that algorithms for recursive data structures are themselves recursive and that algorithms are usually the simplest and most elegant. The following should be covered for each data structure:

Linked List (single): insertion, deletion, reversal, extracting an element or a sublist, checking emptiness.

Binary trees: apart from the definition the following concepts should be covered: external and internal nodes, height, completeness, balancing, Traversals (pre, post and in-order).

13. Complexity and big O notation

Concrete computational complexity; concept of input size; estimating complexity in terms of functions; importance of dominant term; best, average and worst case. Big O notation for computational complexity; analysis of complexity of example algorithms using the big O notation (e.g. Various searching and sorting algorithms, algorithm for solution of linear equations etc.).

Points to be given particular emphasis:

(i) Algorithms are usually compared along two dimensions – amount of space (that is memory) used and the time taken. Of the two the time taken is usually considered the more important. The motivation to study time complexity is to compare different algorithms and use the one that is the most efficient in a particular situation.
(ii) Actual run time on a particular computer is not a good basis for comparison since it depends heavily on the speed of the computer, the total amount of RAM in the computer, the OS running on the system and the quality of the compiler used. So we need a more abstract way to compare the time complexity of algorithms.

(iii) This is done by trying to approximate the number of operations done by each algorithm as a function of the size of the input. In most programs the loops are important in deciding the complexity. For example in bubble sort there are two nested loops and in the worst case the time taken will be proportional to n(n-1) where n is the number of elements to be sorted. Similarly, in linear search in the worst case the target has to be compared with all the elements so time taken will be proportional to n where n is the number of elements in the search set.

(iv) In most algorithms the actual complexity for a particular input can vary. For example in search the number of comparisons can vary from 1 to n. This means we need to study the best, worst and average cases. Comparisons are usually made taking the worst case. Average cases are harder to estimate since it depends on how the data is distributed. For example in search, if the elements are uniformly distributed it will take on the average n/2 comparisons when the average is taken over a statistically significant number of instances.

(v) Comparisons are normally made for large values of the input size. This means that the dominant term in the function is the important term. For example if we are looking at bubble sort and see that time taken can be estimated as: a*n2 +b*n + c where n is the number of elements to be sorted and a, b, c are constants then for large n the dominant term is clearly n2 and we can, in effect, ignore the other two terms.

All the above motivates the big O notation. Let f(n), g(n) be positive functions, then f(n) is said to be O(g(n)) if there exists constants c, n0 such that f(x)≤ c*g(n) whenever n>n0. What this means is that g(n) asymptotically dominates f(n). Expressing time complexity using the big O notation gives us an abstract basis for comparison and frees us from bothering about constants. So the estimated time complexity a*n2+b*n+c is O(n2).

Analyse the big O complexity of the algorithms pertaining to the data structures in 11 (a) and (b) above.

Paper II – Practical

This paper of three hours duration will be evaluated by the Visiting Examiner appointed locally and approved by the Council.
The paper shall consist of three programming problems from which a candidate has to attempt any one. The practical consists of the two parts:

1. Planning Session

2. Examination Session

The total time to be spent on the Planning session and the Examination session is three hours. After completing the Planning session the candidates may begin with the Examination session. A maximum of 90 minutes is permitted for the Planning session. However, if the candidates finish earlier, they are to be permitted to begin with the Examination session.

Planning Session

The candidates will be required to prepare an algorithm and a hand written Java program to solve the problem.

Examination Session

The program handed in at the end of the Planning session shall be returned to the candidates. The candidates will be required to key-in and execute the Java program on seen and unseen inputs individually on the Computer and show execution to the Visiting Examiner. A printout of the program listing including output results should be attached to the answer script containing the algorithm and handwritten program. This should be returned to the examiner. The program should be sufficiently documented so that the algorithm, representation and development process is clear from reading the program. Large differences between the planned program and the printout will result in loss of marks.

Teachers should maintain a record of all the assignments done as part of the practical work through the year and give it due credit at the time of cumulative evaluation at the end of the year. Students are expected to do a minimum of twenty assignments for the year.

Marks (out of a total of 100) should be distributed as given below:

Continuous Evaluation

Candidates will be required to submit a work file containing the practical work related to programming assignments done during the year.

Programming assignments done throughout the year (Internal evaluation) – 10 marks

Programming assignments done throughout the year (Visiting Examiner) – 10 marks

Terminal Evaluation

Solution to programming problem on the computer – 60 marks

(Marks should be given for choice of algorithm and implementation strategy, documentation, correct output on known inputs

mentioned in the question paper, correct output for unknown inputs available only to the examiner.) Viva-voce – 20 marks

(Viva-voce includes questions on the following aspects of the problem attempted by the student: the algorithm and implementation strategy, documentation, correctness, alternative algorithms or implementations. Questions should be confined largely to the problem the student has attempted).

Note:

Algorithm should be expressed clearly using any standard scheme such as a pseudo code.

Equipment

There should be enough computers to provide for a teaching schedule where at least three-fourths of the time available is used for programming.

Schools should have equipment/platforms such that all the software required for practical work runs properly, i.e. it should run at acceptable speeds.

Since hardware and software evolve and change very rapidly, the schools may have to upgrade them as required. Following are the recommended specifications as of now:

The Facilities:

  • A lecture cum demonstration room with a Multimedia Projector/ an LCD and O.H.P. attached to the computer.
  • A white board with white board markers should be available.
  • A fully equipped Computer Laboratory that allows one computer per student.
  • Internet connection for accessing the World Wide Web and email facility.
  • The computers should have a minimum of 512 MB (1 GB preferred) RAM and a PIV or higher processor. The basic requirement is that it should run the operating system and Java programming system (Java compiler, Java runtime environment, Java development environment) at acceptable speeds.
  • Good Quality printers.

Software:

  • Any suitable Operating System can be used.
  • JDK 6 or later.
  • Documentation for the JDK version being used.
  • A suitable text editor. A development environment with a debugger is preferred (e.g. BlueJ, Eclipse, NetBeans). BlueJ is recommended for its ease of use and simplicity.
Tags:  JAVA ICSE

Computer Science with JAVA for Class XI ISC

19 November 2016 - 11:14pm

FIZIKA MIND is Providing coaching tuitions on JAVA Programing Language. Simplicity in training make us remarkable  Computer Science with JAVA for Class XI ISC in Bareilly. Emphasis on correct syllabus oriented training help you score high marks in examination. Short term course will save your time and effort. All teaching will be provided by Er. Swami sir (Electronics Engineer ). Swamisir get Engineering degree from SRMS College of Engineering and Technology Bareilly

Topics include 

Section A

Basic Computer Hardware and Software

1. Numbers

Representation of numbers in different bases and interconversion between them (e.g. binary, octal, decimal, hexadecimal). Addition and subtraction operations for numbers in different bases.

Introduce the positional system of representing numbers and the concept of a base. Discuss the conversion of representations between different bases using English or pseudo code. These

algorithms are also good examples for defining different functions in a class modelling numbers (when programming is discussed). For addition and subtraction use the analogy with decimal numbers, emphasize how carry works (this will be useful later when binary adders are discussed).

2. Encodings

(a) Binary encodings for integers and real numbers using a finite number of bits (sign-magnitude, twos complement, mantissa-exponent notation). Basic operations on integers and floating point numbers. Limitations of finite representations.

Signed, unsigned numbers, least and most significant bits. Sign-magnitude representation and its shortcomings (two representations for 0, addition requires extra step); twos-complement representation. Operations (arithmetic, logical, shift), discuss the basic algorithms used for the arithmetic operations. Floating point representation: normalized scientific notation, mantissa-exponent representation, binary point (discuss trade-off between size of mantissa and exponent). Single and double precision. Arithmetic operations with floating point numbers. Properties of finite representation: overflow, underflow, lack of associativity (demonstrate this through actual programs).

(b) Characters and their encodings (e.g. ASCII, Unicode).

Discuss the limitations of the ASCII code in representing characters of other languages. Discuss the Unicode representation for the local language. Java uses Unicode, so strings in the local language can be used (they can be displayed if fonts are available) – a simple table lookup for local language equivalents for Latin (i.e. English) character strings may be done. More details on Unicode are available at www.unicode.org.

3. High level structure of computer

Block diagram of a computer system with details of (i) function of each block and (ii) interconnectivity and data and control flow between the various blocks

Develop the diagram by successive refinement of blocks till all the following have been covered: ALU, RAM, cache, the buses (modern computers have multiple buses), disk (disk controller and what it does), input/output ports (serial, parallel, USB, network, modem, line-in, line-out etc.), devices that can be attached to these ports (e.g keyboard, mouse, monitor, CDROM, DVD, audio input/output devices, printer, etc.). Clearly describe the connectivity and the flow of data and control signals.

4. Basic architecture of a simple processor and its instruction set

Simple Hypothetical Computer.

The simple hypothetical computer abbreviated as (SHC) is meant to introduce the basic structure of a processor in particular registers, basic instruction set, structure of an instruction, program counter addressing modes (immediate, direct, register, register-indirect). Simple programs should be written in the SHC instruction set (e.g. max./min. of set of nos.)

5. Propositional logic, hardware implementation, arithmetic operations

(a) Propositional logic, well formed formulae, truth values and interpretation of well formed formulae, truth tables.

Propositional variables; the common logical connectives (~ (not), ∧ (and), ∨(or), ⇒ (implication), ⇔ (equivalence)); definition of a well-formed formula (wff); representation of simple word problems as wff (this can be used for motivation); the values true and false; interpretation of a wff; truth tables; satisfiable, unsatisfiable and valid formulae.

(b) Logic and hardware, basic gates (AND, NOT, OR) and their universality, other gates (NAND, NOR, XOR); inverter, half adder, full adder.

Show how the logic in (a) above can be realized in hardware in the form of gates. These gates can then be combined to implement the basic operations for arithmetic. Tie up with the arithmetic operations on integers discussed earlier in 2 (a).

6. Memory

Memory organization and access; parity; memory hierarchy – cache, primary memory, secondary memory.

The access time differences between the different kinds of memory; size differences; locality of reference and cache memory.

7. System and other software

Boot process. Operating system as resource manager, command processing, files, directories and file system. Commonly available programs (editors, compilers, interpreters, word processors, spread sheets etc.).

Boot process step-by-step from power on till the prompt. In OS discuss: (i) all the resources (processor, memory, i/o) that need to be managed in a computer; (ii) what is meant by managing these resources. Logical structure of data storage on disk using logical disks, hierarchical directories and files. Distinguish between interpreters and compilers. In particular discuss the javac and java programs.

Section B

The programming element in the syllabus is aimed at algorithmic problem solving and not merely rote learning of Java syntax. The Java version used should be 1.5 or later. For programming, the students can use any text editor and the javac and java programs or any development environment: for example, BlueJ, Eclipse, NetBeans etc. BlueJ is strongly recommended for its simplicity, ease of use and because it is very well suited for an ‘objects first’ approach.

8. Introduction to algorithmic problem solving using Java

Note that topics 9 to 13 will get introduced almost simultaneously when classes and their definitions are introduced.

9. Objects

(a) Objects as data (attributes) + behaviour (methods or functions); object as an instance of a class. Constructors.

Difference between object and class should be made very clear. BlueJ (www.bluej.org) and Greenfoot (www.greenfoot.org) can be used for this purpose. Constructor as a special kind of function; the new operator; multiple constructors with different argument structures; constructor returns a reference to the object.

(b) Analysis of some real world programming examples in terms of objects and classes.

Use simple examples like a calculator, date, number etc. to illustrate how they can be treated as objects that behave in certain well-defined ways and how the interface provides a way to access behaviour. Illustrate behaviour changes by adding new functions, deleting old functions or modifying existing functions.

10. Primitive values, wrapper classes, types and casting

Primitive values and types: int, short, long, float, double, boolean, char. Corresponding wrapper classes for each primitive type. Class as type of the object. Class as mechanism for user defined types. Changing types through user defined casting and automatic type coercion for some primitive types.

Ideally, everything should be a class; primitive types are defined for efficiency reasons; each primitive type has a corresponding wrapper class. Classes as user defined types. In some cases types are changed by automatic coercion or casting – e.g. mixed type expressions. However, casting in general is not a good idea and should be avoided, if possible.

11. Variables, expressions

Variables as names for values; expressions (arithmetic and logical) and their evaluation (operators, associativity, precedence). Assignment operation; difference between left hand side and right hand side of assignment.

Variables denote values; variables are already defined as attributes in classes; variables have types that constrain the values it can denote. Difference between variables denoting primitive values and object values – variables denoting objects are references to those objects. The assignment operator = is special. The variable on the lhs of = denotes the memory location while the same variable on the rhs denotes the contents of the location e.g. i=i+2.

12. Statements, scope

Statements; conditional (if, if-then-else, switch-break, ?: ternary operator), looping (for, while-do, do-while, continue, break); grouping statements in blocks, scope and visibility of variables.

Describe the semantics of the conditional and looping statements in detail. Evaluation of the condition in conditional statements (esp. difference between || and | and && and &). Emphasize fall through in switch statement. Many small examples should be done to illustrate control structures. Printing different kinds of patterns for looping is instructive. When number of iterations are known in advance use the for loop otherwise the while-do or do-while loop. Express one loop construct using the others. For e.g.:

for (<init>; <test>; <inc>) <stmt>;is equivalent to:

(i) Using while

<init>; while <test> {<stmt>; <inc> }

(ii) Using do-while

<init>; if !<test> do <stmt>; <inc> while <test>;
Nesting of blocks. Variables with block scope, function scope, class scope. Visibility rules when variables with the same name are defined in different scopes.

13. Functions

Functions/methods (as abstractions for complex user defined operations on objects), functions as mechanisms for side effects; formal arguments and actual arguments in functions; different behaviour of primitive and object arguments. Static functions and variables. The this variable. Examples of algorithmic problem solving using functions (various number theoretic problems, finding roots of algebraic equations).

Functions are like complex operations where the object is implicitly the first argument. Variable this denotes the current object. Functions typically return values, they may also cause side-effects (e.g. change attribute values of objects) – typically functions that are only supposed to cause side-effects return void (e.g. Set functions). Java passes argument by value. Illustrate the difference between primitive values and object values as arguments (changes made inside functions persist after the call for object values). Static definitions as class variables and class functions visible and shared by all instances. Need for static functions and variables. Introduce the main method – needed to begin execution.

14. Arrays, strings

(a) Structured data types – arrays (single and multi-dimensional), strings. Example algorithms that use structured data types (e.g. searching, finding maximum/minimum, sorting techniques, solving systems of linear equations, substring, concatenation, length, access to char in string, etc.).

Storing many data elements of the same type requires structured data types – like arrays. Access in arrays is constant time and does not depend on the number of elements. Sorting

techniques (bubble, selection, insertion), Structured data types can be defined by classes – String. Introduce the Java library String class and the basic operations on strings (accessing individual characters, various substring operations, concatenation, replacement, index of operations).

(b) Basic concept of a virtual machine; Java virtual machine; compilation and execution of Java programs (the javac and java programs).

The JVM is a machine but built as a program and not through hardware. Therefore it is called a virtual machine. To run, JVM machine language programs require an interpreter (the java program). The advantage is that such JVM machine language programs (.class files) are portable and can run on any machine that has the java program.

(c) Compile time and run time errors; basic concept of an exception, the Exception class, catch and throw.

Differentiate between compile time and run time errors. Run time errors crash the program. Recovery is possible by the use of exceptions. Explain how an exception object is created and passed up until a matching catch is found. This behaviour is different from the one where a value is returned by a deeply nested function call. It is enough to discuss the Exception class. Sub-classes of Exception can be discussed after inheritance has been done in Class XII.

Section C

15. Elementary data structures and associated algorithms, basic input/output

(a) Class as a contract; separating implementation from interface; encapsulation; private and public.
Class is the basic reusable unit. Its function prototypes (i.e. the interface) work as a visible contract with the outside world since others will use these functions in their programs. This leads to encapsulation (i.e. hiding implementation information) which in turn leads to the use of private and public for realizing encapsulation.

(b) Interfaces in Java; implementing interfaces through a class; interfaces for user defined implementation of behaviour.

Motivation for interface: often when creating reusable classes some parts of the exact implementation can only be provided by the final end user. For example in a class that sorts records of different types the exact comparison operation can only be provided by the end user. Since only he/she knows which field(s) will be used for doing the comparison and whether sorting should be in ascending or descending order be given by the user of the class.

Emphasize the difference between the Java language construct interface and the word interface often used to describe the set of function prototypes of a class.

(c) Basic data structures (stack, queue, dequeue); implementation directly through classes; definition through an interface and multiple implementations by implementing the interface. Basic algorithms and programs using the above data structures.
A data structure is a data collection with well defined operations and behaviour or properties. The behaviour or properties can usually be expressed formally using equations or some kind of logical formulae. Consider for e.g. a stack with operations defined as follows:

void push(Object o)

Object pop()

boolean isEmpty()

Object top()

Then, for example the LIFO property can be expressed by (assume s is a stack):

if s.push(o); o1=pop() then o ≡ o1

What the rule says is: if o is pushed on the stack s and then it is popped and o1 is the object obtained then o, o1 are identical.

Another useful property is:

if s.isEmpty() == true then s.pop() = ERROR

It says that popping an empty stack gives ERROR.

Similarly, several other properties can also be specified. It is important to emphasize the behavioural rules or properties of a data structure since any implementation must guarantee that the rules hold.

Some simple algorithms that use the data structures:

i) For stack: parentheses matching, tower of Hanoi, nested function calls; solving a maze.

ii) For queue: scheduling processes, printers, jobs in a machine shop.

(d) Basic input/output using Scanner and Printer classes from JDK; files and their representation using the File class, file input/output; input/output exceptions. Tokens in an input stream, concept of whitespace, extracting tokens from an input stream (StringTokenizer class).

The Scanner class can be used for input of various types of data (e.g. int, float, char etc.) from the standard input stream or a file input stream. The File class is used model file objects in the underlying system in an OS independent manner. Similarly, the Printer class handles output. Only basic input and output using these classes should be covered.

Discuss the concept of a token (a delimited continuous stream of characters that is meaningful in the application program – e.g. words in a sentence where the delimiter is the blank character). This naturally leads to the idea of delimiters and in particular whitespace and user defined characters as delimiters. As an example show how the StringTokenizer class allows one to extract a sequence of tokens from a string with user defined delimiters.

(e) Concept of recursion, simple recursive functions (e.g. factorial, GCD, binary search, conversion of representations of numbers between different bases).

Many problems can be solved very elegantly by observing that the solution can be composed of solutions to ‘smaller’ versions of the same problem with the base version having a known simple solution. Recursion

can be initially motivated by using recursive equations to define certain functions. These definitions are fairly obvious and are easy to understand. The definitions can be directly converted to a program. Emphasize that any recursion must have a base case. Otherwise, the computation can go into an infinite loop. Illustrate this by removing the base case and running the program. Examples:

(i) Definition of factorial:

factorial(0) = 1 //base case
factorial(n) = n * factorial(n-1)

(ii) Definition of GCD:

gcd(m, n) =

if (m==n) then n //base case

else if (m>n) then gcd(m-n, n)

else gcd(m, n-m)

(iii) Definition of Fibonacci numbers:

fib(0) = 1 //base case

fib(1) = 1 //base case

fib(n) = fib(n-1)+ fib(n-2)

The tower of Hanoi is a very good example of how recursion gives a very simple and elegant solution where as non-recursive solutions are quite complex. Discuss the use of a stack to keep track of function calls. The stack can also be used to solve the tower of Hanoi problem non-recursively.

(f) Concrete computational complexity; concept of input size; estimating complexity in terms of functions; importance of dominant term; best, average and worst case.

Points to be given particular emphasis:

(i) Algorithms are usually compared along two dimensions – amount of space (that is memory) used and the time taken. Of the two the time taken is usually considered the more important. The motivation to study time complexity is to compare different algorithms and use the one that is the most efficient in a particular situation.

(ii) Actual run time on a particular computer is not a good basis for comparison since it depends heavily on the speed of the computer, the total amount of RAM in the computer, the OS running on the system and the quality of the compiler used. So we need a more abstract way to compare the time complexity of algorithms.

(iii) This is done by trying to approximate the number of operations done by each algorithm as a function of the size of the input. In most programs the loops are important in deciding the complexity. For example in bubble sort there are two nested loops and in the worst case the time taken will be proportional to n(n-1) where n is the number of elements to be sorted. Similarly, in linear search in the worst case the target has to be compared with all the elements so time taken will be proportional to n where n is the number of elements in the search set.

(iv) In most algorithms the actual complexity for a particular input can vary. For example in search the number of comparisons can vary from 1 to n. This means we need to study the best, worst and average cases. Comparisons are usually made taking the worst case. Average cases are harder to estimate since it depends on how the data is distributed. For example in search, if the elements are uniformly distributed it will take on the average n/2 comparisons when the average is taken over a statistically significant number of instances.

(v) Comparisons are normally made for large values of the input size. This means that the dominant term in the function is the important term. For example if we are looking at bubble sort and see that time taken can be estimated as: a*n2 +b*n + c where n is the number of elements to be sorted and a, b, c are constants then for large n the dominant term is clearly n2 and we can in effect ignore the other two terms.

16. Implementation of algorithms to solve problems

The students are required to do lab assignments in the computer lab concurrently with the lectures. Programming assignments should be done such that each major topic is covered in at least one assignment. Assignment problems should be designed so that they are non-trivial and make the student do algorithm design, address correctness issues, implement and execute the algorithm in Java and debug where necessary.

Self explanatory.

17. Social context of computing and ethical issues

(a) Intellectual property and corresponding laws and rights, software as intellectual property.

(b) Software copyright and patents and the difference between the two; trademarks; software licensing and piracy.

(c) Free software foundation and its position on software, open source software, various types of licensing (e.g. GPL, BSD).

(d) Privacy, email etiquette, spam, security issues, phising.

Social impact and ethical issues should be discussed and debated in class. The important thing is for students to realise that these are complex issues and there are multiple points of view on many of them and there is no single ‘correct’ or ‘right’ view.

Paper II – Practical

This paper of three hours duration will be evaluated internally by the school.
The paper shall consist of three programming problems from which a candidate has to attempt any one. The practical consists of the two parts:

(1) Planning Session

(2) Examination Session

The total time to be spent on the Planning session and the Examination session is three hours. After completing the Planning session the candidates may begin with the Examination session. A maximum of 90 minutes is permitted for the Planning session. However, if the candidates finish earlier, they are to be permitted to begin with the Examination session.

Planning Session

The candidates will be required to prepare an algorithm and a hand written Java program to solve the problem.

Examination Session

The program handed in at the end of the Planning session shall be returned to the candidates. The candidates will be required to key-in and execute the Java program on seen and unseen inputs individually on the Computer and show execution to the examiner. A printout of the program listing, including output results should be attached to the answer script containing the algorithm and handwritten program. This should be returned to the examiner. The program should be sufficiently documented so that the algorithm, representation and development process is clear from reading the program. Large differences between the planned program and the printout will result in loss of marks.

Teachers should maintain a record of all the assignments done as part of the practical work through the year and give it due credit at the time of cumulative evaluation at the end of the year. Students are expected to do a minimum of twenty assignments for the year.

Marks (out of a total of 100) should be distributed as given below:

Continuous Evaluation

Candidates will be required to submit a work file containing the practical work related to programming assignments done during the year.

Programming assignments done throughout the year (Internal evaluation) – 20 marks

Terminal Evaluation

Solution to programming problem on the computer – 60 marks

(Marks should be given for choice of algorithm and implementation strategy, documentation, correct output on known inputs mentioned in the question paper, correct output for unknown inputs available only to the examiner.)
Viva-voce – 20 marks

(Viva-voce includes questions on the following aspects of the problem attempted by the student: the algorithm and implementation strategy, documentation, correctness, alternative algorithms or implementations. Questions should be confined largely to the problem the student has attempted).

Tags:  JAVA ICSE

Certificate Training in Access 2016

6 November 2016 - 12:53pm

Learn how to build databases to store and retrieve your data more efficiently with Access 2016. We shows how to use the powerful program to wrangle your data and create your first table, and highlights smart strategies to edit and modify fields and records.

The course also shows you how to build queries and action queries, create and design forms, use macros, integrate Access with the rest of the Office 2016 suite, and maintain your databases over time.

Topics include 
  • Creating a new database
  • Creating tables and new data types
  • Importing and entering data
  • Setting up relationships and primary keys
  • Adding validation rules
  • Sorting and filtering table data
  • Building queries
  • Designing forms
  • Creating reports
  • Attaching macros to buttons and tables
  • Working with Excel and Outlook data
  • Maintaining an Access database
Training Software :  Access Tags:  Office

Certificate Training in Word 2016

6 November 2016 - 12:48pm

Learn how to create, format, share, and print a wide variety of documents in Word 2016. We covers creating new documents from templates and scratch, formatting text and pages, working with headers and footers, using themes and styles, adding multimedia, and more. He'll also show how to share documents with others and enhance your productivity with macros.

Topics include 
  • Using templates to create new documents
  • Creating and editing text
  • Formatting text, pages, and paragraphs
  • Adjusting line spacing and page breaks
  • Adding headers, footers, and page numbers
  • Applying styles and themes to documents
  • Creating bulleted and numbered lists
  • Working with tables, macros, and building blocks
  • Illustrating documents
  • Proofing, reviewing, and printing documents
  • Collaborating with others via OneDrive and email
  • Customizing Word
Tags:  Office

Certificate Training in Excel 2016

6 November 2016 - 12:16pm

Start mastering Excel, the world's most popular and powerful spreadsheet program, with Excel expert . Learn how to best enter and organize data, perform calculations with simple functions, work with multiple worksheets, format the appearance of your data and cells, and build charts and PivotTables. Other lessons cover the powerful IF, VLOOKUP, and COUNTIF family of functions; the Goal Seek, Solver, and other data analysis tools; and automating tasks with macros.

Topics include 
  • Working with the Excel interface
  • Entering data
  • Creating formulas and functions
  • Formatting rows, columns, cells, and data
  • Working with alignment and text wrap
  • Adjusting rows and columns
  • Finding and replacing data
  • Printing and sharing worksheets
  • Creating charts and PivotTables
  • Inserting and deleting sheets
  • Using power functions such as IF and VLOOKUP
  • Password-protecting worksheets and workbooks
  • Sorting data
  • Analyzing data with Goal Seek and Solver
  • Creating and running macros
Training Software :  Excel Tags:  Office

Certificate Training in CorelDRAW

2 November 2016 - 8:02pm
Course Category:  Desktop Publication (DTP)

CorelDRAW is one of the image-creating programs in a suite of graphic arts software used by professional artists, educators, students, businesses and the general public. The CorelDRAW Graphics Suite X7, which includes CorelDRAW, is sold as stand-alone software and as a cloud-based subscription. CorelDRAW is the core of the graphics suite and is primarily used for vector illustrations and page layouts.

Creative professionals in print and online advertising use CorelDRAW to create and edit vector-based images and illustrations with and without graphics tablets. The CorelDRAW Graphics Suite X7 can also be used to arrange print layouts, design logos and retouch photographs. With the suite, you can convert bitmap images into vector-based graphic art, which you can then edit and customize. Hobbyists can use CorelDraw’s powerful layout and image-editing features to design calendars, newsletters, banners, scrapbooks and other projects.

Topics include 
  • Understanding vector and bitmap images
  • Working with multipage projects
  • Using independent per-page layers and guides
  • Drawing and editing shapes, lines, curves, and tables
  • Creating and using symbols
  • Working with text
  • Designing a business card
  • Shaping, filling, blending, and extruding objects
  • Importing and exporting other file types
  • Customizing the workspace, menus, toolbars, and palettes
Training Software :  CorelDRAW

Certificate Training in Tally

2 November 2016 - 7:51pm
Course Category:  Computer Accounting

Tally is a very good accounting and inventory software developed by Tally Solutions, Bangalore, India.

It is trusted by Chartered Accountants, Government Departments and Business alike. One point data entry and all your books and financial statements are ready according to government norms. It is very configurable.

Topics include 
  • Accounting Concept
  • Company Setups & Configuration
  • Accounts Classification
  • Basic Inventory in Tally.ERP 9
  • Advanced Inventory in Tally.ERP 9
  • Advanced Accounting in Tally.ERP 9
  • Statutory & Taxation
  • Payroll
  • System Administration & Other Utilities
  • Tally & Remote Capabilities
Training Software :  Tally

Certificate Training in CATIA

1 November 2016 - 11:32pm
Course Category:  CAD Classes

Catia V5 is a software used by many engineers. Knowing how to create a design is very useful when you want to prototype a product and eventually send it off to be created. The objective of this course is to walk you through a complete design of Catia V5 software and teach you the fundamental skills for creating Parts, Assemblies, and Drawings. We take an approach of assuming you have no experience with Catia V5 at all, and get you comfortable with the Interface, all of the picks and clicks.

This course will teach you the fundamentals of Catia V5. Understanding such an immense software program such as this will take some time to fully master. This course will teach you the fundamental functions required to model and document a design you may have. The course focuses not only on the individual tools available in Catia V5, but also on the best approach to the use of these tools, so that the design progresses in a logical manner, leading to a robust, effective and efficient design process. Each lesson builds on previously acquired knowledge and skills, often discussing multiple approaches to a given problem. The series of components created by the user is then used to create a final dynamic assembly.

Upon completion of this course, and with sufficient practice, users should experience increased design productivity, improved design process reliability and a more logical approach to the design process.

Topics include 
  • 12-Auto Constraint
  • Adding Part Bodies
  • Advanced Multi Section Solid
  • Advanced Removed Multi Section Solid
  • Angle Constraint
  • Apply Colour
  • Apply Material
  • Apply Transparency
  • Assembly
  • Assembly Intro
  • Basic Multi Section Solid
  • Basic Removed Multi Solid
  • Body Rotation
  • Body Symmetry
  • Body Translation
  • Boolean Add
  • Boolean Add Application
  • Boolean Intersect
  • Boolean Intersect Application
  • Boolean Operations Overview
  • Boolean Remove
  • Boolean Remove Application
  • CATIA V5 Documents
  • Catia V5 Format
  • CATIA V5 Hot Keys
  • Chamfer
  • Chamfer Sketch
  • Circle Profiles
  • Circular Pattern
  • Coating And Plating Calculations
  • Coincidence Constraint
  • Compass Component
  • Compass Component Intro
  • Compass Positioning
  • Compass Rotate Assembly
  • Compass Rotate Part
  • Compass Translate Part
  • Compass Translation Assembly
  • Compass Views
  • Conic Profiles
  • Constraints Vs Positional Assemblies
  • Construction Geometry
  • Contact Constraint
  • Contact Constraint
  • Corner Sketch
  • Create Boolean Bodies
  • Custom View Positions
  • Customize Enviroment
  • Dimension Sketches
  • Draft Angle
  • Draft Reflect Line
  • Drafted Filleted Pad
  • Drafted Filleted Pocket
  • Edge Fillet
  • Explode 
  • Face - Face Fillet
  • Fix Constraint
  • Fix Together
  • Getting Started
  • Groove
  • Guitar Constraint Assembly
  • Guitar Positioning Assembly
  • Hide Show
  • Hole
  • Inserting Components
  • Manipulation
  • Manual Sketch Edit
  • Measure Between
  • Measure Inertia
  • Measure Item
  • Measure Tools Overview
  • Mirror Body
  • Mirror Sketch
  • Mouse Button Hot Keys
  • Multi Pad
  • Multi Pocket
  • Multi View
  • Multiple Multi Section Solid
  • Multiple Removed Multi Section Solid
  • Offset Constraint
  • Offset Sketch
  • Pad
  • Paralell And Perspective View
  • Part Body
  • Part Details
  • Plastic And Forging Calculations
  • Pocket
  • Predifined Profiles
  • Product Tree
  • Profile Sketch
  • Project Edges
  • Rectangular Pattern
  • Reference Planes
  • Render Style
  • Rib
  • Rotate Sketch
  • Save Management
  • Scale Body
  • Scale Sketch
  • Search Function
  • Section Views
  • Shaft
  • Shell
  • Sketch Analysis
  • Sketcher Intro
  • Sketching
  • Slot
  • Snap
  • Solid Combine
  • Solid Modeling
  • Solid Modeling Intro
  • Spline Definition
  • Spline Sketch
  • Split Sketch Entities
  • Stiffener
  • Symmetry Sketch
  • Translate Sketch
  • Trim Extend Sketch
  • Tritangent Fillet
  • Update
  • Utilize Visible Space
  • Variable Angle Draft
  • Variable Raidus Fillet
  • View Positions
  • Visible Space
  • Workbench
Training Software :  CATIA Tags:  CAD 2D Drawing 3D Drawing 3D Modeling