[Question]
  [
To celebrate Rounded Pi Day, you must take advantage of today's date to make a program that takes in a circle's diameter and outputs its circumference by multiplying the diameter by 3.1416, where 3.1416 must be obtained using today's date.
```
Input 3
Output 9.4248
etc.
```
Does not take the date as input. You do not have to use all components of the date but the digits of pi must come from formatting a Date object or using a date object to obtain it. The answers so far look good.
Not sure what else to specify. All the answers so far meet what I was expecting.
My constraint was that you must use components of the date to come up with Pi. You can of course use the components, multiply by 0 then add 3.1416, but that's boring and wastes precious chars!
Shortest code wins!
  
[Answer]
# C, 32 bytes
```
#define f(d)d*time(0)/464083315.
```
If losing a little more accuracy is fine, I can get it down to about 29 bytes being still accurate to 4 digits past the decimal (as of the time of this posting):
```
#define f(d)d*time(0)/46408e4
```
[Answer]
# AppleScript, ~~122~~ 120 bytes
```
set a to current date
(display dialog""default answer"")'s text returned*(month of a+day of a*.01+year of a*1e-4 mod.01)
```
### Variable a
Variable a is a date object. I call all of my date information off of it.
### Month, day, and year
The month, day, and year calls actually return an object that normally returns a string. To properly use it as a number, I have surrounded it on both sides with mathematical operations to automatically cast it to a number.
### 1e-4
`1e-4` is a byte shorter than `.0001`.
### mod.01
`.` acts as a separator to the AppleScript autocorrect. By using this, I can use modulo and *still* keep it a byte for myself.
### No return statement/log
The last value calculated automatically is returned by the program. I output the number calculated via the return box.
And here's a gif of it running!
[![pi day gif](https://i.stack.imgur.com/RdUdW.gif)](https://i.stack.imgur.com/RdUdW.gif)
[Answer]
# Mathematica + coreutils, 20 bytes
```
<<"!date +%m.%d%y"#&
```
Luckily, Mathematica interprets the output of an external command as an expression. In this case the output is a valid float, so that multiplication with the function argument `#` is implied.
[Answer]
## Lua, ~~30~~ 27 Bytes
```
print(...*os.date"%m.%d%y")
```
Multiply the first command-line argument by the current date in format `mm.ddyy`, which is actually `03.1416`.
[Answer]
## Bash + bc, ~~25~~ 20 bytes
```
date +%m.%d%y\*$1|bc
```
Thanks to [manatwork](https://codegolf.stackexchange.com/users/4198/manatwork) for saving five bytes.
Usage:
```
$ ./pi-round.sh 3
9.4248
```
[Answer]
# 05AB1E, ~~16~~ 13 bytes
```
žfžežg¦¦J*4°/
```
[Try it online.](http://05ab1e.tryitonline.net/#code=xb5mxb5lxb5nwqbCpkoqNMKwLw&input=Mw)
Unfortunately a bug with floats makes this a byte longer :/
Thanks to Adnan for golfing off 3 bytes.
## Explanation
```
žfžežg¦¦J*4°/
žfžežg         push month day year
      ¦¦       slice off the first two chars from the year (2016 -> 16)
        J      join them together into a number
         *     multiply by input
          4°/  divide by 1e4
```
[Answer]
## PowerShell v2+, ~~46~~ ~~28~~ 25 bytes
```
$args[0]*(Date -F "M.dy")
```
Pretty straightforward. Takes input `$args[0]` and multiplies it by the date [formatted as `M.dy`](https://msdn.microsoft.com/en-us/library/8kb3ddd4.aspx) (the `Get-` is implied). Note that this may take a long time to run on v2 as it iterates possible substitutions for `Date` (e.g., checking your `%PATH%` environment variable, etc.) before settling on `Get-Date`.
[Answer]
# R 3.2.4, ~~55~~ ~~51~~ 47 bytes
**edit** I realized I could use `scan` thanks @FryAmTheEggMan. Reduced 4 bytes thanks to @MickyT.
```
scan()*as.numeric(format(Sys.Date(),'%m.%d%y'))
```
First attempt at a golf. Happy pi day!
[Answer]
# GNU Awk, 23 characters
```
$0*=strftime("%m.%d%y")
```
Sample run:
```
bash-4.3$ awk '$0*=strftime("%m.%d%y")' <<< 3
9.4248
```
[Answer]
# Pyth, 19 bytes
```
*Qvs[.d4\..d5>2`.d3
```
[Try it here!](http://pyth.herokuapp.com/?code=*Qvs%5B.d4%5C..d5%3E2%60.d3&input=3&debug=0)  
Only works at 2016-03-14 of course.
## Explanation
```
*Qvs[.d4\..d5>2`.d3   # Q = input
     .d4              # current month
        \.            # dot between month and day
          .d5         # current day of the month
             >2`.d3   # last 2 digits of the year
   s[                 # concat everything into a string
  v                   # eval -> convert to float
*Q                    # multiply with input to get the circumference
```
[Answer]
# PHP, ~~45~~ ~~26~~ ~~25~~ 24 bytes
Uses Windows-1252 encoding
```
<?=$argv[1]*date(~‘Ñ•†);
```
Run like this:
```
echo '<?=$argv[1]*date(~‘Ñ•†);' | php -- 3
```
* Saved 19 bytes by using `date()` instead of `DateTime::format`
* Saved a byte by using the echo tag
* Saved a byte by using ISO-8859 encoding and negating the format string, so no need for double quotes. Might mess up your terminal a bit when running it from CLI, but works.
[Answer]
# Python 2, 58 chars
```
import time
print float(time.strftime("%m.%d%y"))*input()
```
[Try it!](http://ideone.com/fork/nDZbX3)
Explanation:
```
import time                                   # Import time time module
print                                         # Print the following
      float(                                  # Cast to float
            time.strftime("%m.%d%y"))         # Format the time as MM.DDYY
                                     *input() # Multiply by input
```
[Answer]
# JavaScript, ~~41~~ 39 characters
This uses a proprietary **Firefox-only** method.
```
d=>new Date().toLocaleFormat`%m.%d%y`*d
```
Thanks to:
* [Ismael Miguel](https://codegolf.stackexchange.com/users/14732/ismael-miguel) for the template string suggestion (-2 characters).
Sample run (Firefox Web Console):
```
> (d=>new Date().toLocaleFormat`%m.%d%y`*d)(3)
9.4248
```
Note: this will fail in Firebug Console. Seems that Firebug performs some expansion on the template string, transforming ``%m.%d%y`` into ``%__fb_scopedVars(m).d%y`` before passing it to the code.
[Answer]
## Ruby, 40 bytes
```
->n{n*Time.new.strftime('%m.%d%y').to_f}
```
[Answer]
## Mathematica, 54
```
.0001FromDigits[Now@{"Month","Day","YearShort"},100]#&
```
[Answer]
# Vitsy + coreutils, 19 bytes
```
'y%d%.m%+ etad',W*N
```
Explanation:
```
'y%d%.m%+ etad',W*N
'y%d%.m%+ etad'       Push 'date +%m.%d%y' to the stack.
               ,      Execute as shell.
                W     Grab input from STDIN and eval it.
                 *    Multiply the top two items
                  N   Output as a number.
```
Cannot be run in safe mode, as this uses the Runtime's exec method.
[Answer]
# [SpecBAS](https://sites.google.com/site/pauldunn/), 39 bytes
```
1 INPUT n: ?n*VAL DATE$(TIME,"mm.ddyy")
```
Nothing out of the ordinary. Formats date as a string then multiplies the input by the `VAL` (value) of that string.
[Answer]
## Oracle 11g, ~~50~~ 49 bytes
```
SELECT &n*to_char(sysdate,'MM.DDYY')FROM dual;
```
one less byte, thanks to @MickyT
[Answer]
## Python 3, ~~74~~ 54 bytes
using the time module instead of datetime like [Loovjo's Answer](https://codegolf.stackexchange.com/a/75519/49289)
```
import time
lambda n:n*float(time.strftime('%m.%d%y'))
```
**previous solution**
```
from datetime import*
lambda n:n*float(datetime.now().strftime('%m.%d%y'))
```
[Answer]
## Google Sheets, 13 bytes
Bytes are calculated with one byte per character, zero bytes per cell except for the designated input cell, two bytes. The equals sign to start a formula is not counted. (I don't know if this is standard, please correct me if I am wrong.) 
Run snippet to see the code.
```
table {
  empty-cells: show;
}
table,
th,
td {
  border: 1px solid black;
}
```
```
<table border="1">
  <tr>
    <th></th>
    <th>1</th>
    <th>2</th>
    <th>3</th>
  </tr>
  <tr>
    <td>A</td>
    <td>&lt;input></td>
    <td style="text-align:right">3.1416</td>
    <td style="font-family:'Ubuntu Mono',monospace">=<span style="color:rgb(257,142,29)">A1</span>*<span style="color:rgb(126,55,148)">A2</span>
    </td>
  </tr>
</table>
```
This works because you can define your own date formats in Google Sheets. I made it so that it is `<month>.<day><year>`.
[Answer]
## [Pyke](https://github.com/muddyfish/PYKE/tree/master), ~~16~~ 15 bytes, ASCII encoding
```
C867wä%J"bT4^/*
```
Explanation:
```
C867            - b,c,d = year, day, month
    wä          - a = base_96("ä") - 100
      %         - a = a%b
       J"       - a = "".join([a,c,d])
         b      - b = base(a, 10)
          T4^   - a = 10^4
             /  - a = a/b
              * - imp_print(a*eval_or_not(input))
```
or 11 bytes (non-competitive), (adds string singles, 2 digit year, string sumables)
```
C856\.R3sb*
```
Explanation:
```
C856        - a,b,c = 2d_year, day, month
    \.      - d = "."
      R3    - a,b,c = b,c,a
        s   - a = sum(a,b,c)
         b  - a = base(a, 10)
          * - imp_print(a*eval_or_not(input))
```
[Answer]
# [APL](http://goo.gl/9KrKoM), 19 bytes
```
⎕×0.01⊥⌽⍎2⌽8↑2↓⍕⎕TS
```
`⎕TS` is `2016 3 14 12 34 56 789` i.e. March 14rd, 2016 right before 12:35 pm  
`⍕` make into string, i.e. `'2016 3 14 12 34 56 789'`  
`8↑2↓` drop first two (`'20'`) then take next eight (`'16 3 14 '`)  
`2⌽` rotate two characters, giving `' 3 14 16'`  
`⍎` make into numbers (`3 14 16`)  
`⌽` reverse the list, giving `16 14 3`  
`0.01⊥` evaluate in base ¹⁄₁₀₀, = 16 × 0.01² + 15 × 0.01¹ + 3 × 0.01⁰ = 0.0016 + 0.15 + 3 = 3.1416  
`⎕×` multiply with input
or
```
⎕×1E¯4⊥⌽⍎2⌽7↑2↓⍕⎕TS
```
`⎕TS` is `2016 3 14 12 34 56 789`, i.e. March 14rd, 2016 right before 12:35 pm  
`⍕` make into string, i.e. `'2016 3 14 12 34 56 789'`  
`7↑2↓` drop first two (`'20'`) then take next seven (`'16 3 14'`)  
`2⌽` rotate two characters, giving `' 3 1416'`  
`⍎` make into numbers (`3 1416`)  
`⌽` reverse the list, giving `1416 3`  
`1E¯4⊥` evaluate in base ¹⁄₁₀₀₀₀, = 1416 × 0.01¹ + 3 × 0.01⁰ = 0.1416 + 3 = 3.1416  
`⎕×` multiply with input
[Answer]
# JavaScript ES6, ~~68~~ 66 bytes
Saved 2 bytes thanks to dev-null!
```
x=>x*((a=new Date).getMonth()+1+"."+a.getDate()+(a.getYear()-100))
```
Anonymous function. Some uses:
```
f(1)    == 3.1416
f(5)    == 15.708
f(f(2)) == 19.73930112
```
[Answer]
# Tcl/Tk, 58 bytes
```
puts [expr {[gets stdin]*[clock f [clock se] -f %N.%d%g]}]
```
(That's a complete program. If you want to cheat and remove the explicit `puts` statement then it's only 51 bytes -- you'd have to start tclsh and type/paste the following in directly, though:)
```
expr {[gets stdin]*[clock f [clock se] -f %N.%d%g]}
```
[Answer]
# Java 114 bytes
```
public double p(double d){
  return (d*Double.parseDouble(new SimpleDateFormat("MM.ddyy").format(new Date())));
}
```
[Answer]
# Racket, 112 characters
```
(define d(seconds->date(current-seconds)))(*(read)(+(date-month d)(*(date-day d).01)(*(-(date-year d)2e3)1e-4)))
```
Reads the number from input in standard reader syntax.
[Answer]
# TI-84 Basic, 30 bytes
*Works on TI-83/84 calculators; E is the scientific notation token and ~ is the negative token.*
```
Prompt D:getDate:D(Ans(2)+E~4Ans(1)-.2+.01Ans(3
```
**Test Case**
```
D=?3
          9.4248
```
[Answer]
# R 48 bytes
```
d*as.double(format(Sys.Date(),format="%m.%d%y"))
```
[Answer]
# [MATL](https://esolangs.org/wiki/MATL), 17 bytes
```
Z'2$'mm.ddyy'XOU*
```
[**Try it online!**](http://matl.tryitonline.net/#code=WicyJCdtbS5kZHl5J1hPVSo&input=MTA)
```
Z'              % get current date and time as float 
2$'mm.ddyy'XO   % format as a string with custom format 
U               % convert to number 
*               % multiply by implicit input 
```
[Answer]
# TI-BASIC, ~~16~~ ~~13~~ 9 bytes
```
Xround(π,1+min(getDate
```
We round `π` to a number of decimal places equal to the minimum of `{month,day,year}`, and then multiply it by the input.
This is a function that takes input through X. Store it to one of the Y-variables, for example `Y1`, and then call like `Y1([number])` on the homescreen.
]