PVector[] vels = { 
                
 new PVector(1, -1), 
                
 new PVector(-2, 2) 
                
};
               

then you could invert it by using a turnery operator like this to get the opposite value: 

               

                
 vels[i].y = (vels[i].y < 0 ? -vels[i].y : vels[i].y);
               
               

                here is a good example of using boundaries: http://processing.org/learning/topics/circlecollision.html
               

Thank you very much for the response.

I have pasted bellow the source code and please point me how to change the code, when Boid reach to the border and change its vector to opposite.

2. // The Boid class
3. 
   
4. class Boid {
5. 
   
6.   PVector loc;
7.   PVector vel;
8.   PVector acc;
9.   float r; // dimensione boid nel testo originale
10.   float scala; // scala dimensione rondine
11.   float maxforce;    // Maximum steering force
12.   float maxspeed;    // Maximum speed
13. 
    
14.     Boid(PVector l, float ms, float mf, float sc) {
15.     acc = new PVector(0, 0);
16.     vel = new PVector(random(-1, 1), random(-1, 1));
17.     loc = l.get();
18.     r = 20.0;
19.     maxspeed = ms;
20.     maxforce = mf;
21.     scala = sc; // dimensione rondini
22.   }
23. 
    
24.   void run(ArrayList boids) {
25.     flock(boids);
26.     update();
27.     borders();
28.     render();
29.   }
30. 
    
31.   // We accumulate a new acceleration each time based on three rules
32.   void flock(ArrayList boids) {
33.     PVector sep = separate(boids);   // Separation
34.     PVector ali = align(boids);      // Alignment
35.     PVector coh = cohesion(boids);   // Cohesion
36.     // Arbitrarily weight these forces
37.     sep.mult(1.5);
38.     ali.mult(1.0);
39.     coh.mult(1.0);
40.     // Add the force vectors to acceleration
41.     acc.add(sep);
42.     acc.add(ali);
43.     acc.add(coh);
44.   }
45. 
    
46.   // Method to update location
47.   void update() {
48.     // Update velocity
49.     vel.add(acc);
50.     // Limit speed
51.     vel.limit(maxspeed);
52.     loc.add(vel);
53.     // Reset accelertion to 0 each cycle
54.     acc.mult(0);
55.   }
56. 
    
57.   void seek(PVector target) {
58.     acc.add(steer(target, false));
59.   }
60. 
    
61.   void arrive(PVector target) {
62.     acc.add(steer(target, true));
63.   }
64. 
    
65.   // A method that calculates a steering vector towards a target
66.   // Takes a second argument, if true, it slows down as it approaches the target
67.   PVector steer(PVector target, boolean slowdown) {
68.     PVector steer;  // The steering vector
69.     PVector desired = target.sub(target, loc);  // A vector pointing from the location to the target
70.     float d = desired.mag(); // Distance from the target is the magnitude of the vector
71.     // If the distance is greater than 0, calc steering (otherwise return zero vector)
72.     if (d > 0) {
73.       // Normalize desired
74.       desired.normalize();
75.       // Two options for desired vector magnitude (1 -- based on distance, 2 -- maxspeed)
76.       if ((slowdown) && (d < 100.0)) desired.mult(maxspeed*(d/100.0)); // This damping is somewhat arbitrary
77.       else desired.mult(maxspeed);
78.       // Steering = Desired minus Velocity
79.       steer = target.sub(desired, vel);
80.       steer.limit(maxforce);  // Limit to maximum steering force
81.     } 
82.     else {
83.       steer = new PVector(0, 0);
84.     }
85.     return steer;
86.   }
87. 
    
88.   void render() {
89.     // Draw a triangle rotated in the direction of velocity
90.     float theta = vel.heading2D() + PI/2;
91.     fill(120, 200);
92.     noStroke();
93.     pushMatrix();
94.     translate(loc.x, loc.y);
95.     rotate(theta);
96.     
97.   scale(scala); // dimensione boid
98.   shapeMode(CENTER);
99.   beginShape();
100.   vertex(-18, 10);
101.   bezierVertex(-15, -6, 15, -6, 18, 10);
102.   bezierVertex(6, -2, -2, 8, -3, 25);
103.   bezierVertex(0, 0, 0, 0, 3, 25);
104.   bezierVertex(2, 8, -6, -2, -18, 10);
105.   endShape();
106. 
     
107.   popMatrix();
108. }
109. 
     
110. 
     
111. // Wraparound
112. void borders() {
113.   if (loc.x < -r) loc.x = width+r;
114.   if (loc.y < -r) loc.y = height+r;
115.   if (loc.x > width+r) loc.x = -r;
116.   if (loc.y > height+r) loc.y = -r;
117. }
118. 
     
119. // Separation
120. // Method checks for nearby boids and steers away
121. PVector separate (ArrayList boids) {
122.   float desiredseparation = 20.0;
123.   PVector steer = new PVector(0, 0, 0);
124.   int count = 0;
125.   // For every boid in the system, check if it's too close
126.   for (int i = 0 ; i < boids.size(); i++) {
127.     Boid other = (Boid) boids.get(i);
128.     float d = PVector.dist(loc, other.loc);
129.     // If the distance is greater than 0 and less than an arbitrary amount (0 when you are yourself)
130.     if ((d > 0) && (d < desiredseparation)) {
131.       // Calculate vector pointing away from neighbor
132.       PVector diff = PVector.sub(loc, other.loc);
133.       diff.normalize();
134.       diff.div(d);        // Weight by distance
135.       steer.add(diff);
136.       count++;            // Keep track of how many
137.     }
138.   }
139.   // Average -- divide by how many
140.   if (count > 0) {
141.     steer.div((float)count);
142.   }
143. 
     
144.   // As long as the vector is greater than 0
145.   if (steer.mag() > 0) {
146.     // Implement Reynolds: Steering = Desired - Velocity
147.     steer.normalize();
148.     steer.mult(maxspeed);
149.     steer.sub(vel);
150.     steer.limit(maxforce);
151.   }
152.   return steer;
153. }
154. 
     
155. // Alignment
156. // For every nearby boid in the system, calculate the average velocity
157. PVector align (ArrayList boids) {
158.   float neighbordist = 25.0;
159.   PVector steer = new PVector(0, 0, 0);
160.   int count = 0;
161.   for (int i = 0 ; i < boids.size(); i++) {
162.     Boid other = (Boid) boids.get(i);
163.     float d = PVector.dist(loc, other.loc);
164.     if ((d > 0) && (d < neighbordist)) {
165.       steer.add(other.vel);
166.       count++;
167.     }
168.   }
169.   if (count > 0) {
170.     steer.div((float)count);
171.   }
172. 
     
173.   // As long as the vector is greater than 0
174.   if (steer.mag() > 0) {
175.     // Implement Reynolds: Steering = Desired - Velocity
176.     steer.normalize();
177.     steer.mult(maxspeed);
178.     steer.sub(vel);
179.     steer.limit(maxforce);
180.   }
181.   return steer;
182. }
183. 
     
184. // Cohesion
185. // For the average location (i.e. center) of all nearby boids, calculate steering vector towards that location
186. PVector cohesion (ArrayList boids) {
187.   float neighbordist = 25.0;
188.   PVector sum = new PVector(0, 0);   // Start with empty vector to accumulate all locations
189.   int count = 0;
190.   for (int i = 0 ; i < boids.size(); i++) {
191.     Boid other = (Boid) boids.get(i);
192.     float d = loc.dist(other.loc);
193.     if ((d > 0) && (d < neighbordist)) {
194.       sum.add(other.loc); // Add location
195.       count++;
196.     }
197.   }
198.   if (count > 0) {
199.     sum.div((float)count);
200.     return steer(sum, false);  // Steer towards the location
201.   }
202.   return sum;
203. }
204. }

Thank you very much for both of your idea, I could overcome the issue by your advises, Now I want to change the vector to a some angle (45 degree),  Since there is a overlapping the neighbor bound and ui bound and Boid are acting abnormlly. Can you please tell me how can we change the vecor to a some direction not totally opposite ?