What is the difference between Two-way Adapter and Pluggable Adapter Pattern in C#?

Both Two-way Adapter and Pluggable Adapter can access both the classes and also change the behavior of the method which is required to be changed, the following is my code

Two-Way Adapter

 public interface IAircraft
    {
        bool Airborne { get; }
        void TakeOff();
        int Height { get; }
    }

    // Target
    public sealed class Aircraft : IAircraft
    {
        int height;
        bool airborne;
        public Aircraft()
        {
            height = 0;
            airborne = false;
        }
        public void TakeOff()
        {
            Console.WriteLine("Aircraft engine takeoff");
            airborne = true;
            height = 200; // Meters
        }
        public bool Airborne
        {
            get { return airborne; }
        }
        public int Height
        {
            get { return height; }
        }
    }
    // Adaptee interface
    public interface ISeacraft
    {
        int Speed { get; }
        void IncreaseRevs();
    }
    // Adaptee implementation
    public class Seacraft : ISeacraft
    {
        int speed = 0;
        public virtual void IncreaseRevs()
        {
            speed += 10;
            Console.WriteLine("Seacraft engine increases revs to " + speed + " knots");
        }
        public int Speed
        {
            get { return speed; }
        }
    }
    // Adapter
    public class Seabird : Seacraft, IAircraft
    {
        int height = 0;
        // A two-way adapter hides and routes the Target's methods
        // Use Seacraft instructions to implement this one
        public void TakeOff()
        {
            while (!Airborne)
                IncreaseRevs();
        }
        // Routes this straight back to the Aircraft
        public int Height
        {
            get { return height; }
        }

        // This method is common to both Target and Adaptee
        public override void IncreaseRevs()
        {
            base.IncreaseRevs();
            if (Speed > 40)
                height += 100;
        }
        public bool Airborne
        {
            get { return height > 50; }
        }
    }
    class Experiment_MakeSeaBirdFly
    {
        static void Main()
        {
            // No adapter
            Console.WriteLine("Experiment 1: test the aircraft engine");
            IAircraft aircraft = new Aircraft();
            aircraft.TakeOff();
            if (aircraft.Airborne) Console.WriteLine(
            "The aircraft engine is fine, flying at "
            + aircraft.Height + "meters");
            // Classic usage of an adapter
            Console.WriteLine("\nExperiment 2: Use the engine in the Seabird");
            IAircraft seabird = new Seabird();
            seabird.TakeOff(); // And automatically increases speed
            Console.WriteLine("The Seabird took off");
            // Two-way adapter: using seacraft instructions on an IAircraft object
            // (where they are not in the IAircraft interface)
            Console.WriteLine("\nExperiment 3: Increase the speed of the Seabird:");
            (seabird as ISeacraft).IncreaseRevs();
            (seabird as ISeacraft).IncreaseRevs();
            if (seabird.Airborne)
                Console.WriteLine("Seabird flying at height " + seabird.Height +
                " meters and speed " + (seabird as ISeacraft).Speed + " knots");
            Console.WriteLine("Experiments successful; the Seabird flies!");

            Console.Read();
        }
    }

Pluggable Pattern

class Adaptee
    {
        public double Precise(double a, double b)
        {
            return a / b;
        }
    }

    // New standard for requests
    class Target
    {
        public string Estimate(int i)
        {
            return "Estimate is " + (int)Math.Round(i / 3.0);
        }
    }    

    // Implementing new requests via old
    class Adapter : Adaptee
    {
        public Func<int, string> Request;    
        // Different constructors for the expected targets/adaptees    
        // Adapter-Adaptee
        public Adapter(Adaptee adaptee)
        {
            // Set the delegate to the new standard
            Request = x =>
            {
                return "Estimate based on precision is " +
               (int)Math.Round(Precise(x, 3));
            };
        }

        // Adapter-Target
        public Adapter(Target target)
        {
            // Set the delegate to the existing standard
            Request = target.Estimate;
        }
    }

    class Client
    {    
        static void Main()
        {    
            Adapter adapter1 = new Adapter(new Adaptee());
            Console.WriteLine(adapter1.Request(5));

            Adapter adapter2 = new Adapter(new Target());
            Console.WriteLine(adapter2.Request(5));    
            Console.Read();

        }
    }

in the above two code i dont find anything different in respect of the patterns functionality. So what is the different between both the patterns, can anyone help me understand it? thank you