HP 35s Celebrating 35 years
| Company type | Product model |
|---|---|
| Industry | Electronics, Calculators |
| Predecessor | HP 33s |
| Founded | 2007 |
| Founder | Hewlett-Packard |
| Headquarters | United States |
| Products | Programmable scientific calculator |
| Owner | Hewlett-Packard |
The HP 35s (model F2215A) is a programmable scientific calculator produced by Hewlett-Packard, designed without graphing capabilities. Launched in 2007 to commemorate the 35th anniversary of the original HP-35, which was HP's inaugural pocket calculator and the first pocket scientific calculator globally, it serves as the successor to the HP 33s. HP also released a special limited edition featuring a black overlay and an inscription celebrating "35 years."
Features
The HP 35s offers support for both RPN and algebraic infix input modes.
Notable specifications include:
- Dual-line alphanumeric LCD display
- More than 800 memory registers, with 26 labeled and the remainder accessed indirectly
- Functions covering scientific and statistical calculations
- Operation across decimal, binary, octal, and hexadecimal numeral systems
- An equation solver capable of isolating any variable (inherited from the HP-18C)
- Numerical integration function (derived from the HP-34C)
- Capability for fraction entry and display
- Support for complex number and vector computations
- Built-in unit conversion tools and a library of physical constants
- Approximately 30 KB of memory allocated for keystroke programming and data storage
The design draws inspiration from classic HP calculators produced between the 1970s and 1990s, delivering substantial improvements in processing speed, memory capacity, and overall functionality compared to earlier models.
Relative to its predecessor, the HP 33s, key distinctions of the HP 35s include:
- Program addressing supports both label and line number methods (the HP 33s only allowed label addressing)
- Expanded data storage with an additional 801 numbered registers available for use
- Added support for vector operations
- Complex numbers managed as single entities rather than pairs
- Removal of indirect branching commands such as GTO or XEQ
- No fixed limit on equation length, unlike the HP 33s which capped at 255 characters
- Algebraic mode employs conventional infix notation with editing features, contrasting with the HP 33s’ hybrid infix/immediate execution lacking entry deletion
HP offers a complimentary emulator compatible with Windows (and Wine), initially distributed solely for educational purposes.
Construction
The HP 35s was created through a collaboration between Hewlett-Packard and Taiwan-based Kinpo Electronics, which handles manufacturing in mainland China.
Designed to withstand demanding professional environments, the calculator has undergone rigorous testing under harsh conditions. It boasts a sturdy build secured by 25 screws to enhance durability and simplify servicing.
Its aesthetic pays homage to vintage HP calculators such as the HP-65, featuring a black casing with silver-striped curved edges, keys angled on a sloped front panel, and shift keys highlighted in gold and blue. The metal faceplate is affixed to the plastic housing, while key legends are printed rather than produced using double-shot molding as seen in older models.
Power is supplied by two CR2032 button batteries wired in parallel; users are recommended to replace these cells one at a time to avoid loss of stored memory.
Initially packaged with a rigid zippered clamshell case along with a printed manual, later versions came in a vinyl-covered cardboard slipcase lined with velvet and elastic sides, including a CD-ROM containing a PDF version of the manual.
This calculator operates entirely independently without options for firmware updates or external data/program loading.
Reception
Critics commended the device for its robust construction and industrial design, viewing it as a nod to classic HP styling, including features such as 4-Level RPN and RPN Programming. Aimed mainly at students, the calculator lacked integrated matrix operations and utilized more economical plastic materials compared to previous RPL-based models.
The keyboard preserved the traditional HP tactile experience, especially with a prominent key positioned in its customary location. Nonetheless, reviewers pointed out drawbacks such as the absence of computer interface options for transferring programs or data and relatively slow operational speed.
Significant enhancements over the HP 33s included increased addressable registers and support for program line-number addressing. While handling of complex numbers saw improvements, it was still not fully comprehensive. Working with hexadecimal and other non-decimal bases was deemed cumbersome due to the high number of keystrokes required. Additionally, users reported several firmware glitches that remain unresolved.
Because it lacks communication capabilities, the calculator complies with restrictions imposed by professional certification exams. In the United States, it stands as the most advanced programmable calculator authorized for use during the Fundamentals of Engineering and Principles and Practice of Engineering tests.
Entry modes
The 35s offers both RPN and algebraic input methods, defaulting to RPN in line with most HP calculators. Switching between modes is straightforward, with an on-screen indicator showing the active mode.
In RPN mode, it utilizes a four-level stack labeled X (lowest), Y, Z, and T (highest), consistent with HP’s non-graphing RPN calculators. Each stack position can hold real numbers, complex numbers, or vectors. Stack manipulation commands include rolling the stack (, ), swapping X and Y (), recalling the previous X value (), and exchanging X with a named variable ().
Algebraic mode enables users to input expressions that can be edited using arrow keys and backspace before evaluating with . The entered expression appears on the upper display line while the evaluated result is shown beneath.
Units and fractions
Reflecting its vintage inspiration, the 35s focuses on conversions between Imperial/US customary units and metric units. It also supports input and display of mixed fractions, which is beneficial for those working with traditional measurement systems.
Mixed fractions are entered by using decimal points to separate components—for example, converts inches into roughly 10.0 cm.
Users can enable automatic mixed fraction display by pressing the key. The maximum denominator can be adjusted via the function. Three denominator systems are selectable using numbered flags: highest precision, factors of the maximum denominator (such as 2, 4, 8, 16), or fixed denominators. Small arrow icons indicate whether the displayed fraction slightly exceeds or falls short of the actual value. There is no direct function to extract individual parts of a fraction.
Complex numbers
Earlier HP models managed complex numbers by storing real and imaginary parts separately, requiring special command modifiers for calculations. For example, the HP 33s needed all four stack levels to perform addition of complex numbers. The 35s advances this by representing complex numbers as single entities, enabling standard operations without additional modifiers.
However, its support for complex functions is limited and somewhat inconsistent. For instance, attempting to compute the square root of a negative real number results in an error instead of producing a complex answer, aligning with the principal square root convention. Raising a number to the power of 0.5 succeeds if entered as a complex number with zero imaginary component. Inverse and hyperbolic trigonometric functions do not accept complex inputs. While natural logarithms and exponentiation are supported for complex numbers, base-10 logarithms are not directly available; alternative methods exist.
Complex inputs can be provided in rectangular form (using the key) or polar form (using ), with display options for either format. Functions such as and return magnitude and angle respectively. Although there are no dedicated functions to retrieve real or imaginary parts directly, these values can be derived through calculations involving magnitude and angle formulas.
Vectors
The 35s accommodates vectors containing up to three real components, which can be stored either on the stack or within variables as individual entities and manipulated through a variety of functions. Vector input begins with an opening square bracket, with elements separated by commas. Operations such as addition, subtraction, multiplication, or division by scalars are supported; vectors of matching dimensions can be added or subtracted and multiplied to produce their dot product. The function calculates the vector's magnitude. While cross products and element extraction are not inherently supported, users can manually compute these.
Vectors also function as a method for grouping up to three real numbers together, effectively expanding storage capabilities at the expense of processing speed and complexity. HP has supplied programming routines for indirect register data packing on the 35s to assist with this application.
Number bases
This calculator supports displaying numbers in binary, octal, hexadecimal, and decimal formats. Results in non-decimal bases are truncated to whole integers. To enter numbers in these bases, suffixes indicating the base must be used, which requires additional keystrokes.
In hexadecimal mode, six keys normally assigned to floating-point operations are repurposed to represent hex digits A through F (physically labeled H to M). The word size is fixed at 36 bits using two's complement for negative values. Six bitwise operations are available: , , , , , and .
Statistics and probability
The 35s includes standard statistical functions for datasets involving one or two variables, such as calculating means, weighted means, standard deviations, and performing linear regression analysis. Summation registers facilitate further statistical computations. Probability features encompass combinations, permutations, and generation of random numbers.
Memory and variables
The device offers 30 kilobytes of user-accessible memory shared among data storage, equations, and programs. Complex numbers and vectors with up to three components each occupy a single variable slot (37 bytes per slot).
There are 26 variables labeled with alphabetic characters plus six dedicated statistics registers permanently allocated; an additional 801 variables can be accessed indirectly via pointers stored in or . Indirect variables are dynamically allocated when non-zero values are stored; clearing the highest allocated variable automatically deallocates variables downward. Attempting to access unallocated variables results in errors; therefore, users often assign placeholder non-zero values to ensure availability.
Permanent variables and statistics registers can also be accessed indirectly through negative sequence indices ranging from -1 to -32.
The calculator provides 41 selectable mathematical and physical constants accessible via the key. Twelve binary flags govern calculator settings; five of these flags can be customized by the user.
Stored equations consume one byte per character plus an overhead of three bytes; program steps require three bytes each, with steps involving values or equations demanding additional memory.
Users have straightforward means to monitor memory utilization; however, programs themselves cannot perform this check. The function allows clearing indirect variables above a specified index.
Equations
Multiple equations can be stored within the calculator, including expressions (such as f(x,...)), equalities (like f1(x,...) = f2(x,...)), and assignments (e.g., y = f(x,...)). These equations often incorporate named variables intended for user input at runtime or values pulled from the stack.
Equations are entered using algebraic notation regardless of whether RPN mode is active. They are managed through the key, which allows scrolling through the list, adding new entries, editing existing ones, deleting unwanted equations, and executing processing commands.
Available equation processing features include:
- Evaluation via or , which prompts for variable values; assignments update their respective target variables.
- Solving for any variable using , which isolates the desired variable based on user-supplied initial guesses.
- Integration through , where interval boundaries are placed on the stack prior to selecting the equation and integration variable.
Built-in support exists for solving system of linear equations involving two or three unknowns.
Since solving and integrating equations require both processing time and memory resources, performance can be improved by reducing display precision and ensuring ample available memory.
Equations are not validated until they undergo processing, enabling users to include text annotations within the equation list for note-taking purposes.
Programming
The HP 35s offers keystroke programming capabilities, capturing sequences—including those involving shifted functions—as individual keystrokes. These programs can include both conditional and unconditional branches as well as loops, enabling sophisticated problem-solving approaches.
Programs are stored in a continuous memory area accessible through , featuring up to 26 alphabetic labels (such as ), each capable of containing as many as 998 instructions. These labels facilitate targeted program execution via or commands. Any instructions placed before the first label cannot be directly addressed. When instructions are inserted or removed, all related references are automatically updated. Generally, each label corresponds to a distinct program segment that can be executed independently using . Program flow is managed with , while arrow keys allow navigation through the code. It is important to note that program labels function separately from variable identifiers.
Both RPN and algebraic input modes are supported for programming; however, RPN typically produces more compact and efficient code.
For instance, factorial calculation programs for integers ranging from 2 to 69 illustrate this difference—the RPN implementation is significantly more succinct.
Algebraic version:
| Step | Instruction | Description |
|---|---|---|
| A001 | Template:KeypressTemplate:Keypress | Start of program |
| A002 | Template:KeypressTemplate:KeypressTemplate:KeypressTemplate:Keypress | Save input value into N |
| A003 | Template:KeypressTemplate:KeypressTemplate:KeypressTemplate:Keypress | Initialize F with 1 |
| A004 | Template:KeypressTemplate:KeypressTemplate:KeypressTemplate:KeypressTemplate:KeypressTemplate:KeypressTemplate:Keypress | Compute F = N × F |
| A005 | Template:KeypressTemplate:Keypress | Decrement N; if nonzero... |
| A006 | Template:KeypressTemplate:KeypressTemplate:KeypressTemplate:KeypressTemplate:Keypress | ...jump back to step A004 |
| A007 | Template:Keypress | End program; display result |
RPN version:
| Step | Instruction | Description |
|---|---|---|
| R001 | Template:KeypressTemplate:Keypress | Program entry point |
| R002 | Template:KeypressTemplate:Keypress | Store input in variable N |
| R003 | Template:Keypress | Initialize stack with value 1 |
| R004 | Template:KeypressTemplate:KeypressTemplate:Keypress | Multiply top of stack by N |
| R005 | Template:KeypressTemplate:Keypress | Decrease N; if not zero... |
| R006 | Template:KeypressTemplate:KeypressTemplate:KeypressTemplate:KeypressTemplate:Keypress | ...loop back to step R004 |
| R007 | Template:KeypressRTN} | Terminate program; result shown on stack |
Equations may be integrated as single steps within programs. User settings dictate whether these expressions are evaluated or simply displayed during execution. It is also possible to embed messages within equations to create pauses or await user interaction.
Program routines support solving and integration operations in a manner analogous to equations: users choose a program label via , then apply either or , specifying which variables to target. Programs can prompt for input values through instructions and may call upon solving or integration functions for other equations or programs as needed.