Name: Fatima Yousif

Roll Number: 18SW29

Topic: Java Modelling Language

Task 1:

// Task 1
//  PART (B)
// Write assignable clauses where appropriate. = DONE(An assignable clause
specifies which variables may be modified by a method; all other variables should
remain unchanged)
// • Write class invariants. = DONE
// • Write a loop invariant, decreases clause, and assignable clause for the loop
in method add. = DONE
// • Add JML modifiers (spec_public, pure,...) where necessary. = DONE

public class HashTable {

   
    // Open addressing Hashtable with linear probing as collision resolution.
   
    /*@
    invariant
    (size < capacity)? return && size=size+1 && obj=h[i] :return    
     @*/

    /*@ invariant h.length=size @*/

    public /*@ non_null @*/ Object[] h;

   
    public size;
   
    /*@ invariant capacity >=1 @*/
    public int capacity;
   
    /*@ invariant 0 >= size && size <= capacity; @*/

    /*@ invariant capacity=h.length @*/

    HashTable (int capacity) {

          /*@ assignable h,capacity,size @*/
        h = new Object[capacity];
        this.capacity = capacity;
        size = 0;
    }
       
    public int hash_function (int val) {
   
        int result = 0;
       
        if (val >= 0)
           result = val % capacity;
        else {result = (val * -1) % capacity;}
       
        return result;
    }
       
    public /*@ pure @*/ void add (Object u, int key) {
   
    /*@ assignable size, h[i] @*/
       
        if (size < capacity) {
     
   
        int i = hash_function(key);

        if (h[i] == null) {
            h[i] = u;
            size++;
            return;
            }
        else {      
            int j = 0;

            //LOOP INVARIANT
            /*
            @ loop_invariant
@ \result= (\forall int i; i>=0 && i<\index; i=i+1)
            @ && h[i] != null && \index <capacity;
            @ decreases capacity -\index;
            @ assignable \strictly_nothing
            @*/
           
            while (h[i] != null && j < capacity)
            {
             if (i == capacity-1) i = 0;
             else {i++;}
             
             j++;
            }
           
            h[i] = u;
            size++;
            return;        
          }

        } else {
               return;
               }    
    }  
   
}
Task 2 (a):

// TASK 2  
// modifiers (spec_public,pure) = DONE
// method contracts(pre post conditions) = DONE
// class invariants= DONE
// loop invariants= DONE

public class BinarySearch {

    // class invariants
    /*@ invariant size >=0 && size= numbers.length @*/

    private /*@spec_public non_null @*/  int[] numbers; //array must be sorted

    private /*@spec_public @*/ int size;    

    //contracts (pre+ post conditions)

    /*@
    requires (\forall int i, j; 0 <= i & i < j & j < a.length; a[i] <= a[j]);
    requires query !=null;
    ensures \result== index;
    ensures \result == -1;
     @*/

    private /*@ pure @*/ int search(int query)

    {
        int leftIndex = 0;
        int rightIndex = size;

        //LOOP INVARIANT
            /*
            @maintaining
\result= (\exists int j; 0<=j && j<leftIndex;
numbers [j] <query);
            @maintaining 0 <= leftIndex && leftIndex<= rightIndex;
            @decreasing rightIndex -leftIndex;
            @assignable \strictly_nothing;
            @*/

        while (leftIndex <= rightIndex)

        {
            int index = leftIndex+((rightIndex-leftIndex)/2);
            if (numbers[index] < query)
             {
                 leftIndex = index + 1;
                 }
                 else if (numbers[index] > query)
                 {
                     rightIndex = index -1;
                     }
                     else
                     {  
                         return index;
                         }
                         }
                         return -1;
                         }
                         }
Task 2 (b):
// TASK 3  
// modifiers (spec_public,pure) = DONE
// method contracts (pre post conditions) = DONE
// class invariants= DONE
// loop invariants= No

public class Wallet {

    // class invariants
    /*@
    invariant pin.length= 4;
    invariant balance >=0.
    @*/

    final/*@spec_public @*/ int MAX_BALANCE=100000;

    int /*@spec_public non_null @*/ balance;
    byte [] /*@spec_public non_null @*/ pin; //must contain 4 digits
     
    Wallet (int b, byte[] p)
    {
        balance = b;
        pin = p;
    }

  //contracts (pre+ post conditions)

    /*@
    requires amount>=0;
    ensures balance;
    signals (PurseException e) amount > balance &&
                                              balance == \old(balance) ;
     @*/

    int debit(int amount) throws PurseException

    {
        if(amount <= balance)
        {
            balance -= amount;
            return balance;
        }
        else{
            throw new PurseException("overdrawn by "+amount);
            }
    }
            }