Installing Open CV in windows

Download the Numpy version corresponding to your Python installation from here. In my case, I’ve used numpy-1.12.0+mkl-cp36-cp36m-win32.whl

Download the OpenCV version corresponding to your Python installation from here. In my case, I’ve used opencv_python-3.2.0-cp36-cp36m-win32.whl.

Now, open a cmd window like before. You can open this directly in your Downloads folder if you SHIFT and right click inside it. The idea is to open a cmd window where you’ve downloaded the above two files. Use the next set of commands to install NumPy and OpenCV:

1  pip install numpy-1.12.0+mkl-cp36-cp36m-win32.whl

and

1  pip install opencv_python-3.2.0-cp36-cp36m-win32.whl

Read More»

Smart Toll System (For Regnum Group)

Smart Toll System

Feature:

• Auto weight measurement .
• Auto traffic controller .  
• RFID Technology included .
• Money Receiver Booth .
• All information saved in Database.
• Auto Email Service .
• Interface with C#.net

Read More»

Customize Terminal for Linux (Written in C language )

#include <stdlib.h>

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>

void parseCmd(char* cmd, char** params);
int executeCmd(char** params);

#define MAX_COMMAND_LENGTH 100
#define MAX_NUMBER_OF_PARAMS 10

int main()
{
    char cmd[MAX_COMMAND_LENGTH + 1];
    char* params[MAX_NUMBER_OF_PARAMS + 1];

    int cmdCount = 0;

    while(1) {
        // Print command prompt
        char* username = getenv("USER");
        printf("%s@shell %d> ", username, ++cmdCount);

        // Read command from standard input, exit on Ctrl+D
        if(fgets(cmd, sizeof(cmd), stdin) == NULL) break;

        // Remove trailing newline character, if any
        if(cmd[strlen(cmd)-1] == '\n') {
            cmd[strlen(cmd)-1] = '\0';
        }

        // Split cmd into array of parameters
        parseCmd(cmd, params);

        // Exit?
        if(strcmp(params[0], "exit") == 0) break;

        // Execute command
        if(executeCmd(params) == 0) break;
    }

    return 0;
}

// Split cmd into array of parameters
void parseCmd(char* cmd, char** params)
{   int i=0;
    for(i = 0; i < MAX_NUMBER_OF_PARAMS; i++) {
        params[i] = strsep(&cmd, " ");
        if(params[i] == NULL) break;
    }
}

int executeCmd(char** params)
{
    // Fork process
    pid_t pid = fork();

    // Error
    if (pid == -1) {
        char* error = strerror(errno);
        printf("fork: %s\n", error);
        return 1;
    }

    // Child process
    else if (pid == 0) {
        // Execute command
        execvp(params[0], params);  

        // Error occurred
        char* error = strerror(errno);
        printf("shell: %s: %s\n", params[0], error);
        return 0;
    }

    // Parent process
    else {
        // Wait for child process to finish
        int childStatus;
        waitpid(pid, &childStatus, 0);
        return 1;
    }
}

Read More»

10424 Love Calculator

10424 Love Calculator

#include<bits/stdc++.h>
using namespace std;


int main()
{

    string a,b;
    while(getline(cin,a))
    {

        getline(cin,b);
        float rat;
        long s1=0,s2=0;
        for(int i=0;i<a.length();i++)
        {
            char t=tolower(a[i]);
            //cout<<t;

            if(t>='a'&&t<='z')
            {
                s1+=t-'a'+1;

            }



        }
        if(s1%9==0) s1=9;
        else s1%=9;

        for(int i=0;i<b.length();i++)
        {
            char t=tolower(b[i]);
            //cout<<t;

            if(t>='a'&&t<='z')
            {
                s2+=t-'a'+1;

            }



        }
        if(s2%9==0) s2=9;
        else s2%=9;


        if(s1>s2)
            rat=((float)s2/s1)*100.0;
        else
            rat=((float)s1/s2)*100;
        printf("%.2lf %c\n",rat,'%');


    }



    return 0;
}

Read More»

A solution to the Readers/Writers Problem using semaphores

Introduction

The readers/writers problem is one of the classic synchronization problems. Like the dining philosophers, it is often used to compare and contrast synchronization mechanisms. It is also an eminently practical problem.

Readers/Writers Problem - Classic definition

Two kinds of processes -- readers and writers -- share a database. Readers execute transactions that examine database records; writer transactions both examine and update the database. The database is assumed initially to be in a consistent state (i.e., one in which relations between data are meaningful). Each transaction, if executed in isolation, transforms the database from one consistent state to another. To preclude interference between transactions, a writer process must have exclusive access to the database. Assuming no writer is accessing the database, any number of readers may concurrently execute transactions.

Some time ago at work, we had to implement a server that relays and translates his incoming datafeed to multiple (typically > 32) clients. As this datafeed represents the continuously (but on a non-regular time base) changing (stock/option) market prices, fast relaying is crucial. We developed a solution that consists of one receiving thread, multiple translator threads, and even more sending threads (since we do not want to block the server if a client fails to receive).

Obviously, all the threads need access to the received and / or translated packet. To achieve this without corrupting data, synchronization is necessary. Searching the MSDN, resulted in finding several synchronization objects (CCriticalSection, CMutex, etc.) of which none seem to fulfill our demands: Multiple read-access when not writing. We thus decided to write the desired synchronization object ourselves: CMutexRW.

Formal readers and writers solution using semaphores

Since our problem has extensively been studied (since 1960?) we first turned to some old college-books on parallel formal semantics to refresh our knowledge about the problem. Soon we found the pages describing the readers and writers problem and (several) solution outlines. We chose to implement our solution (with readers preference) using semaphores.

First some quick (probably skipable) refresh course to (formal) semaphores: Semaphores where first introduced by Dijkstra in 1968, who thought it to be an useful tool for implementing mutual exclusion and for signalling the occurrence of events such as interrupts. A semaphore is an instance of an abstract data type: it has a representation that is manipulated only by two special operations, P and V. Because Dijkstra is Dutch, the P andV stand for Dutch words. In particular, P is the first letter of the Dutch word passeren, which means `to pass'; V is the first letter of vrijgeven, which means `to release'. The V operation signals the occurrence of an event; the Poperation is used to delay a process until an event has occurred. In particular, the two operations must be implemented so that they preserve the following property for every semaphore in a program.

N/B: the description is copy and paste......

NetBans Project

Read More»

Dining philosophers problem with GUI in JAVA

Problem statement

Illustration of the dining philosophers problem.

Five silent philosophers sit at a round table with bowls of spaghetti. Forks are placed between each pair of adjacent philosophers.

Each philosopher must alternately think and eat. However, a philosopher can only eat spaghetti when he has both left and right forks. Each fork can be held by only one philosopher and so a philosopher can use the fork only if it is not being used by another philosopher. After he finishes eating, he needs to put down both forks so they become available to others. A philosopher can take the fork on his right or the one on his left as they become available, but cannot start eating before getting both of them.

Eating is not limited by the remaining amounts of spaghetti or stomach space; an infinite supply and an infinite demand are assumed.

The problem is how to design a discipline of behavior (a concurrent algorithm) such that no philosopher will starve; i.e., each can forever continue to alternate between eating and thinking, assuming that no philosopher can know when others may want to eat or think.

Problems

The problem was designed to illustrate the challenges of avoiding deadlock, a system state in which no progress is possible. To see that a proper solution to this problem is not obvious, consider a proposal in which each philosopher is instructed to behave as follows:

• think until the left fork is available; when it is, pick it up;
• think until the right fork is available; when it is, pick it up;
• when both forks are held, eat for a fixed amount of time;
• then, put the right fork down;
• then, put the left fork down;
• repeat from the beginning.

This attempted solution fails because it allows the system to reach a deadlock state, in which no progress is possible. This is a state in which each philosopher has picked up the fork to the left, and is waiting for the fork to the right to become available. With the given instructions, this state can be reached, and when it is reached, the philosophers will eternally wait for each other to release a fork.^[4]

Resource starvation might also occur independently of deadlock if a particular philosopher is unable to acquire both forks because of a timing problem. For example there might be a rule that the philosophers put down a fork after waiting ten minutes for the other fork to become available and wait a further ten minutes before making their next attempt. This scheme eliminates the possibility of deadlock (the system can always advance to a different state) but still suffers from the problem of livelock. If all five philosophers appear in the dining room at exactly the same time and each picks up the left fork at the same time the philosophers will wait ten minutes until they all put their forks down and then wait a further ten minutes before they all pick them up again.

Mutual exclusion is the basic idea of the problem; the dining philosophers create a generic and abstract scenario useful for explaining issues of this type. The failures these philosophers may experience are analogous to the difficulties that arise in real computer programming when multiple programs need exclusive access to shared resources. These issues are studied in the branch of concurrent programming. The original problems of Dijkstra were related to external devices like tape drives. However, the difficulties exemplified by the dining philosophers problem arise far more often when multiple processes access sets of data that are being updated. Systems such as operating system kernels use thousands of locks and synchronizations that require strict adherence to methods and protocols if such problems as deadlock, starvation, or data corruption are to be avoided.

Solutions

Resource hierarchy solution

This solution to the problem is the one originally proposed by Dijkstra. It assigns a partial order to the resources (the forks, in this case), and establishing the convention that all resources will be requested in order, and that no two resources unrelated by order will ever be used by a single unit of work at the same time. Here, the resources (forks) will be numbered 1 through 5 and each unit of work (philosopher) will always pick up the lower-numbered fork first, and then the higher-numbered fork, from among the two forks he plans to use. The order in which each philosopher puts down the forks does not matter. In this case, if four of the five philosophers simultaneously pick up their lower-numbered fork, only the highest numbered fork will remain on the table, so the fifth philosopher will not be able to pick up any fork. Moreover, only one philosopher will have access to that highest-numbered fork, so he will be able to eat using two forks.

While the resource hierarchy solution avoids deadlocks, it is not always practical, especially when the list of required resources is not completely known in advance. For example, if a unit of work holds resources 3 and 5 and then determines it needs resource 2, it must release 5, then 3 before acquiring 2, and then it must re-acquire 3 and 5 in that order. Computer programs that access large numbers of database records would not run efficiently if they were required to release all higher-numbered records before accessing a new record, making the method impractical for that purpose.

NetBeans  Project

Read More»

SJF Sheduling

#include<bits/stdc++.h>


using namespace std;
struct process
{
    int pid;
    int at;
    int bt;
    int wt;
    bool flag;


};
bool cmp(process a, process b)
{
    return a.bt<b.bt;
}
bool cmp2(process a, process b)
{
    return a.at<b.at;
}
int main()
{
    queue<int>q;
    freopen ("sjfs.txt","r",stdin);
    //freopen ("fcfsout.txt","w",stdout);
    int n;
    vector<process>v;
    cin >> n;
    for (int i = 0; i<n; i++)
    {
        process temp;
        temp.pid = i;
        temp.flag = false;
        cin >> temp.at >> temp.bt;
        v.push_back(temp);

    }
    int time = 0;
    int idl = 0;
    int cou = 0, x = 0;
    sort(v.begin(), v.end(), cmp);

    vector<process>ans;
    while (cou < n)
    {
        vector<process>tem;
        for (int i = 0; i<n; i++)
        {
            if (v[i].at <= time&&!v[i].flag)
            {
                //cout<<v[i]<<endl;
                v[i].flag = true;
                tem.push_back(v[i]);
                break;


            }

        }


        if (tem.size() == 0)
        {
            idl++;
            time++;

        }
        else
        {
            tem[0].wt = time - tem[0].at;
            time += tem[0].bt;
            ans.push_back(tem[0]);
            cou++;

        }

    }
    double totalWt=0;
    for (int i = 0; i<ans.size(); i++)
    {
        totalWt+=ans[i].wt;


    }
    cout<<"\nProcess ID == Arival Time == Wait Time\n\n";
    for(int i=0;i<n;i++)
    {
        cout<<ans[i].pid<<"\t\t"<<ans[i].at<<"\t\t"<<ans[i].wt<<endl;
    }
    cout<<"\nAvg wait Time= "<<totalWt/(double)n<<endl;
    cout<<"Cpu Utilizatimon= "<<(double)((double)(time-idl)/(double)time)*100<<"\%"<<endl;

    //cout<<time<<endl;

    return 0;
}

Read More»