# Drawing a Reuleaux Triangle

A Reuleaux triangle is a shape of constant width sort of like a rounded equilateral triangle.

It can be formed by the intersection of three circles like in a three set Venn diagram.

What is the best way to draw a Reuleaux triangle using TikZ, Asymptote, or some language that is embeddable into LaTeX? Perhaps by drawing the three circles of a Venn diagram and cutting off the rest?

-
something like \tikz{\draw (90:1) arc (120:180:1.5) arc (-120:-60:1.5) arc (0:60:1.5);} ? –  percusse Feb 15 at 1:31
@percusse Yes! That looks right as long as the arcs are all centered at their opposing vertices. Which they are right? –  David Caliri Feb 15 at 1:44
@percusse What if I want to fill it with color? –  David Caliri Feb 15 at 1:51
For those interested, these are used for the shape of coins for instance in the UK. I was surprised to know that some shapes different from the disk have the same width from any orientation.. –  meduz Mar 4 at 18:02
Since you have some responses below that seem to answer your question, please consider marking one of them as ‘Accepted’ by clicking on the tickmark below their vote count (see How do you accept an answer?). This shows which answer helped you most, and it assigns reputation points to the author of the answer (and to you!). It's part of this site's idea to identify good questions and answers through upvotes and acceptance of answers. –  Jubobs Mar 18 at 17:31

Here is a small Metapost function to draw a general Reuleaux polygon. Explanations below.

prologues := 3;
outputtemplate := "%j%c.eps";

vardef reuleaux(expr n) =
for t=0 step 360/n until 359:
1/2 up rotated t { left rotated (t+90/n) } .. { left rotated (t+270/n)}
endfor cycle enddef;

beginfig(1);
for i := 3 step 2 until 9:
draw reuleaux(i) scaled 40i withcolor .6 red withpen pencircle scaled 1;
draw fullcircle  scaled 40i withcolor .6 white;
endfor
endfig;
end.


Scale, rotate, shift as required. It's sized so that it fits inside a fullcircle scaled to the same amount.

Each corner is a point of the path, so if you want to join the vertices, join points 0, 1, ..., n-1; if you want the mid-points of each arc, use points 1/2, 3/2, ..., n-1/2, like this:

beginfig(2);
path t[];
for n := 3 upto 7:
t[n] = reuleaux(n) scaled 60 shifted (75n,0);
fill t[n] withcolor red+0.75green+0.2blue;
draw for i = 0 upto n-1: point i     of t[n] -- endfor cycle withcolor .6 red;
draw for i = 0 upto n-1: point i+1/2 of t[n] -- endfor cycle withcolor .6 blue;
endfor
endfig;


Obviously, you also could pick out points to label as well.

beginfig(3);
path t; t = reuleaux(3) scaled 90;
draw t withcolor .6 red;
dotlabel.top (btex $A$ etex, point 0 of t);
dotlabel.llft(btex $B$ etex, point 1 of t);
dotlabel.lrt (btex $C$ etex, point 2 of t);
endfig;


## Explanations

I've revised this answer a couple of times, as I thought about the problem a bit more. The original versions used buildcycle and the pre-defined circular paths, but they are not really needed. The final version here is a simple and correct as I can make it.

The reuleaux(n) function returns a path with n vertices connected by circular arcs, whose radius is the length of the longest diagonal of the corresponding regular polygon.

To understand what it does, consider first the following function that returns the path of a regular polygon with n vertices:

vardef polygon(expr n) =
for t=0 step 360/n until 359:
up rotated t --
endfor cycle enddef;


up expands to (0,1), so with n=3 this function expands to

(0,1) -- (-0.866,-0.5) -- (0.866,-0.5) -- cycle


as required for a 3-sided regular polygon fitting inside a circle of unit radius. In Metapost however the predfined fullcircle path has unit diameter so for consistency it would be better to scale our polygon down by 1/2,

vardef polygon(expr n) =
for t=0 step 360/n until 359:
1/2 up rotated t --
endfor cycle enddef;


The precedence rules in MP mean that 1/2 up expands to (0,0.5) which is what we want.

Now we have a regular polygon that fits inside a fullcircle and to make it into a Reuleaux polygon we have to bend the straight lines into arcs centred on the opposite vertex (or the mid-point of the opposite vertices when n is even). We can do this using the path direction notation, and changing -- into .. to allow the path to bend.

vardef reuleaux(expr n) =
for t=0 step 360/n until 359:
1/2 up rotated t { left rotated (t+90/n) } .. { left rotated (t+270/n)}
endfor cycle enddef;


Since left is up rotated 90, the required directions are given by the formulae shown, as you can work out with a little elementary geometry:

If you want to convince yourself that the resulting arcs really are circular and have the right centres then draw appropriately scaled and shifted circles on top. The radius of such a circle would be the length of the longest diagonal on the polygon - AC in the figure above - which you can find with length (point (n+1)/2 of r - point 0 of r) where r=reuleaux(n).

## Applications

The Reuleaux triangle features in some traditional geometric patterns, like this one:

which we can draw like this: (if there's a better way to do the tiling, please comment!)

beginfig(6);
path t, ring; s := 10;
t = reuleaux(3) scaled s;
ring = for i=0 upto 5: subpath(-1,1) of t shifted (0,s) rotated (i*60) .. endfor cycle;
pair offset;
for i=0 upto 5:
dx := 0;
for j=0 upto 13:
offset := (3*s,0) rotated (30*(j mod 2*2-1));
dx := dx + xpart offset;
dy := 3*i*s + 1/2 ypart offset;
draw ring shifted (dx,dy) withcolor (.5,.7,.9);
endfor
endfor
endfig;


This may form the basis for other explorations. For example just changing the definition of t to t = reuleaux(2) scaled s produced this rather wonderful pattern.

## Variations

If you want a Reuleaux polygon pointing right instead of up, then you just have to swap up and left in the definition for right and up.

vardef reuleaux(expr n) =
for t=0 step 360/n until 359:
1/2 right rotated t { up rotated (t+90/n) } .. { up rotated (t+270/n)}
endfor cycle enddef;

beginfig(7);
for n=3 upto 7:
draw fullcircle  scaled 60 shifted (75n,0) withcolor .8 white;
draw reuleaux(n) scaled 60 shifted (75n,0) withcolor .67 red;
endfor
endfig;


This is slightly more consistent with plain MP as point 0 of these shapes corresponds to zero degrees rotation. They look like this:

We can also swap the two directions in the definition to produce what might be called anti-Reuleaux polygons.

vardef antireuleaux(expr n) =
for t=0 step 360/n until 359:
1/2 right rotated t { up rotated (t+270/n) } .. { up rotated (t+90/n)}
endfor cycle enddef;


As you can see below, these anti-shapes are similar to, but subtly differ from, hypocycloid curves.

vardef hypocycloid(expr k) =
for t=0 step 1 until 360:
point 0 of (fullcircle scaled (1/k) rotated (-t*k)
shifted (1/2 right scaled (1-1/k))) rotated t --
endfor cycle
enddef;


It is also possible to round the corners of a Reuleaux polygon while still retaining the constant width property. Here is a function to produce a rounded shape that takes a slightly more generalized approach. The first parameter is the number of sides, the second is the radius of the rounded corners as a fraction of the width.

vardef polygon(expr n) =
for t=0 step 360/n until 359:
1/2 right rotated t --
endfor cycle
enddef;

vardef rounded_reuleaux(expr n, s) =
save m, a, b, p; m := (n+1)/2;
pair a,b; path p; p := polygon(n);
for i = 0 upto n-1:
hide(
a := point i   of p - point i+m of p;
b := point i+1 of p - point i+m of p;
)
point i   of p + s*unitvector(a) { up rotated angle a } ..
point i+1 of p + s*unitvector(b) { up rotated angle b } ..
endfor cycle
enddef;

beginfig(8);
for n := 3 upto 7:
fill rounded_reuleaux(n,1/6) scaled 60 shifted (85n,0) withcolor (1/2,3/4,5/6);
draw reuleaux(n)             scaled 60 shifted (85n,0);
endfor


-
What means : shifted (1/2 up rotated -theta). Especially up. –  Tarass Feb 15 at 17:46
up is standard MP short hand for the vector (0,1); 1/2 up expands to (0,0.5); (1/2 up rotated -theta) expands to (-0.5*sin(-theta),+0.5*cos(-theta)) which is where I want the centre of that part of the arc. –  Thruston Feb 15 at 18:07
... but it's easier to write rotated than to remember the sin and cos formulae –  Thruston Feb 15 at 18:11
Your buildycle-based way of doing is, I think, the most general and appropriate up to now to solve this problem. Wish I had thought about it! –  fpast Feb 16 at 9:14
@PatrickT no preamble needed, you just need the five lines that define the reuleaux function -it's all plain Metapost. Follow the first link for basic info about running MP. I';ll have some time tmw to tidy this up and add some explanations. –  Thruston Feb 16 at 23:10

Here is an attempt with intersetions library:

\documentclass[tikz,border=10pt]{standalone}
\usetikzlibrary{intersections}
\begin{document}
\begin{tikzpicture}
\path[use as bounding box] (0.1,0.1) rectangle (2,1.5);
\clip (0,0) circle (2cm);
\clip (1,2) circle (2cm);
\clip (2,0) circle (2cm);
\draw[thick,fill=blue!20!green!20,name path=left] (0,0) circle (2cm);
\draw[thick,name path=right] (2,0) circle (2cm);
\draw[thick,name path=top] (1,2) circle (2cm);
\path [name intersections={of=left and right, by=a},name intersections={of=left and top, by=b},name intersections={of=top and right, by=c}]
[fill=blue!30,draw=orange] (a) -- node[left,text=black]{\footnotesize$r$}(b) -- node[above,text=black]{\footnotesize$r$}(c) -- node[right,text=black]{\footnotesize$r$}cycle;
\end{tikzpicture}
\end{document}


To colour only the reuleaux triangle comment the following lines in the above code:

    %\path [name intersections={of=left and right, by=a},name intersections={of=left and top, by=b},name intersections={of=top and right, by=c}]
%[fill=blue!30,draw=orange] (a) -- node[left,text=black]{\footnotesize$r$}(b) -- node[above,text=black]{\footnotesize$r$}(c) -- node[right,text=black]{\footnotesize$r$}cycle;
\end{tikzpicture}


Employing Gonzalo's suggestion of using equilateral triangle, here is an attempt.

\documentclass[tikz,border=10pt]{standalone}
\usetikzlibrary{backgrounds}
\begin{document}
\begin{tikzpicture}
\coordinate (a) at (0,0);
\coordinate (b) at (60:1cm);
\coordinate (c) at (0:1cm);
\node[fill,circle,inner sep=1pt] at (a) {};
\node[fill,circle,inner sep=1pt] at (b) {};
\node[fill,circle,inner sep=1pt] at (c) {};
\begin{pgfonlayer}{background}
\path[use as bounding box] (0.1,0.1) rectangle (1,0.6);
\clip (a) circle (1cm);
\clip (b) circle (1cm);
\clip (c) circle (1cm);
\draw[thick,fill=blue!20!green!20] (a) circle (1cm);
\draw[thick] (b) circle (1cm);
\draw[thick] (c) circle (1cm);
\end{pgfonlayer}
\end{tikzpicture}
\end{document}


I have used background layer just to get the circles at the corners un-clipped.

-
That is great! What if you want to also do one where you don't have the inner triangle and you color the entire reuleaux triangle? –  David Caliri Feb 15 at 2:02
@DavidCaliri Please see the edit. –  Harish Kumar Feb 15 at 2:07
Am I mistaken or you are not using an equilateral triangle here? –  Gonzalo Medina Feb 15 at 2:42
It's not really only a suggestion; it's the definition of the Reuleaux triangle :-) –  Gonzalo Medina Feb 15 at 3:12
@GonzaloMedina hehe, it was just a diagram for me. Thanks for correcting. :) –  Harish Kumar Feb 15 at 9:33

Based on percusse's suggestion, but implemented in Asymptote and requiring no angle calculations. The key is the function arc(c, a, b), which returns an arc centered at c from a to b. (If there is no such arc, then it returns an arc centered at c from a to the line c--b.)

Note also the use of the & operator for concatenating two paths with a common endpoint.

\documentclass[margin=10pt]{standalone}
\usepackage{asymptote}
\begin{document}
\begin{asy}
unitsize(3cm);
path triangle = scale(1/2)*polygon(3);
pair a = point(triangle, 0), b=point(triangle,1), c=point(triangle,2);
path releaux = arc(c=a, b, c) & arc(c=b, c, a) & arc(c=c, a, b) & cycle;
fill(releaux, gray);
draw(releaux);
\end{asy}
\end{document}


The result:

-

Just for typing exercise with PSTricks.

\documentclass[pstricks,border=16pt]{standalone}
\usepackage{pst-eucl}
\usepackage{fp}
\FPset\R{5}
\FPeval\T{tan(pi/3)*R/2}
\FPeval\B{T-R}

\begin{document}
\begin{pspicture}(0,\B)(\R,\T)
\pstGeonode[PosAngle={-90,-90,45},CurveType=polygon]{A}(\R,0){B}(!\R\space 2 div \T){C}
\foreach \x/\y/\z in {A/B/C,B/C/A,C/A/B}{\pstArcOAB{\x}{\y}{\z}}
\end{pspicture}
\end{document}


## Edit

It is too short for typing exercise. It takes 183 characters.

% with PSTricks  by me.
\documentclass[pstricks]{standalone}
\begin{document}
\pspicture(6,5)
\pscustom{\moveto(5,1)\psLoop{3}{\rmoveto(-4,0)\psarc(!!CP){4}{0}{60}\rotate{120}}}
\endpspicture
\end{document}


Mark Wibrow's solution below takes 196 characters. I won. :-)

% with Tikz by Mark Wibrow
\documentclass[tikz,border=5]{standalone}
\begin{document}
\tikz\draw (90:1) \foreach \i in {1,2,3}{ [rotate=\i*120] arc (0:60:2*cos 30) } -- cycle
-- (210:1) -- (330:1) -- cycle;
\end{document}

-
may be not surprising its PSTricks :) –  texenthusiast Feb 16 at 13:27
Au contraire. My answer below does not take 196 characters. –  Mark Wibrow Feb 16 at 14:33
If pspicture is simplified as pst and \SpecialCoor is enabled by default then I can save more keystrokes. –  Please don't touch Feb 16 at 17:20

Another TikZ solution, but this time, TikZ does all the job. You just provide two coordinates (two of the vertices of the equilateral triangle) and the other vertex and the radii are automatically calculated. For example, the image below was produced using

\Reuleaux{0,0}{2,0}
\Reuleaux[Dandelion]{0,0}{3,-2}


The code:

\documentclass[dvipsnames]{article}
\usepackage{tikz}
\usetikzlibrary{intersections,positioning,calc}

\newcommand\Reuleaux[3][Aquamarine]{%
\def\A{#2}
\def\B{#3}
\begin{tikzpicture}
\begin{scope}
\clip[name path global=c1] (\A)
let
\p1 = ($(\B) - (\A)$)
in
circle ({veclen(\x1,\y1)});
\clip[name path global=c2] (\B)
let
\p1 = ($(\B) - (\A)$)
in
circle ({veclen(\x1,\y1)});
\clip[name path global=c3] ($(\A) ! .5 ! (\B) ! {sin(60)*2} ! 90:(\B)$)
let
\p1 = ($(\B) - (\A)$)
in
circle ({veclen(\x1,\y1)});
\fill[#1] (current bounding box.north west) rectangle (current bounding box.south east);
\end{scope}
\draw (\A)
let
\p1 = ($(\B) - (\A)$)
in
circle ({veclen(\x1,\y1)});
\draw (\B)
let
\p1 = ($(\B) - (\A)$)
in
circle ({veclen(\x1,\y1)});
\draw ($(\A) ! .5 ! (\B) ! {sin(60)*2} ! 90:(\B)$)
let
\p1 = ($(\B) - (\A)$)
in
circle ({veclen(\x1,\y1)});
\fill [name intersections={of=c1 and c2,by={a,b}}]
(a) circle (2pt) node[label=above:$A$] {};
\fill [name intersections={of=c2 and c3,by={c,d}}]
(d) circle (2pt) node[label=left:$B$] {};
\fill [name intersections={of=c3 and c1,by={e,f}}]
(f) circle (2pt) node[label=right:$C$] {};
\draw (a) -- (d) -- (f) -- cycle;
\end{tikzpicture}%
}

\begin{document}

\Reuleaux{0,0}{2,0}

\Reuleaux[Dandelion]{0,0}{3,-2}

\end{document}


If only the triangle is to be produced, the \draw commands can be suppressed from the above code:

\documentclass[dvipsnames]{article}
\usepackage{tikz}
\usetikzlibrary{intersections,positioning,calc}

\newcommand\Reuleaux[3][Aquamarine]{%
\def\A{#2}
\def\B{#3}
\begin{tikzpicture}
\begin{scope}
\clip[name path global=c1] (\A)
let
\p1 = ($(\B) - (\A)$)
in
circle ({veclen(\x1,\y1)});
\clip[name path global=c2] (\B)
let
\p1 = ($(\B) - (\A)$)
in
circle ({veclen(\x1,\y1)});
\clip[name path global=c3] ($(\A) ! .5 ! (\B) ! {sin(60)*2} ! 90:(\B)$)
let
\p1 = ($(\B) - (\A)$)
in
circle ({veclen(\x1,\y1)});
\fill[#1] (current bounding box.north west) rectangle (current bounding box.south east);
\end{scope}
\fill [name intersections={of=c1 and c2,by={a,b}}]
(a) circle (2pt) node[label=above:$A$] {};
\fill [name intersections={of=c2 and c3,by={c,d}}]
(d) circle (2pt) node[label=left:$B$] {};
\fill [name intersections={of=c3 and c1,by={e,f}}]
(f) circle (2pt) node[label=right:$C$] {};
\draw (a) -- (d) -- (f) -- cycle;
\end{tikzpicture}%
}

\begin{document}

\Reuleaux{0,0}{2,0}

\Reuleaux[Dandelion]{0,0}{3,-2}

\Reuleaux[Maroon]{-2,-2}{0,0}

\end{document}


-

It's pretty easy with PSTricks and pst-eucl:

\documentclass[a4paper,10pt]{article}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}%
\usepackage{lmodern}

\usepackage[svgnames, pdf]{pstricks}%[]
\usepackage{pst-eucl}

\pagestyle{empty}
\begin{document}

\begin{pspicture*}(-5,-5)(5,5)
\pstTriangle(4 ; 60){A}(0,0){B}(4,0){C}
\pscustom[fillstyle = solid, fillcolor = LightSteelBlue!30!White , linecolor = Navy]{%
\pstArcOAB{A}{B}{C}
\pstArcOAB{B}{C}{A}
\pstArcOAB{C}{A}{B}}
\pspolygon[linecolor = red](A)(B)(C)
\end{pspicture*}

\end{document}


This code can be compiled directly with pdflatex --enable-write18.

-

With tkz-euclide

\documentclass{scrartcl}
\usepackage{tkz-euclide}
\usetkzobj{all}

\begin{document}
\begin{tikzpicture}
\tkzDefPoint(0,0){A}
\tkzDefPoint(5,0){B}
\tkzDefEquilateral(A,B)\tkzGetPoint{C}
\tkzDrawPolygon[red](A,B,C)
\tkzDrawArc[fill=gray!20](A,B)(C)
\tkzDrawArc[fill=gray!20](B,C)(A)
\tkzDrawArc[fill=gray!20](C,A)(B)
\end{tikzpicture}
\end{document}


With

  \begin{tikzpicture}
\tkzDefPoint(0,0){A}
\tkzDefPoint(5,0){B}
\tkzDefEquilateral(A,B)\tkzGetPoint{C}
\tkzDrawPolygon[red](A,B,C)
\begin{scope}
\tkzSetUpLine[style=dashed,color=gray]
\tkzDrawCircle(B,C)
\tkzDrawCircle(A,B)
\tkzDrawCircle(C,A)
\end{scope}
\tkzDrawArc[fill=gray!20](A,B)(C)
\tkzDrawArc[fill=gray!20](B,C)(A)
\tkzDrawArc[fill=gray!20](C,A)(B)
\end{tikzpicture}


And finally

\documentclass{scrartcl}
\usepackage{tkz-euclide}
\usetkzobj{all}

\begin{document}
\begin{tikzpicture}
\tkzDefPoint(0,0){A}
\tkzDefPoint(5,0){B}
\tkzDefEquilateral(A,B)\tkzGetPoint{C}
\tkzFillSector[fill=gray!20](A,B)(C)
\tkzFillSector[fill=gray!20](B,C)(A)
\tkzFillSector[fill=gray!20](C,A)(B)
\end{tikzpicture}
\end{document}


Remark : It's possible to create a macro with the last code.

Annexe : With tikz a minimum code is (based on Mark Wibrow's answer)

 \documentclass[tikz,border=5]{standalone}
\begin{document}
\tikz\draw[fill=blue!20] (0,0)
\foreach \i in {1,2,3}{ arc (\i*120:\i*120+60:4)} ;
\end{document}


-

Another try with MetaPost. Heavily inspired by Charles Staat's proposition and Gonzalo Medina's presentation (and much less ingenious than Thruston's program). The challenge for me was to create the arc(a, b, c) macro of Asymptote, used by Charles Staat, and which doesn't exist in Plain MetaPost nor Metafun, macro "which returns an arc centered at c from a to b. (If there is no such arc, then it returns an arc centered at c from a to the line c--b.)"

First version using Enrico Gregorio's great gmp package as (PDF)LaTeX interface for MetaPost (the shell-escape option must be activated).

\documentclass[12pt]{scrartcl}
\usepackage[latex, shellescape]{gmp}
\gmpoptions{everymp={%
input mpcolornames;
input latexmp;
setupLaTeXMP(options="12pt", mode=rerun);
u := 1cm; % scale
vardef arc(expr a, b, c) =
save my_halfcircle, radius; clearxy; path my_halfcircle[], radius;
save r; numeric r; r = abs((b-a));
my_halfcircle1 := halfcircle scaled abs(2r) rotated angle(b-a) shifted a;
my_halfcircle2 := my_halfcircle1 reflectedabout (a, b);
radius = a -- max(1.1, 1.1r/abs(c-a))[a,c];
z = my_halfcircle1 intersectiontimes radius;
if z<>(-1,-1):
subpath (0, x) of my_halfcircle1
else:
subpath (0, xpart(my_halfcircle2 intersectiontimes radius)) of my_halfcircle2
fi
enddef;
%
def Reuleaux(expr A, B, my_color) =
pair C; C := B rotatedaround(A, 60);
path Reuleaux_triangle;
Reuleaux_triangle = arc(A, B, C) -- arc(B, C, A) -- arc(C, A, B) -- cycle;
fill Reuleaux_triangle withcolor my_color; draw Reuleaux_triangle;
draw A--B--C--cycle;
freelabeloffset:=2bp;
freelabel(textext("$A$"), A, 0.5[B,C]);
freelabel(textext("$B$"), B, 0.5[A,C]);
freelabel(textext("$C$"), C, 0.5[A,B]);
enddef;}}

\begin{document}
\begin{mpost*}[mpmem=metafun]
Reuleaux(origin, (3u, 2u), Orange);
\end{mpost*}
%
\begin{center}
\begin{mpost*}[mpmem=metafun]
Reuleaux(origin, (4u, 0), green);
\end{mpost*}
\end{center}

\bigskip
\begin{flushright}
\begin{mpost*}[mpmem=metafun]
Reuleaux((-2u, -3u), (0.5u, 3u), 0.8white);
\end{mpost*}
\end{flushright}
\end{document}


The second version (with the same output) is to be typesetted with LuaLaTeX, since it makes use of the latest available version of the luamplib package.

\documentclass[12pt]{scrartcl}
\usepackage{luamplib}
\mplibsetformat{metafun}
\everymplib{%
verbatimtex
\leavevmode
etex;
input mpcolornames;
u := 1cm; % scale
vardef arc(expr a, b, c) =
save my_halfcircle, radius; clearxy; path my_halfcircle[], radius;
save r; numeric r; r = abs((b-a));
my_halfcircle1 := halfcircle scaled abs(2r) rotated angle(b-a) shifted a;
my_halfcircle2 := my_halfcircle1 reflectedabout (a, b);
radius = a -- max(1.1, 1.1r/abs(c-a))[a,c];
z = my_halfcircle1 intersectiontimes radius;
if z<>(-1,-1):
subpath (0, x) of my_halfcircle1
else:
subpath (0, xpart(my_halfcircle2 intersectiontimes radius)) of my_halfcircle2
fi
enddef;
%
def Reuleaux(expr A, B, my_color) =
pair C; C := B rotatedaround(A, 60);
path Reuleaux_triangle;
Reuleaux_triangle = arc(A, B, C) -- arc(B, C, A) -- arc(C, A, B) -- cycle;
fill Reuleaux_triangle withcolor my_color; draw Reuleaux_triangle;
draw A--B--C--cycle;
freelabeloffset:=2bp;
freelabel(textext("$A$"), A, 0.5[B,C]);
freelabel(textext("$B$"), B, 0.5[A,C]);
freelabel(textext("$C$"), C, 0.5[A,B]);
enddef;
beginfig(1);}
\everyendmplib{endfig;}

\begin{document}
\begin{mplibcode}
Reuleaux(origin, (3u, 2u), Orange);
\end{mplibcode}
%
\begin{center}
\begin{mplibcode}
Reuleaux(origin, (4u, 0), green);
\end{mplibcode}
\end{center}

\bigskip
\begin{flushright}
\begin{mplibcode}
Reuleaux((-2u, -3u), (0.5u, 3u), 0.8white);
\end{mplibcode}
\end{flushright}
\end{document}


-

No frills...

\documentclass[tikz,border=5]{standalone}
\begin{document}
\tikz\draw(0,1)\foreach\i in{1,2,3}{[rotate=\i*120]arc(0:60:sqrt 3)}--cycle--(210:1)--(330:1)--cycle;
\end{document}


or

\documentclass[tikz,border=5]{standalone}
\begin{document}
\tikz\fill[even odd rule] (90:1) \foreach \i in {1,2,3}{ [rotate=\i*120] arc (0:60:2*cos 30) } -- cycle
-- (210:1) -- (330:1) -- cycle;
\end{document}


-
Indeed, straight to the point! Impressive for its concision. –  fpast Feb 16 at 8:39

Here is the new \reuleauxpolypath macro. It inserts into a TikZ path the closed path associated with a Reuleaux polygon. The current point of the path is the center of the polygon. Its three arguments are :

1. the initial direction to position the first vertex,

2. the radius of the Reuleaux polygon (distance between the center and a vertex or radius of the circumscribed circle),

3. the number of vertex.

\newcommand\reuleauxpolypath[3]{% initial direction, radius, num vertex
\pgfextra{
\pgfmathsetmacro\ang{360/(#3)}
\pgfmathsetmacro\semiang{\ang/2}
\pgfmathsetmacro\semisemiang{\ang/4}
} ++({(#1)}:{#2}) \foreach \num in {1,...,#3}{
arc [start angle={(#1)+(\num-1)*\ang+\semisemiang},
} -- cycle
}


Example:

\draw (0,0) \reuleauxpolypath{0}{1cm}{3};


A complete example:

\documentclass[tikz]{standalone}
\newcommand\reuleauxpolypath[3]{% initial direction, radius, num vertex
\pgfextra{
\pgfmathsetmacro\ang{360/(#3)}
\pgfmathsetmacro\semiang{\ang/2}
\pgfmathsetmacro\semisemiang{\ang/4}
} ++({(#1)}:{#2}) \foreach \num in {1,...,#3}{
} -- cycle
}
\begin{document}
\begin{tikzpicture}
\foreach \num/\col in {3/red,5/blue,7/green}{
\draw[draw=\col] (0,0) \reuleauxpolypath{0}{1cm}{\num};
}
\fill[draw=red,fill=orange] (0,2.5) \reuleauxpolypath{90}{1cm}{5};
\end{tikzpicture}
\end{document}

-

Another variant with only tikz. In this answer, I created a macro to draw the triangle based on two points.

\documentclass[11pt]{scrartcl}
\PassOptionsToPackage{dvipsnames,svgnames}{xcolor}
\usepackage{tikz}
\usetikzlibrary{calc}

\makeatletter
\newcommand\reuleaux[2]{% we need two points, it's possible to modify that ...
\pgfextra{\pgfmathanglebetweenpoints{%
\pgfpointanchor{#1}{center}}{%
\pgfpointanchor{#2}{center}}
\pgfmathsetmacro{\@initialdirection}{\pgfmathresult}}
let \p1 = ($(#1) - (#2)$) in  (#2)
arc (\@initialdirection:\@initialdirection+60:{veclen(\x1,\y1)})
arc (\@initialdirection +120:\@initialdirection +180:{veclen(\x1,\y1)})
arc (\@initialdirection +240:\@initialdirection +300:{veclen(\x1,\y1)})}
\makeatother

\begin{document}

\begin{tikzpicture}
\path (0,0)   coordinate (A)
(5,2)   coordinate (B)
(8,-2)  coordinate (C)
(10,1)  coordinate (D);

\draw[fill=MidnightBlue!20] \reuleaux{A}{B} ;
\draw[fill=green!20] \reuleaux{D}{C} ;
\end{tikzpicture}

\end{document}


-

Another solution, using my xpicture package.

First of all, we note that radius $r$ of every circular arc equals the side of the triangle; if this triangle is inscribed in a circle of radius 1, using the cosine law, it is easy to see that $r^2=2(1-\cos(120))$. Then, all we have to do is to draw a circular arc of radius $r$ and amplitude 60 degrees from every corner.

\documentclass{article}
\usepackage{xpicture}

\begin{document}

% Calcule the radius, using calculator functions
\DEGREESCOS{120}{\temp}
\SUBTRACT{1}{\temp}{\temp}
\MULTIPLY{2}{\temp}{\temp}

\setlength{\unitlength}{1cm}
\begin{Picture}(-1,-1)(1,1)
\polarreference
\degreesangles

\Polygon(1,90)(1,210)(1,330)