Multiple colors in Graphics[] environment

Question

There are other questions on the site that are similar to this one, but the answers provided didn't help me.

I want to draw disks of different radii. Each radius is the absolute value of a variable, which takes positive and negative values. I want my disks to be red when the variable is negative, and blue when it is positive.

I am wondering how I would do that, since I haven't found pertinent information in Mathematica's documentation.

EDIT: To be clear, I have a set of eigenvectors, and for each one, I would like to plot a disk for each component of the vector. So, if the $i^{th}$ eigenvector, $\mathbf{\Psi}_i$, has the form

$$\mathbf{\Psi}_i = \sum_j c_j \mathbf{e}_j$$

where the $c_j$ are the coefficients and the $\mathbf e_j$ are the unit vectors in my basis, I'd like to plot for each $c_i$ a disk with radius $\vert c_i \vert^2$ and colored by the sign of $\arg c_j$.

Answer 1

Maybe something like this? I've controlled the colors based on the radius r and am passing in a location loc so that different disks are produced in the following example.

f[loc_, r_] := Graphics[{If[r > 0, Blue, Red], 
                  EdgeForm[Black], Disk[loc, Abs[r]]}]

Here it is for 100 random locations each with a radius ranging from 0 to 2.

Show[Table[f[i, RandomReal[{-2, 2}]], {i, RandomReal[{-10, 10}, {100, 2}]}]]

Edit: I'm not sure I understand exactly what you are asking for in the edits to the question. Going with the second it seems to me that you want to create a matrix of colored disks that corresponds to your original matrix m? If that is the case, you could do something like the following.

diskMatrix[m_]:=
    Block[{r,max = Max[m^2],n=Length[m],p=Length[m[[1]]]},
       Graphics[
         Table[
            r=m[[i,j]]^2;
            {EdgeForm[Black],
            If[m[[i,j]]>0,Blue,Red],
            Tooltip[Disk[{j,-i},
                    Rescale[r,{0,max},{0,2/n}]],
                    Row[{"Radius : ",r}]
            ]}
         ,{i,n},{j,p}
         ]
       ]
    ]

This code is going to take a matrix m and effectively produce a grid of disks where the ijth disk has radius m[[i,j]]^2 and is red if m[[i,j]] is negative, blue otherwise. In order to prevent overlap in the resulting graphic I've rescaled the radii. A Tooltip is used to show the value of the radii on mouse-over.

Here is an example using the matrix provided in the simple example.

m1 = {{-1/2, 1/2, 0, -1/Sqrt[2]}, {1/2, 1/2, -1/Sqrt[2], 0}, {-1/2, 
    1/2, 0, 1/Sqrt[2]}, {1/2, 1/2, 1/Sqrt[2], 0}};

diskMatrix[m1]

Produces the following image...

Edit 2: One last try in light of the most recent edit and posted comments. The following function will take a matrix of possibly complex values. It assumes there will be 4 columns in this matrix.

For each row m[[i]] a square is drawn. Proceeding from bottom left and counter-clockwise around the square a disk is rendered at each vertex. The radius of the disk is proportional to Abs[m[[i,j]]]^2. The color is chosen based on the sign of the real part of m[[i,j]].

diskTangle[evect_] := 
 Block[{r, max = Max[Abs[Flatten[evect]]^2], 
   pos = {{0, 0}, {1, 0}, {1, 1}, {0, 1}}}, 
  Table[Show[Graphics[{EdgeForm[Thick], White, Rectangle[]}], 
    Graphics[
     Table[r = Abs[e[[i]]]^2; {EdgeForm[Black], 
       If[Sign[Re[e[[i]]]] > 0, Blue, Red], 
       Tooltip[Disk[pos[[i]], Rescale[r, {0, max}, {0, 1/2}]], 
        Row[{"Radius : ", r}]]}, {i, Length[e]}]]], {e, evect}]]

Using m1 from above...

evects = Eigensystem[m1][[2]]//N;

diskTangle[evects]

Answer 2

Here's a version that

• keeps bigger disks from hiding smaller ones
• uses a minimum number color specifications

---

(* generate some points of the form {{x,y,r}, ..} *)
points = RandomVariate[NormalDistribution[], {20, 3}];

(* sort the points from biggest to smallest in absolute size, then split by sign *)
split = SplitBy[Reverse[SortBy[points, Abs[Last[#]] &]], Sign[Last[#]] &];

(* assign colors to each set of disks, beware the nested pure functions! *)
disks = {
   If[Sign[Last[First[#]]] == -1, Red, Blue], 
   Tooltip[Disk[{#, #2}, Abs[#3]], #3] & @@@ #
   } & /@ split;

(* draw the graphic *)
Graphics[{EdgeForm[Black], disks}]

---

Answer 3

Here's a routine that acts as a wrapper for Disk. It takes the same parameters, only that the radius can be negative and the color is basd on that.

myDisk[{x_, y_}, radius_] := {
    If[radius >= 0, Darker@Red, Darker@Blue], 
     Disk[{x, y}, Abs[radius]]
}

Using this function creates something like

myDisk[{0, 0}, 1]

{RGBColor[1, 0, 0], Disk[{0, 0}, 1]}

You can now combine a multitude of these into a single Graphics object, like

Graphics[{
    myDisk[{0, 0}, 1],
    myDisk[{1, 0}, -4/3]
}]

---

Edit

After OPs edit:

Here's a $128\times128$ matrix whose eigenvalues are calculated. The function circle creates a circle with your desired properties and places it on the x axis determined by the absolute value of the eigenvalue; this function is then applied to the list of eigenvalues to create the graphics.

m = Table[RandomVariate[NormalDistribution[]], {128}, {128}];
circleData = Eigenvalues[m];
circle[z_] := {If[0 <= Arg[z] <= \[Pi], Darker@Red, Darker@Blue],
    Circle[{5 Abs[z], 0}, Abs[z]]}
Graphics[circle /@ circleData]

Edit 2

Looks like I wasn't saying it complicated enough the first time. This time it's a $5\times5$ matrix. Eigensystem calculates eigenvectors and eigenvalues, the whole thing is then packed into graphics again. One circle per entry of the eigenvector, radius is the size of the eigenvalue.

m = Table[RandomVariate[NormalDistribution[]], {5}, {5}];
circledata = Eigensystem[m] // Transpose;
eigendisks = d \[Function] {
    If[0 <= Arg[d[[1]]] <= \[Pi], Darker@Red, Darker@Blue],
    Circle[20 {Abs@#, 0}, Abs@d[[1]]] & /@ d[[2]]
};
Graphics[eigendisks /@ circledata, Axes -> {True, False}]

Answer 4

This solutions places the disks in a grid where the i-th column corresponds to the components of the i-th eigenvector. The vertical positions of the disks are chosen such that there is a small gap between the disks.

disks[mat_] := Module[{eigenvec, radf, colf, yposf},
  With[{dy = .01},
   eigenvec = Normalize /@ Eigenvectors[mat];
   radf[ev_] := Abs[ev]^2;
   colf[ev_] := {Red, Blue}[[1 + UnitStep[Re[ev]]]];
   yposf[rlist_] := 2 Accumulate[dy + rlist] - rlist;
   Grid[{
     Function[{v},
       Graphics[MapThread[{colf[#1], Tooltip[Disk[{0, #2}, #3], #1]} &,
         {v, yposf[radf[v]], radf[v]}], 
        ImageSize -> {Automatic, 200}]] /@ eigenvec}]]]

Example:

disks[RandomReal[1, {8, 8}]]