Online railway reservation system use case diagram
MCS032 Solved Assignment

Following are some of the main advantages of Use Case Modeling:

1. The use case diagram provides a comprehensive summary of the whole software system in a single illustration.

2. The use cases are mainly composed of narrative text. Hence, unlike many other modeling techniques, the non technical stake holders (e.g. customers, end users, salesperson etc) are also able understand the model for the software system. This means that feedback can be obtained at a very early stage of the development from the customers and the end users.

3. Another major advantage of use case modeling is that it requires the identification of exceptional scenarios for the use cases. This helps in discovering subtle alternate requirements in the system.

4. The use case model can be utilized in several other aspect of software development as well, e.g. Cost Estimation, Project Planning, Test Case Preparation and User Documentation.

Click below link to see Use Case Diagram

Use case diagram for Online Railway Reservation System.

#include <stdio.h>
#include <conio.h>
#include <alloc.h>

#define MAX1 3
#define MAX2 3
#define MAXSIZE 20

#define TRUE 1
#define FALSE 2

struct sparse
{
    int *sp ;
    int row ;
    int *result ;
} ;

void initsparse ( struct sparse * ) ;
void create_array ( struct sparse * ) ;
int count ( struct sparse ) ;
void display ( struct sparse ) ;
void create_tuple ( struct sparse*, struct sparse ) ;
void display_tuple ( struct sparse ) ;
void prodmat ( struct sparse *, struct sparse, struct sparse ) ;
void searchina ( int *sp, int ii, int*p, int*flag ) ;
void searchinb ( int *sp, int jj, int colofa, int*p, int*flag ) ;
void display_result ( struct sparse ) ;
void delsparse ( struct sparse * ) ;

void main( )
{
    struct sparse s[5] ;
    int i ;

    clrscr( ) ;

    for ( i = 0 ; i <= 3 ; i++ )
        initsparse ( &s[i] ) ;

    create_array ( &s[0] ) ;

    create_tuple ( &s[1], s[0] ) ;
    display_tuple ( s[1] ) ;

    create_array ( &s[2] ) ;

    create_tuple ( &s[3], s[2] ) ;
    display_tuple ( s[3] ) ;

    prodmat ( &s[4], s[1], s[3] ) ;

    printf ( "\nResult of multiplication of two matrices: " ) ;
    display_result ( s[4] ) ;

    for ( i = 0 ; i <= 3 ; i++ )
        delsparse ( &s[i] ) ;

    getch( ) ;
}

/* initialises elements of structure */
void initsparse ( struct sparse *p )
{
    p -> sp = NULL ;
    p -> result = NULL ;
}

/* dynamically creates the matrix */
void create_array ( struct sparse *p )
{
    int n, i ;

    /* allocate memory */

    p -> sp = ( int * ) malloc ( MAX1 * MAX2 * sizeof ( int ) ) ;

    /* add elements to the array */
for ( i = 0 ; i < MAX1 * MAX2 ; i++ )
    {
            printf ( "Enter element no. %d: ", i ) ;
            scanf ( "%d", &n ) ;
            * ( p -> sp + i ) = n ;
    }
}

/* displays the contents of the matrix */
void display ( struct sparse s )
{
    int i ;

    /* traverses the entire matrix */
for ( i = 0 ; i < MAX1 * MAX2 ; i++ )
    {
        /* positions the cursor to the new line for every new row */
if ( i % 3 == 0 )
            printf ( "\n" ) ;
        printf ( "%d\t", * ( s.sp + i ) ) ;
    }
}

/* counts the number of non-zero elements */
int count ( struct sparse s )
{
    int cnt = 0, i ;

    for ( i = 0 ; i < MAX1 * MAX2 ; i++ )
    {
        if ( * ( s.sp + i ) != 0 )
            cnt++ ;
    }
    return cnt ;
}

/* creates an array that stores information about non-zero elements */
void create_tuple ( struct sparse *p, struct sparse s )
{
    int r = 0 , c = -1, l = -1, i ;

    /* get the total number of non-zero elements */

    p -> row = count ( s ) + 1 ;

    /* allocate memory */

    p -> sp = ( int * ) malloc ( p -> row * 3 * sizeof ( int ) ) ;

    /* store information about
      total no. of rows, cols, and non-zero values */

    * ( p -> sp + 0 ) = MAX1 ;
    * ( p -> sp + 1 ) = MAX2 ;
    * ( p -> sp + 2 ) = p -> row - 1 ;

    l = 2 ;

    /* scan the array and store info. about non-zero values
       in the 3-tuple */
for ( i = 0 ; i < MAX1 * MAX2 ; i++ )
    {
        c++ ;

        /* sets the row and column values */
if ( ( ( i % 3 ) == 0 ) && ( i != 0 ) )
        {
            r++ ;
            c = 0 ;
        }

        /* checks for non-zero element,
           row, column and non-zero value
           is assigned to the matrix */
if ( * ( s.sp + i ) != 0 )
        {
            l++ ;
            * ( p -> sp + l ) = r ;
            l++ ;
            * ( p -> sp + l ) = c ;
            l++ ;
            * ( p -> sp + l ) = * ( s.sp + i ) ;
        }
    }
}

/* displays the contents of the matrix */
void display_tuple ( struct sparse s )
{
    int i, j ;

    /* traverses the entire matrix */

    printf ( "\nElements in a 3-tuple: " ) ;

    j = ( * ( s.sp + 2 ) * 3 ) + 3 ;

    for ( i = 0 ; i < j ; i++ )
    {
        /* positions the cursor to the new line for every new row */
if ( i % 3 == 0 )
            printf ( "\n" ) ;
        printf ( "%d\t", * ( s.sp + i ) ) ;
    }
    printf ( "\n" ) ;
}

/* performs multiplication of sparse matrices */
void prodmat ( struct sparse *p, struct sparse a, struct sparse b )
{
    int sum, k, position, posi, flaga, flagb, i , j ;
    k = 1 ;

    p -> result = ( int * ) malloc ( MAXSIZE * 3 * sizeof ( int ) ) ;

    for ( i = 0 ; i < * ( a.sp + 0 * 3 + 0 ) ; i++ )
    {
        for ( j = 0 ; j < * ( b.sp + 0 * 3 + 1 ) ; j++  )
        {
            /* search if an element present at ith row */

            searchina ( a.sp, i, &position, &flaga ) ;
            if ( flaga == TRUE )
            {
                sum = 0 ;

                /* run loop till there are element at ith row
                   in first 3-tuple */
while ( * ( a.sp + position * 3 + 0 ) == i )
                {
                    /* search if an element present at ith col.
                       in second 3-tuple */

                    searchinb ( b.sp, j, * ( a.sp + position * 3 + 1 ),
                            &posi, &flagb ) ;

                    /* if found then multiply */
if ( flagb == TRUE )
                        sum = sum + * ( a.sp + position * 3 + 2 ) *
                                * ( b.sp + posi * 3 + 2 ) ;
                    position = position + 1 ;
                }

                /* add result */
if ( sum != 0 )
                {
                    * ( p -> result + k * 3 + 0 ) = i ;
                    * ( p -> result + k * 3 + 1 ) = j ;
                    * ( p -> result + k * 3 + 2 ) = sum ;
                    k = k + 1 ;
                }
            }
         }
      }

    /* add total no. of rows, cols and non-zero values */

    * ( p -> result + 0 * 3 + 0 ) = * ( a.sp + 0 * 3 + 0 ) ;
    * ( p -> result + 0 * 3 + 1 ) = * ( b.sp + 0 * 3 + 1 ) ;
    * ( p -> result + 0 * 3 + 2 ) = k - 1 ;
}

/* searches if an element present at iith row */
void searchina ( int *sp, int ii, int *p, int *flag )
{
    int j ;
    *flag = FALSE ;
    for ( j = 1 ; j <= * ( sp + 0 * 3 + 2 ) ; j++ )
    {
        if ( * ( sp + j * 3 + 0 ) == ii )
        {
            *p = j ;
            *flag = TRUE ;
            return ;
        }
     }
}

/* searches if an element where col. of first 3-tuple
   is equal to row of second 3-tuple */
void searchinb ( int *sp, int jj, int colofa, int *p, int *flag )
{
     int j ;
     *flag = FALSE ;
     for ( j = 1 ; j <= * ( sp + 0 * 3 + 2 ) ; j++ )
     {
        if ( * ( sp + j * 3 + 1 ) == jj && * ( sp + j * 3 + 0 ) == colofa )
        {
            *p = j ;
            *flag = TRUE ;
            return ;
        }
    }
}

/* displays the contents of the matrix */
void display_result ( struct sparse s )
{
    int i ;

    /* traverses the entire matrix */
for ( i = 0 ; i < ( * ( s.result + 0 + 2 ) + 1 ) * 3 ; i++ )
    {
        /* positions the cursor to the new line for every new row */
if ( i % 3 == 0 )
            printf ( "\n" ) ;
        printf ( "%d\t", * ( s.result + i ) ) ;
    }
}

/* deallocates memory */
void delsparse ( struct sparse *s )
{
    if ( s -> sp != NULL )
        free ( s -> sp ) ;
    if ( s -> result != NULL )
        free ( s -> result ) ;
}

Components of capital Analysis

The capital budgeting process is a measurable way for businesses to determine the long-term economic and financial profitability of any investment project.

Capital budgeting is also vital to a business because it creates a structured step by step process that enables a company to:

1. Develop and formulate long-term strategic goals – the ability to set long-term goals is essential to the growth and prosperity of any business. The ability to appraise/value investment projects via capital budgeting creates a framework for businesses to plan out future long-term direction.
   
2. Seek out new investment projects – knowing how to evaluate investment projects gives a business the model to seek and evaluate new projects, an important function for all businesses as they seek to compete and profit in their industry.
   
3. Estimate and forecast future cash flows – future cash flows are what create value for businesses overtime. Capital budgeting enables executives to take a potential project and estimate its future cash flows, which then helps determine if such a project should be accepted.
   
4. Facilitate the transfer of information – from the time that a project starts off as an idea to the time it is accepted or rejected, numerous decisions have to be made at various levels of authority. The capital budgeting process facilitates the transfer of information to the appropriate decision makers within a company.
   
5. Monitoring and Control of Expenditures – by definition a budget carefully identifies the necessary expenditures and R&D required for an investment project. Since a good project can turn bad if expenditures aren't carefully controlled or monitored, this step is a crucial benefit of the capital budgeting process.
   
6. Creation of Decision – when a capital budgeting process is in place, a company is then able to create a set of decision rules that can categorize which projects are acceptable and which projects are unacceptable. The result is a more efficiently run business that is better equipped to quickly ascertain whether or not to proceed further with a project or shut it down early in the process, thereby saving a company both time and money.

Difference between IRR and NPV Methods

Key differences between the most popular methods, the NPV (Net Present Value) Method and IRR (Internal Rate of Return) Method, include:

• NPV is calculated in terms of currency while IRR is expressed in terms of the percentage return a firm expects the capital project to return;

• Academic evidence suggests that the NPV Method is preferred over other methods since it calculates additional wealth and the IRR Method does not;

• The IRR Method cannot be used to evaluate projects where there are changing cash flows (e.g., an initial outflow followed by in-flows and a later out-flow, such as may be required in the case of land reclamation by a mining firm);

• However, the IRR Method does have one significant advantage — managers tend to better understand the concept of returns stated in percentages and find it easy to compare to the required cost of capital; and, finally,

• While both the NPV Method and the IRR Method are both DCF models and can even reach similar conclusions about a single project, the use of the IRR Method can lead to the belief that a smaller project with a shorter life and earlier cash inflows, is preferable to a larger project that will generate more cash.

• Applying NPV using different discount rates will result in different recommendations. The IRR method always gives the same recommendation.

SCAS will have all necessary fields that are essential for allocation of Study Center to the student without any errors. After Application Form for Admission is submitted, the data in the address field needs to be validated by SCAS. If the data is valid, then SCAS should allocate a Study Center which is offering the Programme in which the student sought admission as well as nearest to the Residence of the student among the available Study Centers. Appropriate e-mail should be sent to student in all cases. Make necessary assumptions.

For developing SCAS as specified above,
(a) Which SDLC paradigm will be selected. Justify your answer.
(b) List the functional and non-functional requirements.
(c) Estimate cost.
(d) Estimate effort.
(e) Develop SRS using IEEE format.

Study Center Allocation System
a)   SDLC Model Selection:

The Waterfall Model

The Waterfall Model of SDLC is an Ideal choice for this SCAS software. Some situations where the use of Waterfall model is most appropriate are:
·         Requirements are very well documented, clear and fixed. [Much Cleared]
·         Product definition is stable. [True]
·         Technology is understood and is not dynamic. [True]
·         There are no ambiguous requirements. [True]
·         Ample resources with required expertise are available to support the product. [True]
·         The project is short. [True]
(By Above clarification we can go with The Waterfall Model)

Advantage

The advantage of waterfall development is that it allows for departmentalization and control. A schedule can be set with deadlines for each stage of development and a product can proceed through the development process model phases one by one.
Development moves from concept, through design, implementation, testing, installation, troubleshooting, and ends up at operation and maintenance. Each phase of development proceeds in strict order.

Disadvantage

The disadvantage of waterfall development is that it does not allow for much reflection or revision. Once an application is in the testing stage, it is very difficult to go back and change something that was not well-documented or thought upon in the concept stage.

b) Requirements Analysis(Click to view)

c,d) Cost & Effort Estimation

Function point

At first, we should pay attention to the functionality - what exactly the system should be able to do. Basically, it should be able to take care about these parts - Students, Study Center, Staff, Seat Allocation, and Notification. Then, let us group functions into five categories:

• External Inputs - Students, Admission, Study Centers, Payments details. There are four things we need to consider.
• External Outputs - Students, Allocation and Notification. There are three things to consider.
• External Inquiries - the system is requested for three things, which are Student, Allocation, and Study Center details.
• External Interface Files – Distance Calculator, one value.
• Internal Logical Files - finally, the four elements belong to the last group. Student, and Allocation files, and Staff, and study center files.

That's all about selecting the components. Unfortunately, it's the most difficult aspect of FPA because of lack of specified rules determining how to distinguish functions. Moreover, it's very easy to forget about a thing or place it in a wrong category. Nonetheless, there is only mathematics left to accomplish the function point’s analysis.

Let's predict every function's complexity is low, so the values can be presented in a table:

Category	Multiplier	Weight
EI	4	3
EO	3	4
EQ	3	3
EIF	1	5
ILF	4	7

4*3+3*4+3*3+1*5+4*7 = 66 [Function Points]

Multiplier	Adjusted Function Point
1	66
1.2	79.2
0.8	52.8

Considering C# for coding language average line of code 40 to 80 and median value is 55

We can consider median value to calculate LOC 66*55 = 3630 Source Line of code

Web Development Productivity = 3.30

KSLOC = 3630/1000 = 3.63

Effort 

Effort = Productivity*KSLOC

Effort = 3.30*3.630

11 Person-Months

Duration 

if  c=2.5 and d=0.36 taking intermediate development 

D = c*E^d

= 2.5*11^0.36
=~ 6 Months


If professional is charging INR 20,000 per month
Then Per month development cost will be 40,000 because we need to 2 professionals
Average Development Cost = 40,000 Person Month

Then Total Cost = E*Average Development Cost
= 40000*11
=4,44,000 INR

e) SRS

Generalization 

Generalization is a mechanism for combining similar classes of objects into a single, more general class. Generalization is a bottom-up process. Generalization and inheritance are powerful abstractions for sharing similarities among classes while preserving their differences.

Some Forms of Generalization

1. Hierarchy: In the case of hierarchy, the commonalities are organized into a tree structured form. At the root of any subtree are found all the attributes and behavior common to all of the descendents of that root.
2. Genericity: In this case, the commonality is expressed with the aid of a parameter. Various specializations are distinguished by what they provide for the parameter. For example, using genericity it is possible to represent the common properties of a "stack" through the generalization of a "stack of anything", where "anything" represents the parameter.
3. Polymorphism: Polymorphism captures commonality in algorithms. Polymorphism allows the nested logic (or case statement) to be collapsed to a single case in which the different object types are treated in a uniform manner.
4. Patterns: A pattern expresses a general solution (the key components and relationships) to a commonly occurring design problem. The attributes and behavior of the individual components are only partially defined to allow the pattern to be interpreted and applied to a wide range of situations.

Inheritance

The generalization/specialization relationship is implemented in object-oriented programming languages with inheritance. Inheritance is the implementation mechanism for the generalization/specialization relationship. In single inheritance a subclass has only one superclass. In multiple inheritance a subclass has two or more superclasses.

One object-oriented concept that helps objects work together is inheritance. Inheritance defines relationships among classes in an object-oriented language. In other words, Inheritance is the mechanism used in object-oriented programming (OOP) languages to permit a subclass to share attributes and operations defined in the superclasses.

For example the subclass Car can share the attributes and operations from the superclass Vehicle. The subclass Car may add attributes and operations.