undefined | unit 6 logical and functional programming

PPL

Unit-6

Logical and Functional Programming

Q1) What is Functional Programming Paradigm in java?

A1) Functional programming languages are specially designed to handle symbolic computation and list processing applications. Functional programming is based on mathematical functions. Some of the popular functional programming languages include: Lisp, Python, Erlang, Haskell, Clojure, etc.

Functional programming languages are categorized into two groups, i.e. −

Pure Functional Languages− These types of functional languages support only the functional paradigms. For example − Haskell.

Impure Functional Languages− These types of functional languages support the functional paradigms and imperative style programming. For example − LISP.

Functional Programming – Characteristics

The most prominent characteristics of functional programming are as follows −

Functional programming languages are designed on the concept of mathematical functions that use conditional expressions and recursion to perform computation.

Functional programming supports higher-order functions and lazy evaluation features.

Functional programming languages don’t support flow Controls like loop statements and conditional statements like If-Else and Switch Statements. They directly use the functions and functional calls.

Like OOP, functional programming languages support popular concepts such as Abstraction, Encapsulation, Inheritance, and Polymorphism.

Functional Programming – Advantages

Functional programming offers the following advantages −

Bugs-Free Code− Functional programming does not support state, so there are no side-effect results and we can write error-free codes.

Efficient Parallel Programming− Functional programming languages have NO Mutable state, so there are no state-change issues. One can program "Functions" to work parallel as "instructions". Such codes support easy reusability and testability.

Efficiency− Functional programs consist of independent units that can run concurrently. As a result, such programs are more efficient.

Supports Nested Functions− Functional programming supports Nested Functions.

Lazy Evaluation− Functional programming supports Lazy Functional Constructs like Lazy Lists, Lazy Maps, etc.

As a downside, functional programming requires a large memory space. As it does not have state, you need to create new objects every time to perform actions.

Functional Programming is used in situations where we have to perform lots of different operations on the same set of data.

Lisp is used for artificial intelligence applications like Machine learning, language processing, Modeling of speech and vision, etc.

Embedded Lisp interpreters add programmability to some systems like Emacs.

Q2) What is Functional Programming vs. Object-oriented Programming in java?

A2) Functional Programming vs. Object-oriented Programming

The following table highlights the major differences between functional programming and object-oriented programming −

Functional Programming	OOP
Uses Immutable data.	Uses Mutable data.
Follows Declarative Programming Model.	Follows Imperative Programming Model.
Focus is on: “What you are doing”	Focus is on “How you are doing”
Supports Parallel Programming	Not suitable for Parallel Programming
Its functions have no-side effects	Its methods can produce serious side effects.
Flow Control is done using function calls & function calls with recursion	Flow control is done using loops and conditional statements.
It uses "Recursion" concept to iterate Collection Data.	It uses "Loop" concept to iterate Collection Data. For example: For-each loop in Java
Execution order of statements is not so important.	Execution order of statements is very important.
Supports both "Abstraction over Data" and "Abstraction over Behavior".	Supports only "Abstraction over Data".

Q3) Explain efficiency of a program code

A3) Efficiency of a Program Code

The efficiency of a programming code is directly proportional to the algorithmic efficiency and the execution speed. Good efficiency ensures higher performance.

The factors that affect the efficiency of a program includes −

The speed of the machine

Compiler speed

Operating system

Choosing right Programming language

The way of data in a program is organized

Algorithm used to solve the problem

The efficiency of a programming language can be improved by performing the following tasks −

By removing unnecessary code or the code that goes to redundant processing.

By making use of optimal memory and nonvolatile storage

By making the use of reusable components wherever applicable.

By making the use of error & exception handling at all layers of program.

By creating programming code that ensures data integrity and consistency.

By developing the program code that's compliant with the design logic and flow.

An efficient programming code can reduce resource consumption and completion time as much as possible with minimum risk to the operating environment.

Q4) Explain in short LISP

A4) LISP - Overview

John McCarthy invented LISP in 1958, shortly after the development of FORTRAN. It was first implemented by Steve Russell on an IBM 704 computer.

It is particularly suitable for Artificial Intelligence programs, as it processes symbolic information effectively.

Common Lisp originated, during the 1980s and 1990s, in an attempt to unify the work of several implementation groups that were successors to Maclisp, like ZetaLisp and NIL (New Implementation of Lisp) etc.

It serves as a common language, which can be easily extended for specific implementation.

Programs written in Common LISP do not depend on machine-specific characteristics, such as word length etc.

Features of Common LISP

It is machine-independent

It uses iterative design methodology, and easy extensibility.

It allows updating the programs dynamically.

It provides high level debugging.

It provides advanced object-oriented programming.

It provides a convenient macro system.

It provides wide-ranging data types like, objects, structures, lists, vectors, adjustable arrays, hash-tables, and symbols.

It is expression-based.

It provides an object-oriented condition system.

It provides a complete I/O library.

It provides extensive control structures.

Applications Built in LISP

Large successful applications built in Lisp.

Emacs

AutoCad

Igor Engraver

Yahoo Store

Q5) Explain LISP Decision making

A5) LISP - Decision Making

Decision making structures require that the programmer specify one or more conditions to be evaluated or tested by the program, along with a statement or statements to be executed if the condition is determined to be true, and optionally, other statements to be executed if the condition is determined to be false.

Following is the general form of a typical decision making structure found in most of the programming languages −

Decision Making

LISP provides following types of decision making constructs. Click the following links to check their detail.

Sr.No.	Construct & Description
1	Cond This construct is used for used for checking multiple test-action clauses. It can be compared to the nested if statements in other programming languages.
2	if The if construct has various forms. In simplest form it is followed by a test clause, a test action and some other consequent action(s). If the test clause evaluates to true, then the test action is executed otherwise, the consequent clause is evaluated.
3	when In simplest form it is followed by a test clause, and a test action. If the test clause evaluates to true, then the test action is executed otherwise, the consequent clause is evaluated.
4	Case This construct implements multiple test-action clauses like the cond construct. However, it evaluates a key form and allows multiple action clauses based on the evaluation of that key form.

Q6) Explain LISP Loops

A6) LISP - Loops

There may be a situation, when you need to execute a block of code numbers of times. A loop statement allows us to execute a statement or group of statements multiple times and following is the general form of a loop statement in most of the programming languages.

Loops

LISP provides the following types of constructs to handle looping requirements. Click the following links to check their detail.

Sr.No.	Construct & Description
1	Loop The loop construct is the simplest form of iteration provided by LISP. In its simplest form, it allows you to execute some statement(s) repeatedly until it finds a return statement.
2	loop for The loop for construct allows you to implement a for-loop like iteration as most common in other languages.
3	Do The do construct is also used for performing iteration using LISP. It provides a structured form of iteration.
4	dotimes The dotimes construct allows looping for some fixed number of iterations.
5	dolist The dolist construct allows iteration through each element of a list.

Gracefully Exiting From a Block

The block and return-from allows you to exit gracefully from any nested blocks in case of any error.

The block function allows you to create a named block with a body composed of zero or more statements. Syntax is −

(block block-name(

...

))

The return-from function takes a block name and an optional (the default is nil) return value.

The following example demonstrates this −

Example

Create a new source code file named main.lisp and type the following code in it −

(defun demo-function(flag)

(print'entering-outer-block)

(block outer-block

(print 'entering-inner-block)

(print(block inner-block

(if flag

(return-from outer-block 3)

(return-from inner-block 5)

)

(print'This-wil--not-be-printed))

)

(print 'left-inner-block)

(print'leaving-outer-block)

)

(demo-function t)

(terpri)

(demo-function nil)

When you click the Execute button, or type Ctrl+E, LISP executes it immediately and the result returned is −

ENTERING-OUTER-BLOCK

ENTERING-INNER-BLOCK

ENTERING-OUTER-BLOCK

ENTERING-INNER-BLOCK

LEFT-INNER-BLOCK

LEAVING-OUTER-BLOCK

Q7) Write an Example to define and call a function that would calculate the area of a circle when the radius of the circle is given as an argument.

A7) Let's define and call a function that would calculate the area of a circle when the radius of the circle is given as an argument.

Create a new source code file named main.lisp and type the following code in it.

(defun area-circle(rad)

"Calculates area of a circle with given radius"

(terpri)

(format t "Radius: ~5f" rad)

(format t "~%Area: ~10f"(*3.141592 rad rad))

)

(area-circle 10)

When you execute the code, it returns the following result −

Radius: 10.0

Area: 314.1592

Please note that −

You can provide an empty list as parameters, which means the function takes no arguments, the list is empty, written as ().

LISP also allows optional, multiple, and keyword arguments.

The documentation string describes the purpose of the function. It is associated with the name of the function and can be obtained using the documentation function.

The body of the function may consist of any number of Lisp expressions.

The value of the last expression in the body is returned as the value of the function.

You can also return a value from the function using the return-from special operator.

Q8) Explain LISP Predicates in java

A8) LISP - Predicates

Predicates are functions that test their arguments for some specific conditions and returns nil if the condition is false, or some non-nil value is the condition is true.

The following table shows some of the most commonly used predicates −

Sr.No.	Predicate & Description
1	Atom It takes one argument and returns t if the argument is an atom or nil if otherwise.
2	Equal It takes two arguments and returns t if they are structurally equal or nil otherwise.
3	Eq It takes two arguments and returns t if they are same identical objects, sharing the same memory location or nil otherwise.
4	Eql It takes two arguments and returns t if the arguments are eq, or if they are numbers of the same type with the same value, or if they are character objects that represent the same character, or nil otherwise.
5	Evenp It takes one numeric argument and returns t if the argument is even number or nil if otherwise.
6	Oddp It takes one numeric argument and returns t if the argument is odd number or nil if otherwise.
7	Zerop It takes one numeric argument and returns t if the argument is zero or nil if otherwise.
8	Null It takes one argument and returns t if the argument evaluates to nil, otherwise it returns nil.
9	Listp It takes one argument and returns t if the argument evaluates to a list otherwise it returns nil.
10	Greaterp It takes one or more argument and returns t if either there is a single argument or the arguments are successively larger from left to right, or nil if otherwise.
11	Lessp It takes one or more argument and returns t if either there is a single argument or the arguments are successively smaller from left to right, or nil if otherwise.
12	Numberp It takes one argument and returns t if the argument is a number or nil if otherwise.
13	Symbol It takes one argument and returns t if the argument is a symbol otherwise it returns nil.
14	Integer It takes one argument and returns t if the argument is an integer otherwise it returns nil.
15	Rationalp It takes one argument and returns t if the argument is rational number, either a ratio or a number, otherwise it returns nil.
16	Floatp It takes one argument and returns t if the argument is a floating point number otherwise it returns nil.
17	Realp It takes one argument and returns t if the argument is a real number otherwise it returns nil.
18	Complex It takes one argument and returns t if the argument is a complex number otherwise it returns nil.
19	Character It takes one argument and returns t if the argument is a character otherwise it returns nil.
20	Stringp It takes one argument and returns t if the argument is a string object otherwise it returns nil.
21	Arrayp It takes one argument and returns t if the argument is an array object otherwise it returns nil.
22	Packagep It takes one argument and returns t if the argument is a package otherwise it returns nil.

Q9) Write an example to create a new source code file named main.lisp

A9) (write (atom 'abcd))

(terpri)

(write (equal 'a 'b))

(terpri)

(write (evenp 10))

(terpri)

(write (evenp7 ))

(terpri)

(write (oddp7 ))

(terpri)

(write (zerop 0.0000000001))

(terpri)

(write (eq 3 3.0 ))

(terpri)

(write (equal 3 3.0 ))

(terpri)

(write (null nil ))

When you execute the code, it returns the following result −

NIL

Q10) What is Recursion and iteration in java?

A10) The Recursion and Iteration both repeatedly execute the set of instructions. Recursion is when a statement in a function calls itself repeatedly. The iteration is when a loop repeatedly executes until the controlling condition becomes false. The primary difference between recursion and iteration is that recursion is a process, always applied to a function and iteration is applied to the set of instructions which we want to get repeatedly executed.

Recursion

Recursion uses selection structure.

Infinite recursion occurs if the recursion step does not reduce the problem in a manner that converges on some condition (base case) and Infinite recursion can crash the system.

Recursion terminates when a base case is recognized.

Recursion is usually slower than iteration due to the overhead of maintaining the stack.

Recursion uses more memory than iteration.

Recursion makes the code smaller.

Example

public class RecursionExample {

public static void main(String args[]) {

RecursionExample re = new RecursionExample();

int result = re.factorial(4);

System.out.println("Result:" + result);

}

public int factorial(int n) {

if (n==0) {

return 1;

}

else {

return n*factorial(n-1);

}

Output

Result:24

Iteration

Iteration uses repetition structure.

An infinite loop occurs with iteration if the loop condition test never becomes false and Infinite looping uses CPU cycles repeatedly.

An iteration terminates when the loop condition fails.

An iteration does not use the stack so it's faster than recursion.

Iteration consumes less memory.

Iteration makes the code longer.

Example

public class IterationExample {

public static void main(String args[]) {

for(int i = 1; i <= 5; i++) {

System.out.println(i + " ");

}

Output

Sign Up