the reflection takes place on a line called tangente and it's 90° vertical to the radius lying on the circle.

depending from the angle the radius points, the tangente also has a different angle or position

thus you need to caculate your new xSpeed and y Speed as :

calculate an angle A from xSpeed and y Speed as the direction in that your ball flights 

now mirror your angle A at the line "radius" (from your current ball point to the center) and thus get angle B

calculate newxSpeed and newySpeed from angle B

see
http://en.wikipedia.org/wiki/Reflection_%28physics%29


Greetings, Chrisir

maybe you can see xSpeed and ySpeed as vectors and also x,y and this
get the angle from there.

There are cool methods for vectors.

See PVectors.

I haven't been able to do it yet

It also works in 3D (with a sphere instead of a circle)...

Code Example

1. import processing.opengl.*;
2.  
3. PVector origin = new PVector();
4. ArrayList <Particle> particles = new ArrayList <Particle> ();
5. int numParticles = 250;
6. int radius = 150;
7.  
8. void setup() {
9.   size(500, 500, OPENGL);
10.   smooth();
11.   for (int i=0; i<numParticles; i++) {
12.     particles.add(new Particle());
13.   }
14. }
15.  
16. void draw () {
17.   background(255);
18.   translate(width/2, height/2);
19.   rotateX(frameCount*0.01);
20.   rotateY(frameCount*0.005);
21.   strokeWeight(1);
22.   stroke(0, 125);
23.   noFill();
24.   sphere(radius);
25.   for (Particle p : particles) {
26.     p.update();
27.     p.display();
28.   }
29. }
30.  
31. class Particle {
32.   PVector loc, vel;
33.   color c;
34.  
35.   Particle() {
36.     loc = new PVector(random(-width/2, width/2), random(-height/2, height/2), random(-width/2, width/2));
37.     loc.limit(radius-50);
38.     vel = new PVector(random(-1, 1), random(-1,1), random(-1,1));
39.     vel.normalize();
40.     vel.mult(random(1,4));
41.     c = color(random(255), random(255), random(255));
42.   }
43.  
44.   void update() {
45.     loc.add(vel);
46.     if (loc.dist(origin) > radius) {
47.       PVector n = loc.get();
48.       n.normalize();
49.       n.mult(2*n.dot(vel));
50.       vel.sub(n);
51.     }
52.   }
53.  
54.   void display() {
55.     stroke(c);
56.     strokeWeight(5);
57.     point(loc.x, loc.y, loc.z);
58.   }
59. }