The short answer is no since all the class attributes are floats not doubles.

The solution is to create a new class that does the same as PVector but using doubles. I did this by copying the source code for PVector then search and replace float with double, I had to modify the lerp and hashcode functions by hand but the result can be seem here

To use this class then create a new tab in your processing sketch called PVectorD.java (this is case sensitive) and copy the code from the above link into this tab. Instead of using PVector use PVectorD instead it should work just fine.

Just after I posted this I had a look at the PVector source and realised that i'd asked a stupid question and I thought about whether or not it would be possible to just go through and change all the floats to doubles.

I casted all my doubles to floats after the calculations in the sketches I've been working on and I had to split what was point.x point.y point.z into 3 separate variables. I'll give it another go using your vector doubles class.  

Hi Quarks,

Most Processing folks use a PVector merely as a mean to store 2 or 3 values and nothing more.
Here's a mini PVectorD storage class which only stores and retrieves its x, y, z fields.
It accepts a wide range of data types; including Array, PVector, int and float:  

P.S.: Suffix all your numerical literals w/ d, like 4.5d to assure a better precision.
Processing's pre-processor suffix all fractional literals w/ f, forcing them to be float instead.

PVectorD.java:

---

/** 
 * Mini PVector Class Storage for Doubles (v1.01)
 * by GoToLoop (2013/Aug)
 * 
 * http://forum.processing.org/topic/can-pvector-work-with-doubles
 */

class PVectorD {
  double x, y, z;

  PVectorD(double xx, double yy) {
    set(xx, yy);
  }

  PVectorD(double xx, double yy, double zz) {
    set(xx, yy, zz);
  }

  PVectorD(PVector p) {
    set(p);
  }

  PVectorD(int[] a) {
    set(float(a));
  }

  PVectorD(float[] a) {
    set(a);
  }

  PVectorD(double[] a) {
    set(a);
  }

  void clear() {
    x = y = z = 0;
  }

  void set(double xx, double yy) {
    x = xx;
    y = yy;
  }

  void set(double xx, double yy, double zz) {
    x = xx;
    y = yy;
    z = zz;
  }

  void set(PVector p) {
    x = p.x;
    y = p.y;
    z = p.z;
  }

  void set(int[] a) {
    set(float(a));
  }

  void set(float[] a) {
    final int len = a.length;

    if (len > 0)  x = a[0];
    if (len > 1)  y = a[1];
    if (len > 2)  z = a[2];
  }

  void set(double[] a) {
    final int len = a.length;

    if (len > 0)  x = a[0];
    if (len > 1)  y = a[1];
    if (len > 2)  z = a[2];
  }

  PVectorD get() {
    return new PVectorD(x, y, z);
  }

  PVector toPVector() {
    return new PVector((float) x, (float) y, (float) z);
  }

  double[] toArray() {
    return new double[] {
      x, y, z
    };
  }

  String toString() {
    return "[ " + x + ", " + y + ", " + z + " ]";
  }
}

---

Indeed Ruby seems very clean. Just like JavaScript & CoffeeScript, it doesn't mind about primitive types. 
Well, just for completeness, a PVectorI version to store int x, y, z: 

PVectorI.java:

---

/** 
 * Mini PVector Class Storage for Ints (v1.01)
 * by GoToLoop (2013/Aug)
 * 
 * http://forum.processing.org/topic/can-pvector-work-with-doubles
 */

class PVectorI {
  int x, y, z;

  PVectorI(double xx, double yy) {
    set((int) xx, (int) yy);
  }

  PVectorI(double xx, double yy, double zz) {
    set((int) xx, (int) yy, (int) zz);
  }

  PVectorI(PVector p) {
    set(p);
  }

  PVectorI(int[] a) {
    set(a);
  }

  PVectorI(float[] a) {
    set(int(a));
  }

  void clear() {
    x = y = z = 0;
  }

  void set(int xx, int yy) {
    x = xx;
    y = yy;
  }

  void set(int xx, int yy, int zz) {
    x = xx;
    y = yy;
    z = zz;
  }

  void set(PVector p) {
    x = (int) p.x;
    y = (int) p.y;
    z = (int) p.z;
  }

  void set(int[] a) {
    final int len = a.length;

    if (len > 0)  x = a[0];
    if (len > 1)  y = a[1];
    if (len > 2)  z = a[2];
  }

  void set(float[] a) {
    set(int(a));
  }

  PVectorI get() {
    return new PVectorI(x, y, z);
  }

  PVector toPVector() {
    return new PVector(x, y, z);
  }

  int[] toArray() {
    return new int[] {
      x, y, z
    };
  }

  String toString() {
    return "[ " + x + ", " + y + ", " + z + " ]";
  }
}

---

Thanks guys. Unfortunately I need the full functionality of the PVector class (e.g. magnitude, subtract, set, etc.) as I am using it to carry out some quite serious maths in the background of my program. My problem is that I need the PVector to be precise to +/- 0.001 whilst having a value of over 200000. 

PVector's source code so you can convert float to double data-type:
https://github.com/processing/processing/blob/master/core/src/processing/core/PVector.java

I need it to give magnitude etc as floats and accept floats as inputs so that I don't have to change my entire program!

Well, you can use the float cast operator (float) before passing your double variables to
any Processing API functions as an alternative.

@cptmatthews

I wondered why the link did not work, then I realised that this was a very old post and I have cleared out / rebuilt my website so a lot of old files got dumped.

Since the PVector class has changed over the last two years I have done the same thing with the latest version of PVector and have uploaded it for you to download.

I still had to modify the lerp, equal and hashcode functions by hand. The new random2D and random3D functions had to be modified and the versions of these methods that had PApplet parameters have been removed since they used the random function that returned a float.

So the latest version of PVector2D can be downloaded here

HTH

Huge thanks Quarks and GoToLoop, my program now works easily to the precision I need.