calculator Documentation

1. Project Overview & Quickstart (microsoft/calculator) Copy Chapter

File: README.md Copy Chapter

Calculator

The Windows Calculator app is a modern Windows app written in C++ and C# that ships pre-installed with Windows.
The app provides standard, scientific, and programmer calculator functionality, as well as a set of converters between various units of measurement and currencies.

Calculator ships regularly with new features and bug fixes. You can get the latest version of Calculator in the Microsoft Store.

Features Copy Chapter

• Standard Calculator functionality which offers basic operations and evaluates commands immediately as they are entered.
• Scientific Calculator functionality which offers expanded operations and evaluates commands using order of operations.
• Programmer Calculator functionality which offers common mathematical operations for developers including conversion between common bases.
• Date Calculation functionality which offers the difference between two dates, as well as the ability to add/subtract years, months and/or days to/from a given input date.
• Calculation history and memory capabilities.
• Conversion between many units of measurement.
• Currency conversion based on data retrieved from Bing.
• Infinite precision for basic
  arithmetic operations (addition, subtraction, multiplication, division) so that calculations
  never lose precision.

Getting started Copy Chapter

Prerequisites:

• Your computer must be running Windows 11, build 22000 or newer.

• Install the latest version of Visual Studio (the free community edition is sufficient).

  • Install the "Universal Windows Platform Development" workload.
  • Install the optional "C++ Universal Windows Platform tools" component.
  • Install the latest Windows 11 SDK.

• Install the XAML Styler Visual Studio extension.

• Get the code:

  text Copy

  git clone https://github.com/Microsoft/calculator.git

• Open src\Calculator.slnx in Visual Studio to build and run the Calculator app.

• For a general description of the Calculator project architecture see ApplicationArchitecture.md.

• To run the UI Tests, you need to make sure that
  Windows Application Driver (WinAppDriver)
  is installed.

Contributing Copy Chapter

Want to contribute? The team encourages community feedback and contributions. Please follow our contributing guidelines.

If Calculator is not working properly, please file a report in the Feedback Hub.
We also welcome issues submitted on GitHub.

Roadmap Copy Chapter

For information regarding Windows Calculator plans and release schedule, please see the Windows Calculator Roadmap.

Graphing Mode Copy Section

Adding graphing calculator functionality is on the project roadmap and we hope that this project can create a great end-user experience around graphing. To that end, the UI from the official in-box Windows Calculator is currently part of this repository, although the proprietary Microsoft-built graphing engine, which also drives graphing in Microsoft Mathematics and OneNote, is not. Community members can still be involved in the creation of the UI, however developer builds will not have graphing functionality due to the use of a mock implementation of the engine built on top of a
common graphing API.

Diagnostic Data Copy Chapter

This project collects usage data and sends it to Microsoft to help improve our products and services.
Read our privacy statement to learn more.
Diagnostic data is disabled in development builds by default, and can be enabled with the SEND_DIAGNOSTICS
build flag.

Currency Converter Copy Chapter

Windows Calculator includes a currency converter feature that uses mock data in developer builds. The data that
Microsoft uses for the currency converter feature (e.g., in the retail version of the application) is not licensed
for your use. The mock data will be clearly identifiable as it references planets instead of countries,
and remains static regardless of selected inputs.

Reporting Security Issues Copy Chapter

Please refer to SECURITY.md.

License Copy Chapter

Copyright (c) Microsoft Corporation. All rights reserved.

Licensed under the MIT License.

File: docs/ApplicationArchitecture.md Copy Chapter

Application Architecture

Windows Calculator is a C++/CX application, built for the Universal Windows Platform (UWP).
Calculator uses the XAML UI framework, and the project follows the Model-View-ViewModel (MVVM)
design pattern. This document discusses each of the layers and how they are related to the three Visual Studio projects
that build into the final Calculator application.

Table of Contents Copy Chapter

• View
  • VisualStates
  • Data-Binding
• ViewModel
  • PropertyChanged Events
• Model

View Copy Chapter

The View layer is contained in the Calculator project. This project contains mostly XAML files
and various custom controls that support the UI. App.xaml contains many of the static and
theme resources that the other XAML files will reference. Its code-behind file, App.xaml.cs,
contains the main entry point to the application. On startup, it navigates to the main page.

rootFrame.Navigate(typeof(MainPage), argument)

In Calculator, there is only one concrete Page class: MainPage.xaml. MainPage is the root
container for all the other application UI elements. As you can see, there's not much content. MainPage uses a
NavigationView control to display the toggleable navigation menu, and empty containers for delay-loaded UI elements.
Of the many modes that Calculator shows in its menu, there are actually only three XAML files that MainPage needs to
manage in order to support all modes. They are:

• Calculator.xaml: This UserControl is itself a container for the Standard,
  Scientific, and Programmer modes.
• DateCalculator.xaml: Everything needed for the DateCalculator mode.
• UnitConverter.xaml: One UserControl to support every Converter mode.

VisualStates Copy Section

VisualStates are used to change the size, position, and appearance (Style) of UI elements
in order to create an adaptive, responsive UI. A transition to a new VisualState is often triggered by specific
window sizes. Here are a few important examples of VisualStates in Calculator. Note that it is not a
complete list. When making UI changes, make sure you are considering the various VisualStates and layouts that
Calculator defines.

History/Memory Dock Panel expansion

In the Standard, Scientific, and Programmer modes, the History/Memory panel is exposed as a flyout in small window sizes.
Once the window is resized to have enough space, the panel becomes docked along the edge of the window.

Scientific mode, inverse function button presence

In the Scientific mode, for small window sizes there is not enough room to show all the function buttons. The mode
hides some of the buttons and provides a Shift (↑) button to toggle the visibility of the collapsed rows. When the
window size is large enough, the buttons are re-arranged to display all function buttons at the same time.

Unit Converter aspect ratio adjustment

In the Unit Converter mode, the converter inputs and the numberpad will re-arrange depending on if the window is in
a Portrait or Landscape aspect ratio.

Data-Binding Copy Section

Calculator uses data binding to dynamically update the properties of UI elements. If this concept
is new for you, it's also worth reading about data binding in depth.

The x:Bind markup extension is a newer replacement for the older Binding style. You may see both
styles in the Calculator codebase. Prefer x:Bind in new contributions because it has better performance. If you need
to add or modify an existing Binding, updating to x:Bind is a great first step. Make sure to read and understand
the difference between the two styles, as there are some subtle behavioral changes. Refer to the
binding feature comparison to learn more.

ViewModel Copy Chapter

The ViewModel layer is contained in the CalcViewModel project. ViewModels provide a source of
data for the UI to bind against and act as the intermediary separating pure business logic from UI components that
should not care about the model's implementation. Just as the View layer consists of a hierarchy of XAML files, the
ViewModel consists of a hierarchy of ViewModel files. The relationship between XAML and ViewModel files is often 1:1.
Here are the notable ViewModel files to start exploring with:

• ApplicationViewModel.h: The ViewModel for MainPage.xaml. This ViewModel
  is the root of the other mode-specific ViewModels. The application changes between modes by updating the Mode property
  of the ApplicationViewModel. The ViewModel will make sure the appropriate ViewModel for the new mode is initialized.
• StandardCalculatorViewModel.h: The ViewModel for Calculator.xaml.
  This ViewModel exposes functionality for the main three Calculator modes: Standard, Scientific, and Programmer.
• DateCalculatorViewModel.h: The ViewModel for DateCalculator.xaml.
• UnitConverterViewModel.h: The ViewModel for UnitConverter.xaml.
  This ViewModel implements the logic to support every converter mode, including Currency Converter.

PropertyChanged Events Copy Section

In order for data binding to work, ViewModels need a way to inform the XAML framework about
updates to their member properties. Most ViewModels in the project do so by implementing the
INotifyPropertyChanged interface. The interface requires that the class provides a
PropertyChanged event. Clients of the ViewModel (such as the UI), can register for the
PropertyChanged event from the ViewModel, then re-evaluate bindings or handle the event in code-behind when the
ViewModel decides to raise the event. ViewModels in the Calculator codebase generally uses a macro, defined in the
Utils.h utility file, to implement the INotifyPropertyChanged interface. Here is a standard
implementation, taken from ApplicationViewModel.h.

[Windows::UI::Xaml::Data::Bindable]
public ref class ApplicationViewModel sealed : public Windows::UI::Xaml::Data::INotifyPropertyChanged
{
public:
    ApplicationViewModel();

    OBSERVABLE_OBJECT();

The OBSERVABLE_OBJECT() macro defines the required PropertyChanged event. It also defines a private
RaisePropertyChanged helper function for the class. The function takes a property name and raises a
PropertyChanged event for that property.

Properties that are intended to be the source for a data binding are also typically implemented with a macro. Here is
one such property from ApplicationViewModel:

OBSERVABLE_PROPERTY_RW(Platform::String^, CategoryName);

The OBSERVABLE_PROPERTY_RW macro defines a Read/Write property that will raise a PropertyChanged event if its value
changes. Read/Write means the property exposes both a public getter and setter. For efficiency and to avoid raising
unnecessary PropertyChanged events, the setter for these types of properties will check if the new value is
different from the previous value before raising the event.

From this example, either ApplicationViewModel or clients of the class can simply assign to the CategoryName
property and a PropertyChanged event will be raised, allowing the UI to respond to the new CategoryName value.

Model Copy Chapter

The Model for the Calculator modes is contained in the CalcManager project. It consists of three layers: a CalculatorManager, which relies on a CalcEngine, which relies on the Ratpack.

CalculatorManager Copy Section

The CalculatorManager contains the logic for managing the overall Calculator app's data such as the History and Memory lists, as well as maintaining the instances of calculator engines used for the various modes. The interface to this layer is defined in CalculatorManager.h.

CalcEngine Copy Section

The CalcEngine contains the logic for interpreting and performing operations according to the commands passed to it. It maintains the current state of calculations and relies on the RatPack for performing mathematical operations. The interface to this layer is defined in CalcEngine.h.

RatPack Copy Section

The RatPack (short for Rational Pack) is the core of the Calculator model and contains the logic for
performing its mathematical operations (using infinite precision arithmetic
instead of regular floating point arithmetic). The interface to this layer is defined in ratpak.h.

File: docs/ManualTests.md Copy Chapter

Calculator Manual Tests

These manual tests are run before every release of the Calculator app.

Smoke Tests Copy Chapter

Calculators Copy Section

Math in Standard Calculator Copy Section

Test 1
Steps:

1. From the Standard Calculator page, input “3”, “+”, “3”, “Enter” on the keyboard
   *Expected: “6” shows up in the display *
2. Input “4”, “-”, “2”, “=” using the in-app buttons
   Expected: “2” shows up in the display

Test 2
Steps:

1. From the Standard Calculator page, input “3”, “+”, “3”, “Enter” on the keyboard
2. Navigate to the History pane, and verify that “3 + 3 = 6” shows up in the pane
3. Input “MS” using the in-app buttons
4. Navigate to the Memory pane
   Expected: “6” shows up in the pane

Math in Scientific Calculator Copy Section

Test 1
Steps:

1. From the Scientific Calculator page, input “3”, “^”, “3”, “Enter” on the keyboard
   Expected: “27” shows up in the display

Test 2
Steps:

1. Input “5”, “n!”, “=” using the in-app buttons
   Expected: “120” shows up in the display

Math in Programmer Calculator Copy Section

Test 1
Steps:

1. From the Programmer Calculator page, input “1”, “&”, “0”, “Enter” on the keyboard
   Expected: “0” shows up in the display

Test 2
Steps:

1. Input “15” using the in-app buttons and select “HEX”
   Expected: “F” shows up in the display and the letters A-F show up as in-app buttons

Converters Copy Section

Converter Usage
Steps:

1. From the Length Converter page, select “kilometers” as the unit type in the input field and input “5” using the keyboard
2. Select “miles” as the unit type in the output field
   Expected: The output starts with is “3.106856”

Always-on-Top Copy Section

Test 1
Steps:

1. Launch the "Calculator" app and navigate to "Standard" Calculator
   Expected: Always-on-Top button's tooltip says "Keep on top"
2. Click the Always-on-Top button
   Expected: Always-on-Top button's tooltip now says "Back to full view"
3. Launch the "Notepad" app and put it in full-screen mode
   Expected: Calculator is still on top of Notepad and in Always-on-Top mode

Test 2
Steps:

1. Launch the "Calculator" app and from "Standard" Calculator, input “3”, “+”, “3” (do not press “Enter”)
2. Tab over the Always-on-Top button and press "Enter" on the keyboard
   Expected: The application title, hamburger menu, calculator type title, calculation expression (the secondary line above the main display), history button and memory buttons are no longer visible. The main display shows "3"
3. Press “Enter”
   Expected: The main display shows "6"
4. Press "Ctrl-H" on the keyboard
   Expected: Nothing happens (history keyboard shortcuts are disabled)
5. Press "Ctrl-P" on the keyboard, then tab over the Always-on-Top button and press "Enter" on the keyboard again
6. Open the Memory panel
   Expected: Nothing is stored in memory (memory keyboard shortcuts are disabled in Always-on-Top mode) and "6" is in history

Test 3
Steps:

1. Launch the "Calculator" app and from "Standard" Calculator, click the Always-on-Top button
2. Resize the window horizontally
   Expected: The buttons automatically expand or shrink to fit the available screen size
3. Resize the window vertically
   Expected: The buttons automatically expand or shrink to fit the available screen size and the percent, square-root, squared and reciprocal buttons disappear when the screen height is small
4. Click the Always-on-Top button again
   Expected: Calculator is in Standard mode and the original window layout from before Step 1 is restored
5. Click the Always-on-Top button again
   Expected: Calculator is in Always-on-Top mode and the window size from after Step 3 is restored
6. Close the "Calculator" app
7. Launch the "Calculator" app again and click the Always-on-Top button
   Expected: The window size from right before closing from Always-on-Top mode (ie. after Step 5) is restored

Test 4
Steps:

1. Launch the "Calculator" app and from "Standard" Calculator, click the Always-on-Top button
2. Input "/", "0", “Enter” on the keyboard
   Expected: "Result is undefined" is displayed in the system default app language
3. Click the Always-on-Top button again
   *Expected: Calculator is in Standard mode and all operator (except for "CE", "C", "Delete" and "=") and memory buttons are disabled

Test 5
Steps:

1. Launch the "Calculator" app and navigate to "Scientific" Calculator
   Expected: The Always-on-Top button is hidden
2. Navigate to "Standard" Calculator
   Expected: The Always-on-Top button is visible

Basic Verification Tests Copy Chapter

Launch App Test
Steps:

1. Press the Windows key.
2. Navigate to "all apps".
3. Look for "Calculator".
4. Click to launch the "Calculator" app.
   Expected: The calculator app launches gracefully.

All Calculators Test: Verify All Numbers & Input Methods
Steps:

1. Launch the "Calculator" app.
2. Navigate to "Standard" Calculator.
3. Mouse Input
   Expected: All numbers work via mouse click.
4. Keyboard Input:
   Expected: All numbers work via number pad.
5. Navigate to "Scientific" Calculator and Repeat Steps 3-5
   Expected: Steps 3-5 pass in Scientific mode
6. Navigate to "Programmer" Calculator and Repeat Steps 3-5
   Expected: Steps 3-5 pass in Programmer mode

All Calculators Test: Verify Basic Arithmetic Functions
Steps:

1. Launch the "Calculator" app.
2. Navigate to "Standard" Calculator.
3. Using the Number Pad and Mouse perform the following arithmetic functions and verify the result.
   a. (+) Addition
   b. (-) Subtraction
   c. (x) Multiplication
   d. (÷) Division
   e. (1/x) Reciprocal
   f. (√) Square Root
   g. (x²) Squared
   h. (x³) Cubed
   i. (%) Percent
   j. (±) Positive / Negative
   k. (=) Equals
   l. Delete Button (flag with x in it)
   m. [CE] Clear
   n. [C] Global Clear
   o. (.) Decimal
4. Navigate to "Scientific" Calculator and Repeat Steps 3-19.
5. Navigate to "Programmer" Calculator and Repeat Steps 3-18 (No Decimal in Programming Calc).

Scientific Calculator Test: Verify advanced arithmetic functions
Steps:

1. Launch the "Calculator" app.
2. Navigate to "Scientific" Calculator.
3. Using the Number Pad and Mouse perform the following arithmetic functions and verify the result.
   a. (xʸ) Xth Power of Y
   b. (y√x) Y Root of X
   c. (10ˣ) 10 Power of X
   d. (ex) E Power of X
   e. (π) Pi
   f. (n!) Factorial
   g. (Ln) Natural Logarithm
   h. (Log) Logarithm
   i. (Exp) Exponential
   j. (dms) Degrees, Minutes, Seconds
   k. (deg) Degrees
   l. (Mod) Modulo
   m. “( )" Parenthesis

All Calculators Test: Verify memory functions
Steps:

1. Launch the "Calculator" app.
2. Navigate to "Standard" Calculator.
3. Perform a calculation and press the MS button.
4. If small scale, Select the (M) with the drop down arrow
   Expected: Calculation from previous step is present.
5. Click the (M+) Add to Memory.
   Expected: Previous calculation is added to itself.
6. Click the (M-) Subtract from Memory.
   Expected: Previous calculation is subtracted from the base calculation.
7. Click the (MR) Memory Recall.
   Expected: Previous calculation is made primary (This is not available in the Programmer mode).
8. Check the MC button.
   Expected: The stored information is cleared.
9. Navigate to "Scientific" Calculator and Repeat Steps 3-8.
   Expected: All in "Scientific" mode.
10. Navigate to "Programmer" Calculator and Repeat Steps 3-8.
    Expected: All in "Programmer" mode.

Scientific Calculator Test: Verify trigonometric functions
Steps:

1. Launch the "Calculator" app.
2. Navigate to "Scientific" Calculator.
3. Using the Number Pad and Mouse perform the following trigonometric functions and verify the result.
4. Sine (sin)
5. Cosine (cos)
6. Tangent (tan)
7. Inverse Sine (sin-1)
8. Inverse Cosine (cos-1)
9. Inverse Tangent (tan-1) Inverse Tangent:
10. Press (HYP) for Hyperbolic trig functions:
    Expected: Trig function buttons show hyperbolic trig functions.
11. Hyperbolic Sine (sinh)
12. Hyperbolic Tangent (tanh)
13. Hyperbolic Cosine (cosh)
14. Inverse Hyperbolic Sine (sinh-1)
15. Inverse Hyperbolic Tangent (tanh-1)
16. Inverse Hyperbolic Cosine (cosh-1)

Programmer Calculator Test: Verify logical functions
Steps:

1. Launch the "Calculator" app
2. Navigate to "Programmer" Calculator.
3. Using the Number Pad and Mouse perform the following trigonometric functions and verify the result.
4. Rotate Left (RoL) Logical Operator:
   01011001 rol 3 = 11001010.
5. Rotate Right (RoR) Logical Operator:
   01011001 RoR 3 = 00101011.
6. (Lsh) Logical Operator:
   (10 multiplied by 2 three times)
   10 Lsh 3 = gives 80.
   10.345 Lsh 3 = also gives 80.
7. (Rsh) Logical Operator:
   (16 divided by 2 twice)
   16 Rsh 2 = gives 4.
   16.999 Rsh 2 = also gives 4.
8. (Or) Logical Operator
   101 OR 110 = gives 111.
9. Exclusive Or (Xor) Logical Operator:
   101 XOR 110 = gives 11.
10. (Not) Logical Operator
    NOT 1001100111001001 =
    0110011000110110.
11. (And) Logical Operator
    101 AND 110 = gives 100.
12. (Mod) Logical Operator
    Remainder of integer division (Modulo x)
13. "( )" Parenthesis

All Calculators and Converters Test: Verify scaling functions and languages
Steps:

1. Launch the "Calculator" app.
2. For All Modes: While scaling in both directions to capacity
   Expected: Elements like Memory and History are shifted or integrated appropriately.
3. In Any Mode: While at the Smallest scale, Select the Menu Button
   Expected: The menu items are scrollable with nothing overlapping.
4. While in the Menu: Check the About Page
   Expected: Everything in the about page fits into its window
5. For Scientific Mode: At a Larger Scale
   Expected: All buttons are present and the 2nd button is grayed out.
6. For Scientific Mode: At a Smaller Scale
   Expected: All buttons are present and the 2nd button is able to be toggled.
7. For Programmer Mode: At a Any Scale
   Expected: All buttons are present and the 2nd button is able to be toggled.
8. For Converter Mode: While Scaling
   Expected: The number pad and input areas move around each other gracefully.
9. For Graphing Mode: While Scaling
   Expected: The number pad, graph area, and input areas move around each other gracefully.
10. Changing Language: Open Settings app > Time & language > Region & language > Add a language > Select a Right to Left (RTL) language such as Hebrew > Install the associated files> Set it to the system default.
11. Set the system number format preference: Open a Run dialog (WIN + R) > type ‘intl.cpl’ > Enter > In the format dropdown list > Select Hebrew > Apply.
12. Initiating the change: Package has completed installing > Sign out > Sign in. (This change to the app may also require a reinstallation of the build)
13. Repeat Steps 2-6 again in a (RTL) language.
    Expected: No elements fall out of intended boundaries.

All Calculators Test: Verify toggling functions
Steps:

1. Launch the "Calculator" app.
2. For Standard & Scientific Modes: While in the Smallest scale, verify that the History Icon brings up the history panel gracefully and is displayed appropriately.
   For Scientific Mode: At a Smaller Scale
   Verify the following:
3. Grad / Deg / Rad
   Perform a trig function
   Expected: The answer to the function is in the selected grad/deg/rad. Repeat for each of the modes.
4. (Hyp) Hyperbolic
   Expected: Sin toggles to Sinh, Cos toggles to Cosh, Tan toggles to Tanh.
5. (F-E key) Floating Point Notation & Scientific Notation.
   Expected: Display toggles between floating point and Scientific notation.
   For Programmer Mode
   Verify the following:
6. "Bit Toggling Keypad":
   Expected: In app keypad changes to represent Bits (1s and 0s).
7. "QWORD / DWORD / WORD / BYTE":
   Expected: Toggles as expected.
8. "Hex" Hexadecimal:
   Expected: A B C D E F become active and user can use them. A maximum of 16 characters can be entered.
9. "Dec" Decimal:
   Expected: A B C D E F are inactive. A maximum of 19 characters can be entered.
10. "Oct" Octal:
    Expected: A B C D E F 8 9 are inactive. A maximum of 22 characters can be entered.
11. "Bin" Binary:
    Expected: A B C D E F 2 3 4 5 6 7 8 9 are inactive. A maximum of 64 characters can be entered.

Graphing Mode Test: Verify Graphing mode functions
Steps:

1. Launch the "Calculator" app
2. Navigate to "Graphing" Calculator
3. Enter a function of x in the input field
   Expected: Function is plotted in the graph area. Line color matches the colored square next to the input field
4. Select the "+" button below the function input and enter more functions in the fields that appear
   Expected: All functions are plotted in the graph area and match the colors of the input field squares
5. Select the colored square for any function
   Expected: Visibility of the function in the graph is toggled off/on
6. Select the "Zoom In", "Zoom Out", and "Reset View' buttons in the graph area
   Expected: Both X and Y axes zoom in, out, and revert to default settings, respectively
7. Select the Trace button, then click + drag the graph until the red square is near a graphed function
   Expected: Closest (X, Y) coordinates of the function to the red square are displayed with a black dot to indicate the location
8. Enter "y=mx+b" into a function input field, then select "Variables" button
   Expected: y=x+1 function is plotted in the graph, "Variables" modal window shows two variables "m" and "b" with values set to 1.
9. Adjust the value, minimum, maximum, and step for each variable
   Expected: y=mx+b graph adjusts to the new values for m and b, step size changes the increments of the slider for each value
10. Share the graph via OneNote, Outlook/Mail, Twitter, and Feedback Hub
    Expected: Modifiable message that contains an image of the graph customized for the chosen application opens
11. Verify Key Graph Features tab shows the correct information for the following functions:
    (Note: IP = Inflection Points, VA = Vertical Asymptotes, HA = Horizontal Asymptotes, OA = Oblique Asymptotes)
    a. y=x
    Expected: Domain: ⁅𝑥∈ℝ⁆; Range: ⁅y∈ℝ⁆; X/Y Intercepts: (0)/(0); Max: none; Min: none; IP: none; VA: none; HA: none; OA: none; Parity: Odd; Monotonicity: (-∞, ∞) Increasing
    b. y=1/x
    Expected: Domain: ⁅𝑥≠0⁆; Range: ⁅y∈ℝ{0}⁆; X/Y Intercepts: ø/ø; Max: none; Min: none; IP: none; VA: x=0; HA: y=0; OA: none; Parity: Odd; Monotonicity: (0, ∞) Decreasing, (-∞, 0) Increasing
    c. y=x^2
    Expected: Domain: ⁅𝑥∈ℝ⁆; Range: ⁅y∈{0, ∞)⁆; X/Y Intercepts: (0)/(0); Max: none; Min: (0,0); IP: none; VA: none; HA: none; OA: none; Parity: Even; Monotonicity: (0, ∞) Increasing, (-∞, 0) Decreasing
    d. y=x^3
    Expected: Domain: ⁅𝑥∈ℝ⁆; Range: ⁅y∈ℝ⁆; X/Y Intercepts: (0)/(0); Max: none; Min: none; IP: (0,0); VA: none; HA: none; OA: none; Parity: Odd; Monotonicity: (-∞, ∞) Increasing
    e. y=e^x
    Expected: Domain: ⁅𝑥∈ℝ⁆; Range: ⁅y∈(0, ∞)⁆; X/Y Intercepts: ø/(1); Max: none; Min: none; IP: none; VA: none; HA: y=0; OA: none; Parity: none; Monotonicity: (-∞, ∞) Increasing
    f. y=ln(x)
    Expected: Domain: ⁅𝑥>0⁆; Range: ⁅y∈ℝ⁆; X/Y Intercepts: (1)/ø; Max: none; Min: none; IP: none; VA: x=0; HA: none; OA: none; Parity: none; Monotonicity: (0, ∞) Increasing
    g. y=sin(x)
    Expected: Domain: ⁅𝑥∈ℝ⁆; Range: ⁅𝑦∈[−1,1]⁆; X/Y Intercepts: (⁅𝜋n1,n1∈ℤ⁆)/(0); Max: ⁅(2𝜋n1+𝜋/2,1),n1∈ℤ⁆; Min: ⁅(2𝜋n1+3𝜋/2,−1),n1∈ℤ⁆; IP: ⁅(𝜋n1,0),n1∈ℤ⁆; VA: none; HA: none; OA: none; Parity: Odd; Monotonicity: ⁅(2𝜋n1+𝜋/2,2𝜋n1+3𝜋/2),n1∈ℤ⁆ Decreasing; ⁅(2𝜋n1+3𝜋/2,2𝜋n1+5𝜋/2),n1∈ℤ⁆ Increasing; Period: 2𝜋
    h. y=cos(x)
    Expected: Domain: ⁅𝑥∈ℝ⁆; Range: ⁅𝑦∈[−1,1]⁆; X/Y Intercepts: (⁅𝜋n1+𝜋/2,n1∈ℤ⁆)/(1); Max: ⁅(2𝜋n1,1),n1∈ℤ⁆; Min: ⁅(2𝜋n1+𝜋,-1),n1∈ℤ⁆; IP: ⁅(𝜋n1+𝜋/2,0),n1∈ℤ⁆; VA: none; HA: none; OA: none; Parity: Even; Monotonicity: ⁅(2𝜋n1+𝜋,2𝜋n1+2𝜋),n1∈ℤ⁆ Increasing, ⁅(2𝜋n1,2𝜋n1+𝜋),n1∈ℤ⁆ Decreasing; Period: 2𝜋
    i. y=tan(x)
    Expected: Domain: ⁅x≠𝜋n1+𝜋/2,∀n1∈ℤ⁆; Range: ⁅𝑦∈ℝ⁆; X/Y Intercepts: (x=𝜋n1, n1 ∈ℤ)/(0); Max: none; Min: none; IP: x=𝜋n1, n1 ∈ℤ; VA: x=𝜋n1+𝜋/2, n1∈ℤ; HA: none; OA: none; Parity: Odd; Monotonicity: ⁅(𝜋n1+𝜋/2,𝜋n1+3𝜋/2),n1∈ℤ⁆ Increasing; Period: 𝜋
    j. y=sqrt(25-x^2)
    Expected: Domain: ⁅x∈[-5,5]⁆; Range: ⁅𝑦∈[0,5]⁆; X/Y Intercepts: (5),(-5)/(5); Max: (0,5); Min: (-5,0) and (5,0); IP: none; VA: none; HA: none; OA: none; Parity: Even; Monotonicity: (0,5) Decreasing, (-5,0) Increasing
    k. y=(-3x^2+2)/(x-1)
    Expected: Domain: ⁅x≠1⁆; Range: ⁅𝑦∈(-∞, -2√3 - 6}U{2√3 -6,∞⁆; X/Y Intercepts: (-√6/3),(√6/3)/(-2); Max: ⁅(√3/3+1,-2√3−6)⁆; Min: ⁅(−√3/3+1,2√3−6)⁆; IP: none; VA: x=1; HA: none; OA: y=-3x-3; Parity: none; Monotonicity: (√3/3+1,∞) Decreasing, (1,√3/3+1,) Increasing(-√3/3+1,1), Increasing, (-∞,-√3/3+1) Decreasing
    l. y=sin(sin(x)) ("too complex" error test)
    Expected: Domain: ⁅𝑥∈ℝ⁆; Range: Unable to calculate range for this function; X/Y Intercepts: none; Max: none; Min: none; IP: none; VA: none; HA: none; OA: none; Parity: odd; Monotonicity: Unable to determine the monotonicity of the function
    These features are too complex for Calculator to calculate: Range, X Intercept, Period, Minima, Maxima, Inflection Points, Monotonicity
    m. y=mx+b
    Expected: Analysis is not supported for this function

Date Calculation Test: Verify dates can be calculated.
Steps:

1. Launch the "Calculator" app
2. Navigate to "Date Calculation" Calculator
3. With "Difference between dates" Selected
   Change the various date input fields
   Expected: From and To reflect dates input respectively.
4. With "Add or Subtract days" Selected
   Change the various date input fields
   Expected: Verify changes made to both add and subtract reflect input respectively.

Currency Converter Test: Verify conversion & updating current currency rates.
Steps:

1. Launch the "Calculator" app.
2. Navigate to "Currency Converter" Calculator.
3. Select 2 Currency types from the dropdowns & enter a "1" into a conversion slot.
   Expected: The currency is slotted properly and converted rate matches the ratio provided under the selected currency types.
4. Click "Updated"
   Expected: Display matches PC's date and time.
5. After at least a minute: Select "Update rates" & Check "Updated" again:
   Expected: The "Update Rates" button changes the date and time to match the computer's current date and time.

All Calculators Test: Hotkeys: Verify Hot Key function.
Steps:

1. Launch the "Calculator" app.

   For All Applicable Modes verify the following (note: only 11-15 and 20 work in Always-on-Top mode):

2. Press Alt +1 to enter "Standard" mode
   Expected: Move to "Standard" screen.

3. Press Alt +2 to enter "Scientific" mode
   Expected: Move to "Scientific" screen.

4. Press Alt +3 to enter "Programmer" mode
   Expected: Move to "Programming" screen.

5. Press Alt +4 to enter "Date Calculation" mode
   Expected: Move to "Date Calculation" screen.
   6 Press Alt +5 to enter "Graphing" mode
   Expected: Move to "Graphing" screen.

6. Press Ctrl +M to Store in Memory

7. Press Ctrl +P to Add to Active Memory

8. Press Ctrl +Q to Subtract form Active Memory

9. Press Ctrl +R to Recall from Memory

10. Press Ctrl +L to Clear from Memory

11. Press Delete to Clear Current Input 'CE'

12. Press Esc to Full Clear Input 'C'

13. Press F9 to Toggle '±'

14. Press R to Select '1/x'

15. Press @ to Select '√'

16. Press Ctrl + H to Toggle History Panel
    Expected: Function when in small scale window.

17. Press Up arrow to Move up History Panel
    Expected: Function when in small scale window.

18. Press Down arrow to Move Down History Panel
    Expected: Function when in small scale window.

19. Press Ctrl + Shift + D to Clear History Panel
    Expected: Function when in small scale window.

20. Press Spacebar to Repeat Last Input

    Verify the following in Scientific Mode

21. Press F3 to Select 'DEG'

22. Press F4 to Select 'RAD'

23. Press F5 to Select 'GRAD'

24. Press Ctrl +G to Select '10ˣ'

25. Press Ctrl +Y to Select 'y√x'

26. Press Shift +O to Select 'sin-1'

27. Press Shift + S to Select 'cos-1'

28. Press Shift +T to Select 'tan-1'

29. Press Ctrl +O to Select 'Cosh'

30. Press Ctrl +S to Select 'Sinh'

31. Press Ctrl +T to Select 'Tanh'

32. Press D to Select 'Mod'

33. Press L to Select 'log'

34. Press M to Select 'dms'

35. Press N to Select 'ln'

36. Press Ctrl +N to Select 'ex'

37. Press O to Select 'Cos'

38. Press P to Select 'π'

39. Press Q to Select 'x²'

40. Press S to Select 'Sin'

41. Press T to Select 'Tan'

42. Press V to Toggle 'F-E'

43. Press X to Select 'Exp'

44. Press Y or ^ to Select 'xʸ'

45. Press # to Select 'x³'

46. Press ! to Select 'n!'

    Verify the following in Programmer Mode

47. Press F2 to Select 'DWORD'

48. Press F3 to Select 'WORD'

49. Press F4 to Select 'BYTE'

50. Press F5 to Select 'HEX'

51. Press F6 to Select 'DEC'

52. Press F7 to Select 'OCT'

53. Press F8 to Select 'BIN'

54. Press F12 to Select 'QWORD'

55. Press A-F to Input in HEX

56. Press J to Select 'RoL'

57. Press K to Select 'RoR'

58. Press < to Select 'Lsh'

59. Press > to Select 'Rsh'

60. Press % to Select 'Mod'

61. Press | to Select 'Or'

62. Press ~ to Select 'Not'

63. Press & to Select 'And'

    Verify the following in Graphing Mode

64. Press x to Select 'x'

65. Press y to Select 'y'

66. Press Ctrl +[Numpad+] to Select 'Zoom In'

67. Press Ctrl +[Numpad-] to Select 'Zoom Out'

Localization Tests Copy Chapter

Always-on-Top Copy Section

Test 1
Steps:

1. Change the system default app language to Arabic
2. Launch the "Calculator" app and from "Standard" Calculator, click the Always-on-Top button
   Expected: UI/Menu is localized (for example, the title bar buttons is in right-to-left order)
3. Input "/", "0", “Enter” on the keyboard
   Expected: Error message is in Arabic

Ease of Access Tests Copy Chapter

Always-on-Top Copy Section

Test 1
Steps:

1. Open the "Narrator" app
2. Launch the "Calculator" app and from "Standard" Calculator, click the Always-on-Top button
3. Tab over the Always-on-Top button
   Expected: Narrator reads the localized version of "Back to full view"
4. Tab over the main results field
   Expected: Narrator reads the localized version of exactly what's displayed (ie. "0")
5. Tab over the rest of the UI elements
   Expected: Narrator reads the localized version of the UI elements' contents

File: docs/NewFeatureProcess.md Copy Chapter

New feature process

Where do I submit my idea for a new feature? Copy Chapter

The easiest way to submit new feature requests is through
Feedback Hub.
In Feedback Hub, any Windows user (even if they aren't on GitHub) can upvote suggestions. The
Calculator team reviews these suggestions regularly, and when we're ready to work on an idea we
create feature pitch issues here on GitHub.

But using Feedback Hub is not required—you can create feature pitches too! This document
explains the elements of a good pitch and how we'll guide features from a pitch to a finished
product. The Feature Tracking board shows
all the features we're working on and where they're at in the process.

Do I need to follow this process? Can I just start coding and submit a PR? Copy Chapter

You do not need to follow this process for bug fixes, performance improvements, or changes to the
development tools. To contribute these changes,
discuss the proposed change in an issue
and then submit a pull request.

You do need to follow this process for any change which "users will notice". This applies
especially to new features and major visual changes.

Step 1: Feature pitch Copy Chapter

Feature pitches are submitted as issues on GitHub using the
Feature Request template.
We encourage discussion on open issues, and as discussion progresses we will edit the issue description to refine the
idea until it is ready for review.

We review pitches regularly, and will approve or close issues based on whether they broadly align with the
Calculator roadmap. Approved pitches are moved
into planning on the feature tracking board.

Step 2: Planning Copy Chapter

For most features, the output of this phase is a specification which describes how the feature will work, supported by
design renderings and code prototypes as needed. The original issue will continue to track the overall progress of the
feature, but we will create and iterate on spec documentation in the
Calculator Spec repo. Sometimes we'll learn new things about a feature
proposal during planning, and we'll edit or close the original pitch.

We welcome community participation throughout planning. The best ideas often come from trying many ideas during
the planning phase. To enable rapid
experimentation, we encourage developing and sharing rough ideas—maybe even with pencil and
paper—before making designs pixel-perfect or making code robust and maintainable.

After the spec review is completed, we will move the issue
into implementation on the feature tracking board. In some cases,
all of the details of an idea can be captured concisely in original feature pitch. When that happens, we may move ideas
directly into implementation.

Step 3: Implementation Copy Chapter

A feature can be implemented by the original submitter, a Microsoft team member, or by other
community members. Code contributions and testing help are greatly appreciated. Please let everyone know if you're
actively working on a feature to help avoid duplicated efforts from others.

You might be able to reuse code written during the prototype process, although there will typically
be more work required to make the solution robust. Once the code is ready, you can begin
submitting pull requests.

Technical review Copy Section

As with all changes, the code for new features will be reviewed by a member of the Microsoft team
before being checked in to the master branch.

New features often need a more thorough technical review than bug fixes. When reviewing code for
new features, the Microsoft team considers at least these items:

• All items on the Accessibility checklist
  should be addressed.
• All items on the Globalization checklist
  should be addressed.
• The change should be tested on the oldest version of Windows that the app supports. You can
  find this version number in AppxManifest.xml. Any calls to APIs newer than that version should be
  conditionally enabled.
• The change should use only supported APIs. If there are any questions about whether legacy or
  undocumented APIs are in use, the Windows App Certification Kit
  should be run to check.
• The change should save the user's progress if the app is
  suspended and resumed.
  Code to handle these cases should be
  tested in the Visual Studio debugger.
• If the change has customizations for particular device families,
  it should be tested on those device families.
• The change should be tested with the app window resized to the smallest possible size.
• The change should be tested with light, dark, and high contrast themes. It should honor the
  user's preferred accent color.
• If the change adds new libraries or other dependencies:
  • If the library is packaged with the app, the increased size of the binaries should be
    measured.
  • If the library is not maintained by Microsoft, the Microsoft team will need to set up a
    plan to monitor the upstream library for changes like security fixes.
  • If the library is being used under an open-source license, we must comply with the license
    and credit third parties appropriately.
• If the change adds code which runs during the app's startup path, or adds new XAML elements
  which are loaded at startup:
  • Run the perf tests to measure any increase in startup time. Move work out of the startup
    path if possible.
• If the change adds additional logging:
  • All logging should use
    TraceLogging.
  • Unnecessary log events should be removed, or configured so that they are collected only when
    needed to debug issues or measure feature usage.
• If the change reads user data from files or app settings:
  • Verify that state saved in a previous version of the app can be used with the new version.
• If the change makes network requests:
  • Microsoft must plan to keep these dependencies secure and functional for the lifetime of
    the app (which might be several years).
  • The app should be fully functional if some network requests are slow or fail. Tools like
    Fiddler
    can be used to simulate slow or failed requests.

Step 4: Final product review and merge to master Copy Chapter

After the technical review is complete, the product team will review the finished product to make
sure the final implementation is ready to release to Windows customers.

File: docs/Roadmap.md Copy Chapter

Windows Calculator Roadmap

Windows Calculator is under active development by Microsoft.

Focus Copy Chapter

In 2021, the Windows Calculator team is focused on:

• Iterating upon the existing app design based on the latest guidelines for Fluent Design and WinUI.
• Unblocking community contributions by identifying and addressing bottlenecks affecting developers, including:
  • Migrating the codebase to C# (#893)
  • Releasing infinite-precision engine as standalone package (#1545) and adding support for arbitrary expression parsing (#526)
  • Adding a settings page (#596)
• [Your feature idea here] - please review our new feature development process to get started!

We welcome contributions of all kinds from the community, but especially those that support the efforts above. Please see our contributing guidelines for more information on how to get involved.

Releases Copy Chapter

Windows Calculator is included in every Windows 10 release as a provisioned Windows app. We also deliver updates through the Microsoft Store approximately monthly.

2. Official Technical Reference & Guides (microsoft/microsoft.github.io) Copy Chapter

[microsoft.github.io](https://microsoft.github.io)

Many open source projects released by Microsoft products, services and teams also have
deployments powered by GitHub Pages on this domain.

To discover Microsoft-released open source projects, learn about Microsoft's open source
approach and other information, check us out online at opensource.microsoft.com.

If we can help answer questions about the open source program at Microsoft, you can
contact opensource at microsoft com - although we are not able to provide support
for projects through this mechanism.

Microsoft GitHub resources Copy Chapter

• Default repo templates including SECURITY.MD and code of conduct files: microsoft/repo-templates
• Code of Conduct (FAQ)

Microsoft open source resources Copy Chapter

• Open Source Blog
• The Open Source Show on Channel 9
• https://opensource.microsoft.com/

Resources for Microsoft employees Copy Chapter

• docs.opensource.microsoft.com
• Link your GitHub Account and join GitHub organizations automatically

How to identify an official Microsoft organization on GitHub Copy Chapter

• Official Microsoft GitHub orgs have a professional avatar and include a web address at Microsoft.com or an associated official domain
• Official Microsoft orgs are Verified on GitHub - look for the domain verification indicator on GitHub