From 97a838c5911dc9c8df0d7bac5a97d499b7e85b47 Mon Sep 17 00:00:00 2001 From: Michael Lyons Date: Sun, 9 Feb 2025 13:57:04 -0500 Subject: [PATCH 01/12] Move Completions Builder comments to readme --- resources/completion_builder/README.md | 54 ++++++++++++++++++++++++++ resources/completion_builder/main.py | 41 +------------------ 2 files changed, 56 insertions(+), 39 deletions(-) create mode 100644 resources/completion_builder/README.md diff --git a/resources/completion_builder/README.md b/resources/completion_builder/README.md new file mode 100644 index 0000000..c976053 --- /dev/null +++ b/resources/completion_builder/README.md @@ -0,0 +1,54 @@ +# Function completion builder + +## Scripts + +General operations performed by the scripts found in this directory: + +### *main.py* Main +Runner script + +### *js.py* JSON +Convert the function data found in `func_data_list.txt` to JSON, where each has: +- `func_name` (String) +- `req_param` (Array) +- `opt_param` (Array) +- `ellipsis` (Boolean) + +### *cb.py* Completion Builder +Build out completion strings for param-having functions + +### *ld.py* Load +Convert the function metadata found in `func_ref.xlsx` to JSON + +### *mg.py* Merge + +1. Match completion strings to descriptions, categories, and function names. + +2. Build out completion strings for nullary functions. + (Nullary functions are not included during the OCR which creates the + *\*\_data\_list\_raw.txt* file. Nullary functions are however included in + the *\*\_funcs\_ref.xlsx* file, so this is where they are managed.) + +3. Remove `TRUE()` and `FALSE()` from consideration if present in + *\*\_funcs\_ref.xlsx* + +4. Run all subscripts (if `toggle_rerun` is enabled) and build out entire + *.sublime-completions* file. + + +## Comments + +- NOTE: Not all `ellipsis == True` functions follow the same format. + + ``` + COUNTA~value1,[value2],... + COUNTIFS~criteria_range1,criteria1,... + ``` + + Before running this script, clean formulas in *\*\_funcs\_data\_list.txt* + that look like the second line to look like the first, using your best + judgement. Find them using: `[^\]],\.{3}` + +- TODO: Allow this entire directory to switch between application specific + information like the `scope` found in this file and the file names used by + all scripts instead of having to refactor a bunch of stuff every time. diff --git a/resources/completion_builder/main.py b/resources/completion_builder/main.py index c68dc23..3bddab6 100644 --- a/resources/completion_builder/main.py +++ b/resources/completion_builder/main.py @@ -1,41 +1,4 @@ -# General operations performed by the scripts found in this directory: -# -# 1. Covert the function data found in func_data_list.txt to JSON, where each has: -# "func_name" (String) -# "req_param" (Array) -# "opt_param" (Array) -# "ellipsis" (Boolean) -# ⮡ js.py ("json") -# -# 2. Build out completion strings for param-having functions -# ⮡ cb.py ("completion builder") -# -# 3. Covert the function metadata found in func_ref.xlsx to JSON -# ⮡ ld.py ("load") -# -# 4. Match completion strings to descriptions, categories, and function names -# ⮡ mg.py ("merge") -# -# 5. Build out completion strings for nullary functions -# (Nullary functions are not included during the OCR which creates the *_data_list_raw.txt file. -# Nullary functions are however included in the *_funcs_ref.xlsx file, so this is where they -# are managed.) -# ⮡ mg.py -# -# 6. Remove TRUE() and FALSE() from consideration if present in *_funcs_ref.xlsx -# ⮡ mg.py -# -# 7. Run all subscripts (if toggle_rerun is enabled) and build out entire .sublime-completions file. -# ⮡ main.py -# -# NOTE: Not all `ellipsis == True` functions follow the same format, e.g.: -# 1. COUNTA~value1,[value2],... -# 2. COUNTIFS~criteria_range1,criteria1,... -# Before running this script, clean formulas in *_funcs_data_list.txt that look like 2. to look like 1. using your best judgement. Find them using: -# [^\]],\.{3} - -# TODO: Allow this entire directory to switch between application specific information like the `scope` found in this file and -# the file names used by all scripts instead of having to refactor a bunch of stuff every time. +#! /usr/bin/env python3 import subprocess import json @@ -84,4 +47,4 @@ o = open('.sublime-completions', 'w') o.write(json_out) -o.close() \ No newline at end of file +o.close() From 6fec870e25f609b7833836d91641266e00a5677d Mon Sep 17 00:00:00 2001 From: Michael Lyons Date: Sun, 9 Feb 2025 14:27:31 -0500 Subject: [PATCH 02/12] Add arguments to function list parser --- resources/completion_builder/js.py | 79 ++++++++++++++++++------------ 1 file changed, 47 insertions(+), 32 deletions(-) mode change 100644 => 100755 resources/completion_builder/js.py diff --git a/resources/completion_builder/js.py b/resources/completion_builder/js.py old mode 100644 new mode 100755 index 90def2a..794aaaf --- a/resources/completion_builder/js.py +++ b/resources/completion_builder/js.py @@ -1,51 +1,66 @@ -# See main.py for overview. +#! /usr/bin/env python3 import json import re -import sys +from argparse import ArgumentParser -app = sys.argv[1] +def parse_function_list(sheet_app: str, write_json_file: bool = True): -func_file = f'{app}_funcs_data_list.txt' + with open(f'{sheet_app}_funcs_data_list.txt', 'r') as file: + lines = [line.strip() for line in file] -with open(func_file, 'r') as file: - func_list = [line.strip() for line in file] + # Debug + # lines = ['CALL~register_id,[argument1],...'] -# Debug -# func_list = ['CALL~register_id,[argument1],...'] + functions = [] -dict_list = [] + for line in lines: + func_name, param_str = line.split('~') + param_list = param_str.split(',') + req_param = [] + opt_param = [] -for line in func_list: - func_name = line.split('~')[0] + ellipsis = False - param_str = line.split('~')[1] + for param in param_list: + if param[0] == '[': + opt_param.append(re.sub(r'[\[\]]', '', param)) - param_list = param_str.split(',') + elif param[0] == '.': + ellipsis = True - req_param = [] + else: + req_param.append(param) - opt_param = [] + func_dict = dict( + func_name = func_name, + req_param = req_param, + opt_param = opt_param, + ellipsis = ellipsis, + ) - ellipsis = False + functions.append(func_dict) - for param in param_list: - if param[0] == '[': - opt_param.append(re.sub(r'[\[\]]', '', param)) + if write_json_file: + with open(f'{sheet_app}_funcs.json', 'w') as o: + json.dump(functions, o, indent=4) - elif param[0] == '.': - ellipsis = True + return functions - else: - req_param.append(param) - func_dict = dict(func_name = func_name, req_param = req_param, opt_param = opt_param, ellipsis = ellipsis) +if __name__ == '__main__': + parser = ArgumentParser( + description='Parse ~-delimited spreadsheet function list from a file') + parser.add_argument( + '-s', '--spreadsheet-app', + choices={'excel', 'gsheets', 'localc'}, + default='excel', + help='spreadsheet application') + parser.add_argument( + '-j', '--dump-json', + type=bool, + default=True, + help='dump JSON output to a file') + args = parser.parse_args() - dict_list.append(func_dict) - -json_out = json.dumps(dict_list, indent = 4) - -o = open(f'{app}_funcs.json', 'w') - -o.write(json_out) -o.close() \ No newline at end of file + parse_function_list(args.spreadsheet_app) From a9acfaca97ca0e7e0bfbdf9a3754c0c699b8cefd Mon Sep 17 00:00:00 2001 From: Michael Lyons Date: Sun, 9 Feb 2025 15:01:50 -0500 Subject: [PATCH 03/12] Make a formal class for SpreadsheetFunction --- .../completion_builder/SpreadsheetFunction.py | 43 +++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 resources/completion_builder/SpreadsheetFunction.py diff --git a/resources/completion_builder/SpreadsheetFunction.py b/resources/completion_builder/SpreadsheetFunction.py new file mode 100644 index 0000000..9ea258f --- /dev/null +++ b/resources/completion_builder/SpreadsheetFunction.py @@ -0,0 +1,43 @@ +class SpreadsheetFunction(object): + """Metadata about a function for a spreadsheet application""" + + def __init__(self, name: str, description: str = None, family: str = None, + required_args: list[str] = None, + optional_args: list[str] = None, + has_ellipsis: bool = False): + super(SpreadsheetFunction, self).__init__() + self.name = name + self.description = description + self.family = family + self.required_args = required_args + self.optional_args = optional_args + self.has_ellipsis = has_ellipsis + + def to_arg_string(self) -> str: + args = self.required_args + args += [f'[{a}]' for a in self.optional_args] + if self.has_ellipsis: + args += ['...'] + return ', '.join(args) + + def to_completion_arg_string(self) -> str: + # TODO: Replace this with the fancy one + return self.to_arg_string() + + def to_sublime_word_completion(self) -> dict[str,str]: + return { + "trigger": self.name, + "contents": self.name, + "annotation": self.family, + "details": self.description, + "kind": "function", + } + + def to_sublime_snippet_completion(self) -> dict[str,str]: + return { + "trigger": self.name.lower(), + "contents": self.to_completion_arg_string(), + "annotation": self.family, + "details": self.description, + "kind": "snippet", + } From 5bf513e697975ecda6e71ac5ea808352ecbdb9d3 Mon Sep 17 00:00:00 2001 From: Michael Lyons Date: Sun, 9 Feb 2025 15:28:04 -0500 Subject: [PATCH 04/12] Ignore compiled Python --- .gitignore | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..7a60b85 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +__pycache__/ +*.pyc From 64a91d5931d3942981a9dd096308a35ad32dbb07 Mon Sep 17 00:00:00 2001 From: Michael Lyons Date: Sun, 9 Feb 2025 15:29:33 -0500 Subject: [PATCH 05/12] Start using the SpreadsheetFunction class --- .../completion_builder/SpreadsheetFunction.py | 9 +++++++++ resources/completion_builder/js.py | 16 +++++++++------- 2 files changed, 18 insertions(+), 7 deletions(-) diff --git a/resources/completion_builder/SpreadsheetFunction.py b/resources/completion_builder/SpreadsheetFunction.py index 9ea258f..79f47c1 100644 --- a/resources/completion_builder/SpreadsheetFunction.py +++ b/resources/completion_builder/SpreadsheetFunction.py @@ -13,6 +13,15 @@ def __init__(self, name: str, description: str = None, family: str = None, self.optional_args = optional_args self.has_ellipsis = has_ellipsis + def to_json(self) -> str: + """This is the temporary transfer format""" + return dict( + func_name = self.name, + req_param = self.required_args, + opt_param = self.optional_args, + ellipsis = self.has_ellipsis, + ) + def to_arg_string(self) -> str: args = self.required_args args += [f'[{a}]' for a in self.optional_args] diff --git a/resources/completion_builder/js.py b/resources/completion_builder/js.py index 794aaaf..836861e 100755 --- a/resources/completion_builder/js.py +++ b/resources/completion_builder/js.py @@ -4,6 +4,8 @@ import re from argparse import ArgumentParser +from SpreadsheetFunction import SpreadsheetFunction + def parse_function_list(sheet_app: str, write_json_file: bool = True): with open(f'{sheet_app}_funcs_data_list.txt', 'r') as file: @@ -32,18 +34,18 @@ def parse_function_list(sheet_app: str, write_json_file: bool = True): else: req_param.append(param) - func_dict = dict( - func_name = func_name, - req_param = req_param, - opt_param = opt_param, - ellipsis = ellipsis, + function = SpreadsheetFunction( + func_name, + required_args = req_param, + optional_args = opt_param, + has_ellipsis = ellipsis, ) - functions.append(func_dict) + functions.append(function) if write_json_file: with open(f'{sheet_app}_funcs.json', 'w') as o: - json.dump(functions, o, indent=4) + json.dump([f.to_json() for f in functions], o, indent=4) return functions From c43b7b80ef58fc6559c3b008e3efb067cfd11f24 Mon Sep 17 00:00:00 2001 From: Michael Lyons Date: Sun, 9 Feb 2025 16:40:41 -0500 Subject: [PATCH 06/12] Move mg.py to use SpreadsheetFunction The completion strings need to be fixed. --- .../completion_builder/SpreadsheetFunction.py | 35 +++++- resources/completion_builder/cb.py | 0 resources/completion_builder/cb_2.py | 0 resources/completion_builder/js.py | 6 +- resources/completion_builder/ld.py | 4 +- resources/completion_builder/main.py | 0 resources/completion_builder/mg.py | 106 ++++++++++++------ resources/func_tooltip_ocr_bandit.py | 0 8 files changed, 107 insertions(+), 44 deletions(-) mode change 100644 => 100755 resources/completion_builder/cb.py mode change 100644 => 100755 resources/completion_builder/cb_2.py mode change 100644 => 100755 resources/completion_builder/ld.py mode change 100644 => 100755 resources/completion_builder/main.py mode change 100644 => 100755 resources/completion_builder/mg.py mode change 100644 => 100755 resources/func_tooltip_ocr_bandit.py diff --git a/resources/completion_builder/SpreadsheetFunction.py b/resources/completion_builder/SpreadsheetFunction.py index 79f47c1..6b49985 100644 --- a/resources/completion_builder/SpreadsheetFunction.py +++ b/resources/completion_builder/SpreadsheetFunction.py @@ -1,3 +1,9 @@ +APP_SUFFIXES = [ + 'excel', + 'google', + 'libre', +] + class SpreadsheetFunction(object): """Metadata about a function for a spreadsheet application""" @@ -13,25 +19,46 @@ def __init__(self, name: str, description: str = None, family: str = None, self.optional_args = optional_args self.has_ellipsis = has_ellipsis + @staticmethod + def from_json(json_obj): + """This is the temporary transfer format""" + return SpreadsheetFunction( + json_obj.get('func_name'), + description = json_obj.get('func_desc', None), + family = json_obj.get('func_cat', None), + required_args = json_obj.get('req_param', None), + optional_args = json_obj.get('opt_param', None), + has_ellipsis = json_obj.get('ellipsis', False), + ) + def to_json(self) -> str: """This is the temporary transfer format""" - return dict( + output = dict( func_name = self.name, + func_cat = self.family, + func_desc = self.description, + is_nullary = not (self.required_args or self.optional_args), + comp_str = self.to_completion_arg_string(), req_param = self.required_args, opt_param = self.optional_args, ellipsis = self.has_ellipsis, ) + return {k:output[k] for k in output if output[k] is not None} + def to_arg_string(self) -> str: - args = self.required_args - args += [f'[{a}]' for a in self.optional_args] + args = [] + if self.required_args: + args += self.required_args + if self.optional_args: + args += [f'[{a}]' for a in self.optional_args] if self.has_ellipsis: args += ['...'] return ', '.join(args) def to_completion_arg_string(self) -> str: # TODO: Replace this with the fancy one - return self.to_arg_string() + return f'{self.name}({self.to_arg_string()})' def to_sublime_word_completion(self) -> dict[str,str]: return { diff --git a/resources/completion_builder/cb.py b/resources/completion_builder/cb.py old mode 100644 new mode 100755 diff --git a/resources/completion_builder/cb_2.py b/resources/completion_builder/cb_2.py old mode 100644 new mode 100755 diff --git a/resources/completion_builder/js.py b/resources/completion_builder/js.py index 836861e..7434c9d 100755 --- a/resources/completion_builder/js.py +++ b/resources/completion_builder/js.py @@ -4,7 +4,7 @@ import re from argparse import ArgumentParser -from SpreadsheetFunction import SpreadsheetFunction +from SpreadsheetFunction import APP_SUFFIXES, SpreadsheetFunction def parse_function_list(sheet_app: str, write_json_file: bool = True): @@ -55,7 +55,7 @@ def parse_function_list(sheet_app: str, write_json_file: bool = True): description='Parse ~-delimited spreadsheet function list from a file') parser.add_argument( '-s', '--spreadsheet-app', - choices={'excel', 'gsheets', 'localc'}, + choices=APP_SUFFIXES, default='excel', help='spreadsheet application') parser.add_argument( @@ -65,4 +65,4 @@ def parse_function_list(sheet_app: str, write_json_file: bool = True): help='dump JSON output to a file') args = parser.parse_args() - parse_function_list(args.spreadsheet_app) + parse_function_list(args.spreadsheet_app, args.dump_json) diff --git a/resources/completion_builder/ld.py b/resources/completion_builder/ld.py old mode 100644 new mode 100755 index 07f74af..d100145 --- a/resources/completion_builder/ld.py +++ b/resources/completion_builder/ld.py @@ -1,4 +1,4 @@ -# See main.py for overview. +#! /usr/bin/env python3 import json import pandas as pd @@ -11,4 +11,4 @@ o = open(f'{app}_funcs_ref.json', 'w') -o.write(ref_file) \ No newline at end of file +o.write(ref_file) diff --git a/resources/completion_builder/main.py b/resources/completion_builder/main.py old mode 100644 new mode 100755 diff --git a/resources/completion_builder/mg.py b/resources/completion_builder/mg.py old mode 100644 new mode 100755 index b2a9554..991d3d3 --- a/resources/completion_builder/mg.py +++ b/resources/completion_builder/mg.py @@ -1,55 +1,91 @@ -# See main.py for overview. +#! /usr/bin/env python3 import json import sys +from argparse import ArgumentParser -app = sys.argv[1] +from SpreadsheetFunction import APP_SUFFIXES, SpreadsheetFunction -func_file = open(f'{app}_funcs_comp.json', 'r') +SKIPPED_FUNCTIONS = [ + 'TRUE', + 'FALSE', +] -js_func = json.load(func_file) -func_file.close() +def merge_function_args_with_desc(sheet_app: str, write_json_file: bool = True): + # completion-arg functions file + func_file = open(f'{sheet_app}_funcs_comp.json', 'r') + js_func = json.load(func_file) + func_file.close() -ref_file = open(f'{app}_funcs_ref.json', 'r') + # Permute the functions for quick lookup + js_func = {f['func_name']: f for f in js_func} -js_ref = json.load(ref_file) + # function description and category file + ref_file = open(f'{sheet_app}_funcs_ref.json', 'r') + js_ref = json.load(ref_file) + ref_file.close() -ref_file.close() + print('Length of Reference List: ' + str(len(js_ref))) + print('Length of Completions List: ' + str(len(js_func))) -print('Length of Reference List: ' + str(len(js_ref))) -print('Length of Completions List: ' + str(len(js_func))) + # Goal: For each object in _ref, + # if "is_nullary" == True: + # (DONE) look for a matching function in _func and return the "comp_str" field, then load it into a new field for the current object in _ref. + # if "is_nullary" == False: + # generate a nullary-specific completion string using f'={func_name}()', then load it into a new field for the current object in _ref. -# Goal: For each object in _ref, -# if "is_nullary" == True: -# (DONE) look for a matching function in _func and return the "comp_str" field, then load it into a new field for the current object in _ref. -# if "is_nullary" == False: -# generate a nullary-specific completion string using f'={func_name}()', then load it into a new field for the current object in _ref. + functions = [] + for ref in js_ref: + function = SpreadsheetFunction.from_json(ref) + if function.name in SKIPPED_FUNCTIONS: + continue + if ref['is_nullary']: + functions.append(function) + continue -# Note: Drops the true and false functions to prevent them making their way into the final list. -js_ref = [ref for ref in js_ref if ref['func_name'] not in ['TRUE', 'FALSE']] - -for ref in js_ref: - func_name = ref.get('func_name') - - if ref.get('is_nullary'): - ref['comp_str'] = f'={func_name}()' - - else: try: - lookup = next(((func['comp_str'], func['ellipsis']) for func in js_func if func['func_name'] == func_name), None) - ref['comp_str'] = lookup[0] - ref['ellipsis'] = lookup[1] + lookup = js_func[function.name] + if function.name == 'IMAGE': + print(function.to_json()) + print(lookup) + function.required_args = lookup['req_param'] + function.optional_args = lookup['opt_param'] + function.has_ellipsis = lookup['ellipsis'] + if function.name == 'IMAGE': + print('after') + print(function.to_json()) + # print(lookup) except: print("\nError when when matching comp_str for nonnullary function:") - print(f'ref func_name: {func_name}') - print(f'lookup: {lookup}') + print(f'{function.name=}') + print(f'{lookup=}') + + functions.append(function) + + + print(f'Length of Master List: {len(functions)}') + + if write_json_file: + with open(f'{sheet_app}_funcs_master.json', 'w') as o: + json.dump([f.to_json() for f in functions], o, indent=4) -print('Length of Master List: ' + str(len(js_ref))) + return functions -o = open(f'{app}_funcs_master.json', 'w') -json_out = json.dumps(js_ref, indent = 4) +if __name__ == '__main__': + parser = ArgumentParser( + description='Merge spreadsheet function metadata with their arguments') + parser.add_argument( + '-s', '--spreadsheet-app', + choices=APP_SUFFIXES, + default='excel', + help='spreadsheet application') + parser.add_argument( + '-j', '--dump-json', + type=bool, + default=True, + help='dump JSON output to a file') + args = parser.parse_args() -o.write(json_out) -o.close() \ No newline at end of file + merge_function_args_with_desc(args.spreadsheet_app, args.dump_json) diff --git a/resources/func_tooltip_ocr_bandit.py b/resources/func_tooltip_ocr_bandit.py old mode 100644 new mode 100755 From eb488d059afeb89d5eb75c5d41cb00e3df77af57 Mon Sep 17 00:00:00 2001 From: Michael Lyons Date: Sun, 9 Feb 2025 17:09:24 -0500 Subject: [PATCH 07/12] Steal cb.py into SpreadsheetFunction --- .../completion_builder/SpreadsheetFunction.py | 42 ++++++++++++++++--- 1 file changed, 37 insertions(+), 5 deletions(-) diff --git a/resources/completion_builder/SpreadsheetFunction.py b/resources/completion_builder/SpreadsheetFunction.py index 6b49985..3e6f8bf 100644 --- a/resources/completion_builder/SpreadsheetFunction.py +++ b/resources/completion_builder/SpreadsheetFunction.py @@ -45,8 +45,7 @@ def to_json(self) -> str: ) return {k:output[k] for k in output if output[k] is not None} - - def to_arg_string(self) -> str: + def to_arg_list(self) -> list[str]: args = [] if self.required_args: args += self.required_args @@ -54,11 +53,44 @@ def to_arg_string(self) -> str: args += [f'[{a}]' for a in self.optional_args] if self.has_ellipsis: args += ['...'] - return ', '.join(args) + return args + + def to_arg_string(self) -> str: + return ', '.join(self.to_arg_list()) def to_completion_arg_string(self) -> str: - # TODO: Replace this with the fancy one - return f'{self.name}({self.to_arg_string()})' + completions = [] + param_id = 0 + + if self.required_args: + for req in self.required_args: + param_id += 1 + + if param_id > 1: + completions.append(',') + completions.append(f'${{{param_id}: {req}}}') + else: + completions.append(f'${{{param_id}:{req}}}') + + if self.optional_args: + num_opt_param = len(self.optional_args) + num_param = num_opt_param + len(self.required_args or []) + + # Wrap optional arguments in an extra tabstop + param_id += 1 + completions.append(f'${{{param_id}:') + + for opt in self.optional_args: + param_id += 1 + + if param_id == num_param + 1 and self.has_ellipsis: + completions.append(f',${{{param_id}: [{opt}], ...}}') + else: + completions.append(f',${{{param_id}: [{opt}]}}') + + completions.append('}') + + return f'{self.name}({"".join(completions)})' def to_sublime_word_completion(self) -> dict[str,str]: return { From 6b4835dca76bd5b503f4780161e08bd8bf34a792 Mon Sep 17 00:00:00 2001 From: Michael Lyons Date: Sun, 9 Feb 2025 17:16:27 -0500 Subject: [PATCH 08/12] Drop extra JSON file --- .../completion_builder/excel_funcs_comp.json | 5568 ----------------- resources/completion_builder/mg.py | 2 +- 2 files changed, 1 insertion(+), 5569 deletions(-) delete mode 100644 resources/completion_builder/excel_funcs_comp.json diff --git a/resources/completion_builder/excel_funcs_comp.json b/resources/completion_builder/excel_funcs_comp.json deleted file mode 100644 index f584d71..0000000 --- a/resources/completion_builder/excel_funcs_comp.json +++ /dev/null @@ -1,5568 +0,0 @@ -[ - { - "func_name": "ABS", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ABS(${1:number})" - }, - { - "func_name": "ACCRINT", - "req_param": [ - "issue", - "first_interest", - "settlement", - "rate", - "par", - "frequency" - ], - "opt_param": [ - "basis", - "calc_method" - ], - "ellipsis": false, - "comp_str": "ACCRINT(${1:issue},${2: first_interest},${3: settlement},${4: rate},${5: par},${6: frequency}${7:,${8: [basis]},${9: [calc_method]}})" - }, - { - "func_name": "ACCRINTM", - "req_param": [ - "issue", - "settlement", - "rate", - "par" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "ACCRINTM(${1:issue},${2: settlement},${3: rate},${4: par}${5:,${6: [basis]}})" - }, - { - "func_name": "ACOS", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ACOS(${1:number})" - }, - { - "func_name": "ACOSH", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ACOSH(${1:number})" - }, - { - "func_name": "ACOT", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ACOT(${1:number})" - }, - { - "func_name": "ACOTH", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ACOTH(${1:number})" - }, - { - "func_name": "ADDRESS", - "req_param": [ - "row_num", - "column_num" - ], - "opt_param": [ - "abs_num", - "a1", - "sheet_text" - ], - "ellipsis": false, - "comp_str": "ADDRESS(${1:row_num},${2: column_num}${3:,${4: [abs_num]},${5: [a1]},${6: [sheet_text]}})" - }, - { - "func_name": "AGGREGATE", - "req_param": [ - "function_num", - "options", - "array" - ], - "opt_param": [ - "k" - ], - "ellipsis": false, - "comp_str": "AGGREGATE(${1:function_num},${2: options},${3: array}${4:,${5: [k]}})" - }, - { - "func_name": "AMORDEGRC", - "req_param": [ - "cost", - "date_purchased", - "first_period", - "salvage", - "period", - "rate" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "AMORDEGRC(${1:cost},${2: date_purchased},${3: first_period},${4: salvage},${5: period},${6: rate}${7:,${8: [basis]}})" - }, - { - "func_name": "AMORLINC", - "req_param": [ - "cost", - "date_purchased", - "first_period", - "salvage", - "period", - "rate" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "AMORLINC(${1:cost},${2: date_purchased},${3: first_period},${4: salvage},${5: period},${6: rate}${7:,${8: [basis]}})" - }, - { - "func_name": "AND", - "req_param": [ - "logical1" - ], - "opt_param": [ - "logical2" - ], - "ellipsis": true, - "comp_str": "AND(${1:logical1}${2:,${3: [logical2], ...}})" - }, - { - "func_name": "ARABIC", - "req_param": [ - "text" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ARABIC(${1:text})" - }, - { - "func_name": "AREAS", - "req_param": [ - "reference" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "AREAS(${1:reference})" - }, - { - "func_name": "ARRAYTOTEXT", - "req_param": [ - "array" - ], - "opt_param": [ - "format" - ], - "ellipsis": false, - "comp_str": "ARRAYTOTEXT(${1:array}${2:,${3: [format]}})" - }, - { - "func_name": "ASC", - "req_param": [ - "text" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ASC(${1:text})" - }, - { - "func_name": "ASIN", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ASIN(${1:number})" - }, - { - "func_name": "ASINH", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ASINH(${1:number})" - }, - { - "func_name": "ATAN", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ATAN(${1:number})" - }, - { - "func_name": "ATAN2", - "req_param": [ - "x_num", - "y_num" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ATAN2(${1:x_num},${2: y_num})" - }, - { - "func_name": "ATANH", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ATANH(${1:number})" - }, - { - "func_name": "AVEDEV", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "AVEDEV(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "AVERAGE", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "AVERAGE(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "AVERAGEA", - "req_param": [ - "value1" - ], - "opt_param": [ - "value2" - ], - "ellipsis": true, - "comp_str": "AVERAGEA(${1:value1}${2:,${3: [value2], ...}})" - }, - { - "func_name": "AVERAGEIF", - "req_param": [ - "range", - "criteria" - ], - "opt_param": [ - "average_range" - ], - "ellipsis": false, - "comp_str": "AVERAGEIF(${1:range},${2: criteria}${3:,${4: [average_range]}})" - }, - { - "func_name": "AVERAGEIFS", - "req_param": [ - "average_range", - "criteria_range1", - "criteria1" - ], - "opt_param": [ - "criteria_range2", - "criteria2" - ], - "ellipsis": true, - "comp_str": "AVERAGEIFS(${1:average_range},${2: criteria_range1},${3: criteria1}${4:,${5: [criteria_range2]},${6: [criteria2], ...}})" - }, - { - "func_name": "BAHTTEXT", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "BAHTTEXT(${1:number})" - }, - { - "func_name": "BASE", - "req_param": [ - "number", - "radix" - ], - "opt_param": [ - "min_length" - ], - "ellipsis": false, - "comp_str": "BASE(${1:number},${2: radix}${3:,${4: [min_length]}})" - }, - { - "func_name": "BESSELI", - "req_param": [ - "x", - "n" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "BESSELI(${1:x},${2: n})" - }, - { - "func_name": "BESSELJ", - "req_param": [ - "x", - "n" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "BESSELJ(${1:x},${2: n})" - }, - { - "func_name": "BESSELK", - "req_param": [ - "x", - "n" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "BESSELK(${1:x},${2: n})" - }, - { - "func_name": "BESSELY", - "req_param": [ - "x", - "n" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "BESSELY(${1:x},${2: n})" - }, - { - "func_name": "BETA.DIST", - "req_param": [ - "x", - "alpha", - "beta", - "cumulative" - ], - "opt_param": [ - "A", - "B" - ], - "ellipsis": false, - "comp_str": "BETA.DIST(${1:x},${2: alpha},${3: beta},${4: cumulative}${5:,${6: [A]},${7: [B]}})" - }, - { - "func_name": "BETA.INV", - "req_param": [ - "probability", - "alpha", - "beta" - ], - "opt_param": [ - "A", - "B" - ], - "ellipsis": false, - "comp_str": "BETA.INV(${1:probability},${2: alpha},${3: beta}${4:,${5: [A]},${6: [B]}})" - }, - { - "func_name": "BETADIST", - "req_param": [ - "x", - "alpha", - "beta" - ], - "opt_param": [ - "A", - "B" - ], - "ellipsis": false, - "comp_str": "BETADIST(${1:x},${2: alpha},${3: beta}${4:,${5: [A]},${6: [B]}})" - }, - { - "func_name": "BETAINV", - "req_param": [ - "probability", - "alpha", - "beta" - ], - "opt_param": [ - "A", - "B" - ], - "ellipsis": false, - "comp_str": "BETAINV(${1:probability},${2: alpha},${3: beta}${4:,${5: [A]},${6: [B]}})" - }, - { - "func_name": "BIN2DEC", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "BIN2DEC(${1:number})" - }, - { - "func_name": "BIN2HEX", - "req_param": [ - "number" - ], - "opt_param": [ - "places" - ], - "ellipsis": false, - "comp_str": "BIN2HEX(${1:number}${2:,${3: [places]}})" - }, - { - "func_name": "BIN2OCT", - "req_param": [ - "number" - ], - "opt_param": [ - "places" - ], - "ellipsis": false, - "comp_str": "BIN2OCT(${1:number}${2:,${3: [places]}})" - }, - { - "func_name": "BINOM.DIST", - "req_param": [ - "number_s", - "trials", - "probability_s", - "cumulative" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "BINOM.DIST(${1:number_s},${2: trials},${3: probability_s},${4: cumulative})" - }, - { - "func_name": "BINOM.DIST.RANGE", - "req_param": [ - "trials", - "probability_s", - "number_s" - ], - "opt_param": [ - "number_s2" - ], - "ellipsis": false, - "comp_str": "BINOM.DIST.RANGE(${1:trials},${2: probability_s},${3: number_s}${4:,${5: [number_s2]}})" - }, - { - "func_name": "BINOM.INV", - "req_param": [ - "trials", - "probability_s", - "alpha" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "BINOM.INV(${1:trials},${2: probability_s},${3: alpha})" - }, - { - "func_name": "BINOMDIST", - "req_param": [ - "number_s", - "trials", - "probability_s", - "cumulative" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "BINOMDIST(${1:number_s},${2: trials},${3: probability_s},${4: cumulative})" - }, - { - "func_name": "BITAND", - "req_param": [ - "number1", - "number2" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "BITAND(${1:number1},${2: number2})" - }, - { - "func_name": "BITLSHIFT", - "req_param": [ - "number", - "shift_amount" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "BITLSHIFT(${1:number},${2: shift_amount})" - }, - { - "func_name": "BITOR", - "req_param": [ - "number1", - "number2" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "BITOR(${1:number1},${2: number2})" - }, - { - "func_name": "BITRSHIFT", - "req_param": [ - "number", - "shift_amount" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "BITRSHIFT(${1:number},${2: shift_amount})" - }, - { - "func_name": "BITXOR", - "req_param": [ - "number1", - "number2" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "BITXOR(${1:number1},${2: number2})" - }, - { - "func_name": "BYCOL", - "req_param": [ - "array" - ], - "opt_param": [ - "function" - ], - "ellipsis": false, - "comp_str": "BYCOL(${1:array}${2:,${3: [function]}})" - }, - { - "func_name": "BYROW", - "req_param": [ - "array" - ], - "opt_param": [ - "function" - ], - "ellipsis": false, - "comp_str": "BYROW(${1:array}${2:,${3: [function]}})" - }, - { - "func_name": "CALL", - "req_param": [ - "register_id" - ], - "opt_param": [ - "argument1" - ], - "ellipsis": true, - "comp_str": "CALL(${1:register_id}${2:,${3: [argument1], ...}})" - }, - { - "func_name": "CEILING", - "req_param": [ - "number", - "significance" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CEILING(${1:number},${2: significance})" - }, - { - "func_name": "CEILING.MATH", - "req_param": [ - "number" - ], - "opt_param": [ - "significance", - "mode" - ], - "ellipsis": false, - "comp_str": "CEILING.MATH(${1:number}${2:,${3: [significance]},${4: [mode]}})" - }, - { - "func_name": "CEILING.PRECISE", - "req_param": [ - "number" - ], - "opt_param": [ - "significance" - ], - "ellipsis": false, - "comp_str": "CEILING.PRECISE(${1:number}${2:,${3: [significance]}})" - }, - { - "func_name": "CELL", - "req_param": [ - "info_type" - ], - "opt_param": [ - "reference" - ], - "ellipsis": false, - "comp_str": "CELL(${1:info_type}${2:,${3: [reference]}})" - }, - { - "func_name": "CHAR", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CHAR(${1:number})" - }, - { - "func_name": "CHIDIST", - "req_param": [ - "x", - "deg_freedom" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CHIDIST(${1:x},${2: deg_freedom})" - }, - { - "func_name": "CHIINV", - "req_param": [ - "probability", - "deg_freedom" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CHIINV(${1:probability},${2: deg_freedom})" - }, - { - "func_name": "CHISQ.DIST", - "req_param": [ - "x", - "deg_freedom", - "cumulative" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CHISQ.DIST(${1:x},${2: deg_freedom},${3: cumulative})" - }, - { - "func_name": "CHISQ.DIST.RT", - "req_param": [ - "x", - "deg_freedom" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CHISQ.DIST.RT(${1:x},${2: deg_freedom})" - }, - { - "func_name": "CHISQ.INV", - "req_param": [ - "probability", - "deg_freedom" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CHISQ.INV(${1:probability},${2: deg_freedom})" - }, - { - "func_name": "CHISQ.INV.RT", - "req_param": [ - "probability", - "deg_freedom" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CHISQ.INV.RT(${1:probability},${2: deg_freedom})" - }, - { - "func_name": "CHISQ.TEST", - "req_param": [ - "actual_range", - "expected_range" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CHISQ.TEST(${1:actual_range},${2: expected_range})" - }, - { - "func_name": "CHITEST", - "req_param": [ - "actual_range", - "expected_range" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CHITEST(${1:actual_range},${2: expected_range})" - }, - { - "func_name": "CHOOSE", - "req_param": [ - "index_num", - "value1" - ], - "opt_param": [ - "value2" - ], - "ellipsis": true, - "comp_str": "CHOOSE(${1:index_num},${2: value1}${3:,${4: [value2], ...}})" - }, - { - "func_name": "CHOOSECOLS", - "req_param": [ - "array", - "col_num1" - ], - "opt_param": [ - "col_num2" - ], - "ellipsis": true, - "comp_str": "CHOOSECOLS(${1:array},${2: col_num1}${3:,${4: [col_num2], ...}})" - }, - { - "func_name": "CHOOSEROWS", - "req_param": [ - "array", - "row_num1" - ], - "opt_param": [ - "row_num2" - ], - "ellipsis": true, - "comp_str": "CHOOSEROWS(${1:array},${2: row_num1}${3:,${4: [row_num2], ...}})" - }, - { - "func_name": "CLEAN", - "req_param": [ - "text" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CLEAN(${1:text})" - }, - { - "func_name": "CODE", - "req_param": [ - "text" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CODE(${1:text})" - }, - { - "func_name": "COLUMN", - "req_param": [], - "opt_param": [ - "reference" - ], - "ellipsis": false, - "comp_str": "COLUMN(${1:,${2: [reference]}})" - }, - { - "func_name": "COLUMNS", - "req_param": [ - "array" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "COLUMNS(${1:array})" - }, - { - "func_name": "COMBIN", - "req_param": [ - "number", - "number_chosen" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "COMBIN(${1:number},${2: number_chosen})" - }, - { - "func_name": "COMBINA", - "req_param": [ - "number", - "number_chosen" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "COMBINA(${1:number},${2: number_chosen})" - }, - { - "func_name": "COMPLEX", - "req_param": [ - "real_num", - "i_num" - ], - "opt_param": [ - "suffix" - ], - "ellipsis": false, - "comp_str": "COMPLEX(${1:real_num},${2: i_num}${3:,${4: [suffix]}})" - }, - { - "func_name": "CONCAT", - "req_param": [ - "text1" - ], - "opt_param": [ - "text2" - ], - "ellipsis": true, - "comp_str": "CONCAT(${1:text1}${2:,${3: [text2], ...}})" - }, - { - "func_name": "CONCATENATE", - "req_param": [ - "text1" - ], - "opt_param": [ - "text2" - ], - "ellipsis": true, - "comp_str": "CONCATENATE(${1:text1}${2:,${3: [text2], ...}})" - }, - { - "func_name": "CONFIDENCE", - "req_param": [ - "alpha", - "standard_dev", - "size" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CONFIDENCE(${1:alpha},${2: standard_dev},${3: size})" - }, - { - "func_name": "CONFIDENCE.NORM", - "req_param": [ - "alpha", - "standard_dev", - "size" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CONFIDENCE.NORM(${1:alpha},${2: standard_dev},${3: size})" - }, - { - "func_name": "CONFIDENCE.T", - "req_param": [ - "alpha", - "standard_dev", - "size" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CONFIDENCE.T(${1:alpha},${2: standard_dev},${3: size})" - }, - { - "func_name": "CONVERT", - "req_param": [ - "number", - "from_unit", - "to_unit" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CONVERT(${1:number},${2: from_unit},${3: to_unit})" - }, - { - "func_name": "CORREL", - "req_param": [ - "array1", - "array2" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CORREL(${1:array1},${2: array2})" - }, - { - "func_name": "COS", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "COS(${1:number})" - }, - { - "func_name": "COSH", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "COSH(${1:number})" - }, - { - "func_name": "COT", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "COT(${1:number})" - }, - { - "func_name": "COTH", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "COTH(${1:number})" - }, - { - "func_name": "COUNT", - "req_param": [ - "value1" - ], - "opt_param": [ - "value2" - ], - "ellipsis": true, - "comp_str": "COUNT(${1:value1}${2:,${3: [value2], ...}})" - }, - { - "func_name": "COUNTA", - "req_param": [ - "value1" - ], - "opt_param": [ - "value2" - ], - "ellipsis": true, - "comp_str": "COUNTA(${1:value1}${2:,${3: [value2], ...}})" - }, - { - "func_name": "COUNTBLANK", - "req_param": [ - "range" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "COUNTBLANK(${1:range})" - }, - { - "func_name": "COUNTIF", - "req_param": [ - "range", - "criteria" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "COUNTIF(${1:range},${2: criteria})" - }, - { - "func_name": "COUNTIFS", - "req_param": [ - "criteria_range1", - "criteria1" - ], - "opt_param": [ - "criteria_range2", - "criteria2" - ], - "ellipsis": true, - "comp_str": "COUNTIFS(${1:criteria_range1},${2: criteria1}${3:,${4: [criteria_range2]},${5: [criteria2], ...}})" - }, - { - "func_name": "COUPDAYBS", - "req_param": [ - "settlement", - "maturity", - "frequency" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "COUPDAYBS(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})" - }, - { - "func_name": "COUPDAYS", - "req_param": [ - "settlement", - "maturity", - "frequency" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "COUPDAYS(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})" - }, - { - "func_name": "COUPDAYSNC", - "req_param": [ - "settlement", - "maturity", - "frequency" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "COUPDAYSNC(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})" - }, - { - "func_name": "COUPNCD", - "req_param": [ - "settlement", - "maturity", - "frequency" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "COUPNCD(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})" - }, - { - "func_name": "COUPNUM", - "req_param": [ - "settlement", - "maturity", - "frequency" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "COUPNUM(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})" - }, - { - "func_name": "COUPPCD", - "req_param": [ - "settlement", - "maturity", - "frequency" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "COUPPCD(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})" - }, - { - "func_name": "COVAR", - "req_param": [ - "array1", - "array2" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "COVAR(${1:array1},${2: array2})" - }, - { - "func_name": "COVARIANCE.P", - "req_param": [ - "array1", - "array2" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "COVARIANCE.P(${1:array1},${2: array2})" - }, - { - "func_name": "COVARIANCE.S", - "req_param": [ - "array1", - "array2" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "COVARIANCE.S(${1:array1},${2: array2})" - }, - { - "func_name": "CRITBINOM", - "req_param": [ - "trials", - "probability_s", - "alpha" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CRITBINOM(${1:trials},${2: probability_s},${3: alpha})" - }, - { - "func_name": "CSC", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CSC(${1:number})" - }, - { - "func_name": "CSCH", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CSCH(${1:number})" - }, - { - "func_name": "CUBEKPIMEMBER", - "req_param": [ - "connection", - "kpi_name", - "kpi_property" - ], - "opt_param": [ - "caption" - ], - "ellipsis": false, - "comp_str": "CUBEKPIMEMBER(${1:connection},${2: kpi_name},${3: kpi_property}${4:,${5: [caption]}})" - }, - { - "func_name": "CUBEMEMBER", - "req_param": [ - "connection", - "member_expression" - ], - "opt_param": [ - "caption" - ], - "ellipsis": false, - "comp_str": "CUBEMEMBER(${1:connection},${2: member_expression}${3:,${4: [caption]}})" - }, - { - "func_name": "CUBEMEMBERPROPERTY", - "req_param": [ - "connection", - "member_expression", - "property" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CUBEMEMBERPROPERTY(${1:connection},${2: member_expression},${3: property})" - }, - { - "func_name": "CUBERANKEDMEMBER", - "req_param": [ - "connection", - "set_expression", - "rank" - ], - "opt_param": [ - "caption" - ], - "ellipsis": false, - "comp_str": "CUBERANKEDMEMBER(${1:connection},${2: set_expression},${3: rank}${4:,${5: [caption]}})" - }, - { - "func_name": "CUBESET", - "req_param": [ - "connection", - "set_expression" - ], - "opt_param": [ - "caption", - "sort_order", - "sort_by" - ], - "ellipsis": false, - "comp_str": "CUBESET(${1:connection},${2: set_expression}${3:,${4: [caption]},${5: [sort_order]},${6: [sort_by]}})" - }, - { - "func_name": "CUBESETCOUNT", - "req_param": [ - "set" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CUBESETCOUNT(${1:set})" - }, - { - "func_name": "CUBEVALUE", - "req_param": [ - "connection" - ], - "opt_param": [ - "member_expression1" - ], - "ellipsis": true, - "comp_str": "CUBEVALUE(${1:connection}${2:,${3: [member_expression1], ...}})" - }, - { - "func_name": "CUMIPMT", - "req_param": [ - "rate", - "nper", - "pv", - "start_period", - "end_period", - "type" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CUMIPMT(${1:rate},${2: nper},${3: pv},${4: start_period},${5: end_period},${6: type})" - }, - { - "func_name": "CUMPRINC", - "req_param": [ - "rate", - "nper", - "pv", - "start_period", - "end_period", - "type" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "CUMPRINC(${1:rate},${2: nper},${3: pv},${4: start_period},${5: end_period},${6: type})" - }, - { - "func_name": "DATE", - "req_param": [ - "year", - "month", - "day" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "DATE(${1:year},${2: month},${3: day})" - }, - { - "func_name": "DATEDIF", - "req_param": [ - "start_date", - "end_date", - "unit" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "DATEDIF(${1:start_date},${2: end_date},${3: unit})" - }, - { - "func_name": "DATEVALUE", - "req_param": [ - "date_text" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "DATEVALUE(${1:date_text})" - }, - { - "func_name": "DAVERAGE", - "req_param": [ - "database", - "field", - "criteria" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "DAVERAGE(${1:database},${2: field},${3: criteria})" - }, - { - "func_name": "DAY", - "req_param": [ - "serial_number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "DAY(${1:serial_number})" - }, - { - "func_name": "DAYS", - "req_param": [ - "end_date", - "start_date" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "DAYS(${1:end_date},${2: start_date})" - }, - { - "func_name": "DAYS360", - "req_param": [ - "start_date", - "end_date" - ], - "opt_param": [ - "method" - ], - "ellipsis": false, - "comp_str": "DAYS360(${1:start_date},${2: end_date}${3:,${4: [method]}})" - }, - { - "func_name": "DB", - "req_param": [ - "cost", - "salvage", - "life", - "period" - ], - "opt_param": [ - "month" - ], - "ellipsis": false, - "comp_str": "DB(${1:cost},${2: salvage},${3: life},${4: period}${5:,${6: [month]}})" - }, - { - "func_name": "DBCS", - "req_param": [ - "text" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "DBCS(${1:text})" - }, - { - "func_name": "DCOUNT", - "req_param": [ - "database", - "field", - "criteria" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "DCOUNT(${1:database},${2: field},${3: criteria})" - }, - { - "func_name": "DCOUNTA", - "req_param": [ - "database", - "field", - "criteria" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "DCOUNTA(${1:database},${2: field},${3: criteria})" - }, - { - "func_name": "DDB", - "req_param": [ - "cost", - "salvage", - "life", - "period" - ], - "opt_param": [ - "factor" - ], - "ellipsis": false, - "comp_str": "DDB(${1:cost},${2: salvage},${3: life},${4: period}${5:,${6: [factor]}})" - }, - { - "func_name": "DEC2BIN", - "req_param": [ - "number" - ], - "opt_param": [ - "places" - ], - "ellipsis": false, - "comp_str": "DEC2BIN(${1:number}${2:,${3: [places]}})" - }, - { - "func_name": "DEC2HEX", - "req_param": [ - "number" - ], - "opt_param": [ - "places" - ], - "ellipsis": false, - "comp_str": "DEC2HEX(${1:number}${2:,${3: [places]}})" - }, - { - "func_name": "DEC2OCT", - "req_param": [ - "number" - ], - "opt_param": [ - "places" - ], - "ellipsis": false, - "comp_str": "DEC2OCT(${1:number}${2:,${3: [places]}})" - }, - { - "func_name": "DECIMAL", - "req_param": [ - "number", - "radix" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "DECIMAL(${1:number},${2: radix})" - }, - { - "func_name": "DEGREES", - "req_param": [ - "angle" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "DEGREES(${1:angle})" - }, - { - "func_name": "DELTA", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": false, - "comp_str": "DELTA(${1:number1}${2:,${3: [number2]}})" - }, - { - "func_name": "DEVSQ", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "DEVSQ(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "DGET", - "req_param": [ - "database", - "field", - "criteria" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "DGET(${1:database},${2: field},${3: criteria})" - }, - { - "func_name": "DISC", - "req_param": [ - "settlement", - "maturity", - "pr", - "redemption" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "DISC(${1:settlement},${2: maturity},${3: pr},${4: redemption}${5:,${6: [basis]}})" - }, - { - "func_name": "DMAX", - "req_param": [ - "database", - "field", - "criteria" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "DMAX(${1:database},${2: field},${3: criteria})" - }, - { - "func_name": "DMIN", - "req_param": [ - "database", - "field", - "criteria" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "DMIN(${1:database},${2: field},${3: criteria})" - }, - { - "func_name": "DOLLAR", - "req_param": [ - "number" - ], - "opt_param": [ - "decimals" - ], - "ellipsis": false, - "comp_str": "DOLLAR(${1:number}${2:,${3: [decimals]}})" - }, - { - "func_name": "DOLLARDE", - "req_param": [ - "fractional_dollar", - "fraction" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "DOLLARDE(${1:fractional_dollar},${2: fraction})" - }, - { - "func_name": "DOLLARFR", - "req_param": [ - "decimal_dollar", - "fraction" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "DOLLARFR(${1:decimal_dollar},${2: fraction})" - }, - { - "func_name": "DPRODUCT", - "req_param": [ - "database", - "field", - "criteria" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "DPRODUCT(${1:database},${2: field},${3: criteria})" - }, - { - "func_name": "DROP", - "req_param": [ - "array", - "rows" - ], - "opt_param": [ - "columns" - ], - "ellipsis": false, - "comp_str": "DROP(${1:array},${2: rows}${3:,${4: [columns]}})" - }, - { - "func_name": "DSTDEV", - "req_param": [ - "database", - "field", - "criteria" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "DSTDEV(${1:database},${2: field},${3: criteria})" - }, - { - "func_name": "DSTDEVP", - "req_param": [ - "database", - "field", - "criteria" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "DSTDEVP(${1:database},${2: field},${3: criteria})" - }, - { - "func_name": "DSUM", - "req_param": [ - "database", - "field", - "criteria" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "DSUM(${1:database},${2: field},${3: criteria})" - }, - { - "func_name": "DURATION", - "req_param": [ - "settlement", - "maturity", - "coupon", - "yld", - "frequency" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "DURATION(${1:settlement},${2: maturity},${3: coupon},${4: yld},${5: frequency}${6:,${7: [basis]}})" - }, - { - "func_name": "DVAR", - "req_param": [ - "database", - "field", - "criteria" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "DVAR(${1:database},${2: field},${3: criteria})" - }, - { - "func_name": "DVARP", - "req_param": [ - "database", - "field", - "criteria" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "DVARP(${1:database},${2: field},${3: criteria})" - }, - { - "func_name": "EDATE", - "req_param": [ - "start_date", - "months" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "EDATE(${1:start_date},${2: months})" - }, - { - "func_name": "EFFECT", - "req_param": [ - "nominal_rate", - "npery" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "EFFECT(${1:nominal_rate},${2: npery})" - }, - { - "func_name": "ENCODEURL", - "req_param": [ - "text" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ENCODEURL(${1:text})" - }, - { - "func_name": "EOMONTH", - "req_param": [ - "start_date", - "months" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "EOMONTH(${1:start_date},${2: months})" - }, - { - "func_name": "ERF", - "req_param": [ - "lower_limit" - ], - "opt_param": [ - "upper_limit" - ], - "ellipsis": false, - "comp_str": "ERF(${1:lower_limit}${2:,${3: [upper_limit]}})" - }, - { - "func_name": "ERF.PRECISE", - "req_param": [ - "x" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ERF.PRECISE(${1:x})" - }, - { - "func_name": "ERFC", - "req_param": [ - "x" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ERFC(${1:x})" - }, - { - "func_name": "ERFC.PRECISE", - "req_param": [ - "x" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ERFC.PRECISE(${1:x})" - }, - { - "func_name": "ERROR.TYPE", - "req_param": [ - "error_val" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ERROR.TYPE(${1:error_val})" - }, - { - "func_name": "EUROCONVERT", - "req_param": [ - "number", - "source", - "target", - "full_precision", - "triangulation_precision" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "EUROCONVERT(${1:number},${2: source},${3: target},${4: full_precision},${5: triangulation_precision})" - }, - { - "func_name": "EVEN", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "EVEN(${1:number})" - }, - { - "func_name": "EXACT", - "req_param": [ - "text1", - "text2" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "EXACT(${1:text1},${2: text2})" - }, - { - "func_name": "EXP", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "EXP(${1:number})" - }, - { - "func_name": "EXPAND", - "req_param": [ - "array", - "rows" - ], - "opt_param": [ - "columns", - "pad_with" - ], - "ellipsis": false, - "comp_str": "EXPAND(${1:array},${2: rows}${3:,${4: [columns]},${5: [pad_with]}})" - }, - { - "func_name": "EXPON.DIST", - "req_param": [ - "x", - "lambda", - "cumulative" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "EXPON.DIST(${1:x},${2: lambda},${3: cumulative})" - }, - { - "func_name": "EXPONDIST", - "req_param": [ - "x", - "lambda", - "cumulative" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "EXPONDIST(${1:x},${2: lambda},${3: cumulative})" - }, - { - "func_name": "F.DIST", - "req_param": [ - "x", - "deg_freedom1", - "deg_freedom2", - "cumulative" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "F.DIST(${1:x},${2: deg_freedom1},${3: deg_freedom2},${4: cumulative})" - }, - { - "func_name": "F.DIST.RT", - "req_param": [ - "x", - "deg_freedom1", - "deg_freedom2" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "F.DIST.RT(${1:x},${2: deg_freedom1},${3: deg_freedom2})" - }, - { - "func_name": "F.INV", - "req_param": [ - "probability", - "deg_freedom1", - "deg_freedom2" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "F.INV(${1:probability},${2: deg_freedom1},${3: deg_freedom2})" - }, - { - "func_name": "F.INV.RT", - "req_param": [ - "probability", - "deg_freedom1", - "deg_freedom2" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "F.INV.RT(${1:probability},${2: deg_freedom1},${3: deg_freedom2})" - }, - { - "func_name": "F.TEST", - "req_param": [ - "array1", - "array2" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "F.TEST(${1:array1},${2: array2})" - }, - { - "func_name": "FACT", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "FACT(${1:number})" - }, - { - "func_name": "FACTDOUBLE", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "FACTDOUBLE(${1:number})" - }, - { - "func_name": "FDIST", - "req_param": [ - "x", - "deg_freedom1", - "deg_freedom2" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "FDIST(${1:x},${2: deg_freedom1},${3: deg_freedom2})" - }, - { - "func_name": "FILTER", - "req_param": [ - "array", - "include" - ], - "opt_param": [ - "if_empty" - ], - "ellipsis": false, - "comp_str": "FILTER(${1:array},${2: include}${3:,${4: [if_empty]}})" - }, - { - "func_name": "FILTERXML", - "req_param": [ - "xml", - "xpath" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "FILTERXML(${1:xml},${2: xpath})" - }, - { - "func_name": "FIND", - "req_param": [ - "find_text", - "within_text" - ], - "opt_param": [ - "start_num" - ], - "ellipsis": false, - "comp_str": "FIND(${1:find_text},${2: within_text}${3:,${4: [start_num]}})" - }, - { - "func_name": "FINDB", - "req_param": [ - "find_text", - "within_text" - ], - "opt_param": [ - "start_num" - ], - "ellipsis": false, - "comp_str": "FINDB(${1:find_text},${2: within_text}${3:,${4: [start_num]}})" - }, - { - "func_name": "FINV", - "req_param": [ - "probability", - "deg_freedom1", - "deg_freedom2" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "FINV(${1:probability},${2: deg_freedom1},${3: deg_freedom2})" - }, - { - "func_name": "FISHER", - "req_param": [ - "x" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "FISHER(${1:x})" - }, - { - "func_name": "FISHERINV", - "req_param": [ - "y" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "FISHERINV(${1:y})" - }, - { - "func_name": "FIXED", - "req_param": [ - "number" - ], - "opt_param": [ - "decimals", - "no_commas" - ], - "ellipsis": false, - "comp_str": "FIXED(${1:number}${2:,${3: [decimals]},${4: [no_commas]}})" - }, - { - "func_name": "FLOOR", - "req_param": [ - "number", - "significance" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "FLOOR(${1:number},${2: significance})" - }, - { - "func_name": "FLOOR.MATH", - "req_param": [ - "number" - ], - "opt_param": [ - "significance", - "mode" - ], - "ellipsis": false, - "comp_str": "FLOOR.MATH(${1:number}${2:,${3: [significance]},${4: [mode]}})" - }, - { - "func_name": "FLOOR.PRECISE", - "req_param": [ - "number" - ], - "opt_param": [ - "significance" - ], - "ellipsis": false, - "comp_str": "FLOOR.PRECISE(${1:number}${2:,${3: [significance]}})" - }, - { - "func_name": "FORECAST", - "req_param": [ - "x", - "known_ys", - "known_xs" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "FORECAST(${1:x},${2: known_ys},${3: known_xs})" - }, - { - "func_name": "FORECAST.ETS", - "req_param": [ - "target_date", - "values", - "timeline" - ], - "opt_param": [ - "seasonality", - "data_completion", - "aggregation" - ], - "ellipsis": false, - "comp_str": "FORECAST.ETS(${1:target_date},${2: values},${3: timeline}${4:,${5: [seasonality]},${6: [data_completion]},${7: [aggregation]}})" - }, - { - "func_name": "FORECAST.ETS.CONFINT", - "req_param": [ - "target_date", - "values", - "timeline" - ], - "opt_param": [ - "confidence_level", - "seasonality", - "data_completion", - "aggregation" - ], - "ellipsis": false, - "comp_str": "FORECAST.ETS.CONFINT(${1:target_date},${2: values},${3: timeline}${4:,${5: [confidence_level]},${6: [seasonality]},${7: [data_completion]},${8: [aggregation]}})" - }, - { - "func_name": "FORECAST.ETS.SEASONALITY", - "req_param": [ - "values", - "timeline" - ], - "opt_param": [ - "data_completion", - "aggregation" - ], - "ellipsis": false, - "comp_str": "FORECAST.ETS.SEASONALITY(${1:values},${2: timeline}${3:,${4: [data_completion]},${5: [aggregation]}})" - }, - { - "func_name": "FORECAST.ETS.STAT", - "req_param": [ - "values", - "timeline", - "statistic_type" - ], - "opt_param": [ - "seasonality", - "data_completion", - "aggregation" - ], - "ellipsis": false, - "comp_str": "FORECAST.ETS.STAT(${1:values},${2: timeline},${3: statistic_type}${4:,${5: [seasonality]},${6: [data_completion]},${7: [aggregation]}})" - }, - { - "func_name": "FORECAST.LINEAR", - "req_param": [ - "x", - "known_ys", - "known_xs" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "FORECAST.LINEAR(${1:x},${2: known_ys},${3: known_xs})" - }, - { - "func_name": "FORMULATEXT", - "req_param": [ - "reference" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "FORMULATEXT(${1:reference})" - }, - { - "func_name": "FREQUENCY", - "req_param": [ - "data_array", - "bins_array" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "FREQUENCY(${1:data_array},${2: bins_array})" - }, - { - "func_name": "FTEST", - "req_param": [ - "array1", - "array2" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "FTEST(${1:array1},${2: array2})" - }, - { - "func_name": "FV", - "req_param": [ - "rate", - "nper", - "pmt" - ], - "opt_param": [ - "pv", - "type" - ], - "ellipsis": false, - "comp_str": "FV(${1:rate},${2: nper},${3: pmt}${4:,${5: [pv]},${6: [type]}})" - }, - { - "func_name": "FVSCHEDULE", - "req_param": [ - "principal", - "schedule" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "FVSCHEDULE(${1:principal},${2: schedule})" - }, - { - "func_name": "GAMMA", - "req_param": [ - "x" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "GAMMA(${1:x})" - }, - { - "func_name": "GAMMA.DIST", - "req_param": [ - "x", - "alpha", - "beta", - "cumulative" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "GAMMA.DIST(${1:x},${2: alpha},${3: beta},${4: cumulative})" - }, - { - "func_name": "GAMMA.INV", - "req_param": [ - "probability", - "alpha", - "beta" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "GAMMA.INV(${1:probability},${2: alpha},${3: beta})" - }, - { - "func_name": "GAMMADIST", - "req_param": [ - "x", - "alpha", - "beta", - "cumulative" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "GAMMADIST(${1:x},${2: alpha},${3: beta},${4: cumulative})" - }, - { - "func_name": "GAMMAINV", - "req_param": [ - "probability", - "alpha", - "beta" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "GAMMAINV(${1:probability},${2: alpha},${3: beta})" - }, - { - "func_name": "GAMMALN", - "req_param": [ - "x" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "GAMMALN(${1:x})" - }, - { - "func_name": "GAMMALN.PRECISE", - "req_param": [ - "x" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "GAMMALN.PRECISE(${1:x})" - }, - { - "func_name": "GAUSS", - "req_param": [ - "x" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "GAUSS(${1:x})" - }, - { - "func_name": "GCD", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "GCD(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "GEOMEAN", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "GEOMEAN(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "GESTEP", - "req_param": [ - "number" - ], - "opt_param": [ - "step" - ], - "ellipsis": false, - "comp_str": "GESTEP(${1:number}${2:,${3: [step]}})" - }, - { - "func_name": "GETPIVOTDATA", - "req_param": [ - "data_field", - "pivot_table" - ], - "opt_param": [ - "field1", - "item1" - ], - "ellipsis": true, - "comp_str": "GETPIVOTDATA(${1:data_field},${2: pivot_table}${3:,${4: [field1]},${5: [item1], ...}})" - }, - { - "func_name": "GROWTH", - "req_param": [ - "known_ys" - ], - "opt_param": [ - "known_xs", - "new_xs", - "const" - ], - "ellipsis": false, - "comp_str": "GROWTH(${1:known_ys}${2:,${3: [known_xs]},${4: [new_xs]},${5: [const]}})" - }, - { - "func_name": "HARMEAN", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "HARMEAN(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "HEX2BIN", - "req_param": [ - "number" - ], - "opt_param": [ - "places" - ], - "ellipsis": false, - "comp_str": "HEX2BIN(${1:number}${2:,${3: [places]}})" - }, - { - "func_name": "HEX2DEC", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "HEX2DEC(${1:number})" - }, - { - "func_name": "HEX2OCT", - "req_param": [ - "number" - ], - "opt_param": [ - "places" - ], - "ellipsis": false, - "comp_str": "HEX2OCT(${1:number}${2:,${3: [places]}})" - }, - { - "func_name": "HLOOKUP", - "req_param": [ - "lookup_value", - "table_array", - "row_index_num" - ], - "opt_param": [ - "range_lookup" - ], - "ellipsis": false, - "comp_str": "HLOOKUP(${1:lookup_value},${2: table_array},${3: row_index_num}${4:,${5: [range_lookup]}})" - }, - { - "func_name": "HOUR", - "req_param": [ - "serial_number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "HOUR(${1:serial_number})" - }, - { - "func_name": "HSTACK", - "req_param": [ - "array1" - ], - "opt_param": [ - "array2" - ], - "ellipsis": true, - "comp_str": "HSTACK(${1:array1}${2:,${3: [array2], ...}})" - }, - { - "func_name": "HYPERLINK", - "req_param": [ - "link_location" - ], - "opt_param": [ - "friendly_name" - ], - "ellipsis": false, - "comp_str": "HYPERLINK(${1:link_location}${2:,${3: [friendly_name]}})" - }, - { - "func_name": "HYPGEOM.DIST", - "req_param": [ - "sample_s", - "number_sample", - "population_s", - "number_pop", - "cumulative" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "HYPGEOM.DIST(${1:sample_s},${2: number_sample},${3: population_s},${4: number_pop},${5: cumulative})" - }, - { - "func_name": "HYPGEOMDIST", - "req_param": [ - "sample_s", - "number_sample", - "population_s", - "number_pop" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "HYPGEOMDIST(${1:sample_s},${2: number_sample},${3: population_s},${4: number_pop})" - }, - { - "func_name": "IF", - "req_param": [ - "logical_test" - ], - "opt_param": [ - "value_if_true", - "value_if_false" - ], - "ellipsis": false, - "comp_str": "IF(${1:logical_test}${2:,${3: [value_if_true]},${4: [value_if_false]}})" - }, - { - "func_name": "IFERROR", - "req_param": [ - "value", - "value_if_error" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IFERROR(${1:value},${2: value_if_error})" - }, - { - "func_name": "IFNA", - "req_param": [ - "value", - "value_if_na" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IFNA(${1:value},${2: value_if_na})" - }, - { - "func_name": "IFS", - "req_param": [ - "logical_test1", - "value_if_true1" - ], - "opt_param": [ - "logical_test2", - "value_if_true2" - ], - "ellipsis": true, - "comp_str": "IFS(${1:logical_test1},${2: value_if_true1}${3:,${4: [logical_test2]},${5: [value_if_true2], ...}})" - }, - { - "func_name": "IMABS", - "req_param": [ - "inumber" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMABS(${1:inumber})" - }, - { - "func_name": "IMAGE", - "req_param": [ - "source" - ], - "opt_param": [ - "alt_text", - "sizing", - "height", - "width" - ], - "ellipsis": false, - "comp_str": "IMAGE(${1:source}${2:,${3: [alt_text]},${4: [sizing]},${5: [height]},${6: [width]}})" - }, - { - "func_name": "IMAGINARY", - "req_param": [ - "inumber" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMAGINARY(${1:inumber})" - }, - { - "func_name": "IMARGUMENT", - "req_param": [ - "inumber" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMARGUMENT(${1:inumber})" - }, - { - "func_name": "IMCONJUGATE", - "req_param": [ - "inumber" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMCONJUGATE(${1:inumber})" - }, - { - "func_name": "IMCOS", - "req_param": [ - "inumber" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMCOS(${1:inumber})" - }, - { - "func_name": "IMCOSH", - "req_param": [ - "inumber" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMCOSH(${1:inumber})" - }, - { - "func_name": "IMCOT", - "req_param": [ - "inumber" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMCOT(${1:inumber})" - }, - { - "func_name": "IMCSC", - "req_param": [ - "inumber" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMCSC(${1:inumber})" - }, - { - "func_name": "IMCSCH", - "req_param": [ - "inumber" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMCSCH(${1:inumber})" - }, - { - "func_name": "IMDIV", - "req_param": [ - "inumber1", - "inumber2" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMDIV(${1:inumber1},${2: inumber2})" - }, - { - "func_name": "IMEXP", - "req_param": [ - "inumber" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMEXP(${1:inumber})" - }, - { - "func_name": "IMLN", - "req_param": [ - "inumber" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMLN(${1:inumber})" - }, - { - "func_name": "IMLOG10", - "req_param": [ - "inumber" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMLOG10(${1:inumber})" - }, - { - "func_name": "IMLOG2", - "req_param": [ - "inumber" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMLOG2(${1:inumber})" - }, - { - "func_name": "IMPOWER", - "req_param": [ - "inumber", - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMPOWER(${1:inumber},${2: number})" - }, - { - "func_name": "IMPRODUCT", - "req_param": [ - "inumber1" - ], - "opt_param": [ - "inumber2" - ], - "ellipsis": true, - "comp_str": "IMPRODUCT(${1:inumber1}${2:,${3: [inumber2], ...}})" - }, - { - "func_name": "IMREAL", - "req_param": [ - "inumber" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMREAL(${1:inumber})" - }, - { - "func_name": "IMSEC", - "req_param": [ - "inumber" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMSEC(${1:inumber})" - }, - { - "func_name": "IMSECH", - "req_param": [ - "inumber" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMSECH(${1:inumber})" - }, - { - "func_name": "IMSIN", - "req_param": [ - "inumber" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMSIN(${1:inumber})" - }, - { - "func_name": "IMSINH", - "req_param": [ - "inumber" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMSINH(${1:inumber})" - }, - { - "func_name": "IMSQRT", - "req_param": [ - "inumber" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMSQRT(${1:inumber})" - }, - { - "func_name": "IMSUB", - "req_param": [ - "inumber1", - "inumber2" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMSUB(${1:inumber1},${2: inumber2})" - }, - { - "func_name": "IMSUM", - "req_param": [ - "inumber1" - ], - "opt_param": [ - "inumber2" - ], - "ellipsis": true, - "comp_str": "IMSUM(${1:inumber1}${2:,${3: [inumber2], ...}})" - }, - { - "func_name": "IMTAN", - "req_param": [ - "inumber" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "IMTAN(${1:inumber})" - }, - { - "func_name": "INDEX", - "req_param": [ - "array", - "row_num" - ], - "opt_param": [ - "column_num" - ], - "ellipsis": false, - "comp_str": "INDEX(${1:array},${2: row_num}${3:,${4: [column_num]}})" - }, - { - "func_name": "INDIRECT", - "req_param": [ - "ref_text" - ], - "opt_param": [ - "a1" - ], - "ellipsis": false, - "comp_str": "INDIRECT(${1:ref_text}${2:,${3: [a1]}})" - }, - { - "func_name": "INFO", - "req_param": [ - "type_text" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "INFO(${1:type_text})" - }, - { - "func_name": "INT", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "INT(${1:number})" - }, - { - "func_name": "INTERCEPT", - "req_param": [ - "known_ys", - "known_xs" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "INTERCEPT(${1:known_ys},${2: known_xs})" - }, - { - "func_name": "INTRATE", - "req_param": [ - "settlement", - "maturity", - "investment", - "redemption" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "INTRATE(${1:settlement},${2: maturity},${3: investment},${4: redemption}${5:,${6: [basis]}})" - }, - { - "func_name": "IPMT", - "req_param": [ - "rate", - "per", - "nper", - "pv" - ], - "opt_param": [ - "fv", - "type" - ], - "ellipsis": false, - "comp_str": "IPMT(${1:rate},${2: per},${3: nper},${4: pv}${5:,${6: [fv]},${7: [type]}})" - }, - { - "func_name": "IRR", - "req_param": [ - "values" - ], - "opt_param": [ - "guess" - ], - "ellipsis": false, - "comp_str": "IRR(${1:values}${2:,${3: [guess]}})" - }, - { - "func_name": "ISBLANK", - "req_param": [ - "value" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ISBLANK(${1:value})" - }, - { - "func_name": "ISERR", - "req_param": [ - "value" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ISERR(${1:value})" - }, - { - "func_name": "ISERROR", - "req_param": [ - "value" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ISERROR(${1:value})" - }, - { - "func_name": "ISEVEN", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ISEVEN(${1:number})" - }, - { - "func_name": "ISFORMULA", - "req_param": [ - "reference" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ISFORMULA(${1:reference})" - }, - { - "func_name": "ISLOGICAL", - "req_param": [ - "value" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ISLOGICAL(${1:value})" - }, - { - "func_name": "ISNA", - "req_param": [ - "value" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ISNA(${1:value})" - }, - { - "func_name": "ISNONTEXT", - "req_param": [ - "value" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ISNONTEXT(${1:value})" - }, - { - "func_name": "ISNUMBER", - "req_param": [ - "value" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ISNUMBER(${1:value})" - }, - { - "func_name": "ISO.CEILING", - "req_param": [ - "number" - ], - "opt_param": [ - "significance" - ], - "ellipsis": false, - "comp_str": "ISO.CEILING(${1:number}${2:,${3: [significance]}})" - }, - { - "func_name": "ISODD", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ISODD(${1:number})" - }, - { - "func_name": "ISOMITTED", - "req_param": [ - "argument" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ISOMITTED(${1:argument})" - }, - { - "func_name": "ISOWEEKNUM", - "req_param": [ - "date" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ISOWEEKNUM(${1:date})" - }, - { - "func_name": "ISPMT", - "req_param": [ - "rate", - "per", - "nper", - "pv" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ISPMT(${1:rate},${2: per},${3: nper},${4: pv})" - }, - { - "func_name": "ISREF", - "req_param": [ - "value" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ISREF(${1:value})" - }, - { - "func_name": "ISTEXT", - "req_param": [ - "value" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ISTEXT(${1:value})" - }, - { - "func_name": "JIS", - "req_param": [ - "text" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "JIS(${1:text})" - }, - { - "func_name": "KURT", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "KURT(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "LAMBDA", - "req_param": [ - "parameter_or_calculation1" - ], - "opt_param": [ - "parameter_or_calculation2" - ], - "ellipsis": true, - "comp_str": "LAMBDA(${1:parameter_or_calculation1}${2:,${3: [parameter_or_calculation2], ...}})" - }, - { - "func_name": "LARGE", - "req_param": [ - "array", - "k" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "LARGE(${1:array},${2: k})" - }, - { - "func_name": "LCM", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "LCM(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "LEFT", - "req_param": [ - "text" - ], - "opt_param": [ - "num_chars" - ], - "ellipsis": false, - "comp_str": "LEFT(${1:text}${2:,${3: [num_chars]}})" - }, - { - "func_name": "LEFTB", - "req_param": [ - "text" - ], - "opt_param": [ - "num_bytes" - ], - "ellipsis": false, - "comp_str": "LEFTB(${1:text}${2:,${3: [num_bytes]}})" - }, - { - "func_name": "LEN", - "req_param": [ - "text" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "LEN(${1:text})" - }, - { - "func_name": "LENB", - "req_param": [ - "text" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "LENB(${1:text})" - }, - { - "func_name": "LET", - "req_param": [ - "name1", - "name_value1", - "calculation_or_name2" - ], - "opt_param": [ - "name_value2" - ], - "ellipsis": true, - "comp_str": "LET(${1:name1},${2: name_value1},${3: calculation_or_name2}${4:,${5: [name_value2], ...}})" - }, - { - "func_name": "LINEST", - "req_param": [ - "known_ys" - ], - "opt_param": [ - "known_xs", - "const", - "stats" - ], - "ellipsis": false, - "comp_str": "LINEST(${1:known_ys}${2:,${3: [known_xs]},${4: [const]},${5: [stats]}})" - }, - { - "func_name": "LN", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "LN(${1:number})" - }, - { - "func_name": "LOG", - "req_param": [ - "number" - ], - "opt_param": [ - "base" - ], - "ellipsis": false, - "comp_str": "LOG(${1:number}${2:,${3: [base]}})" - }, - { - "func_name": "LOG10", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "LOG10(${1:number})" - }, - { - "func_name": "LOGEST", - "req_param": [ - "known_ys" - ], - "opt_param": [ - "known_xs", - "const", - "stats" - ], - "ellipsis": false, - "comp_str": "LOGEST(${1:known_ys}${2:,${3: [known_xs]},${4: [const]},${5: [stats]}})" - }, - { - "func_name": "LOGINV", - "req_param": [ - "probability", - "mean", - "standard_dev" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "LOGINV(${1:probability},${2: mean},${3: standard_dev})" - }, - { - "func_name": "LOGNORM.DIST", - "req_param": [ - "x", - "mean", - "standard_dev", - "cumulative" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "LOGNORM.DIST(${1:x},${2: mean},${3: standard_dev},${4: cumulative})" - }, - { - "func_name": "LOGNORM.INV", - "req_param": [ - "probability", - "mean", - "standard_dev" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "LOGNORM.INV(${1:probability},${2: mean},${3: standard_dev})" - }, - { - "func_name": "LOGNORMDIST", - "req_param": [ - "x", - "mean", - "standard_dev" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "LOGNORMDIST(${1:x},${2: mean},${3: standard_dev})" - }, - { - "func_name": "LOOKUP", - "req_param": [ - "lookup_value", - "lookup_vector" - ], - "opt_param": [ - "result_vector" - ], - "ellipsis": false, - "comp_str": "LOOKUP(${1:lookup_value},${2: lookup_vector}${3:,${4: [result_vector]}})" - }, - { - "func_name": "LOWER", - "req_param": [ - "text" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "LOWER(${1:text})" - }, - { - "func_name": "MAKEARRAY", - "req_param": [ - "rows", - "columns", - "function" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "MAKEARRAY(${1:rows},${2: columns},${3: function})" - }, - { - "func_name": "MAP", - "req_param": [ - "array", - "lambda_or_array2" - ], - "opt_param": [ - "lambda_or_array3" - ], - "ellipsis": true, - "comp_str": "MAP(${1:array},${2: lambda_or_array2}${3:,${4: [lambda_or_array3], ...}})" - }, - { - "func_name": "MATCH", - "req_param": [ - "lookup_value", - "lookup_array" - ], - "opt_param": [ - "match_type" - ], - "ellipsis": false, - "comp_str": "MATCH(${1:lookup_value},${2: lookup_array}${3:,${4: [match_type]}})" - }, - { - "func_name": "MAX", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "MAX(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "MAXA", - "req_param": [ - "value1" - ], - "opt_param": [ - "value2" - ], - "ellipsis": true, - "comp_str": "MAXA(${1:value1}${2:,${3: [value2], ...}})" - }, - { - "func_name": "MAXIFS", - "req_param": [ - "max_range", - "criteria_range1", - "criteria1" - ], - "opt_param": [ - "criteria_range2", - "criteria2" - ], - "ellipsis": true, - "comp_str": "MAXIFS(${1:max_range},${2: criteria_range1},${3: criteria1}${4:,${5: [criteria_range2]},${6: [criteria2], ...}})" - }, - { - "func_name": "MDETERM", - "req_param": [ - "array" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "MDETERM(${1:array})" - }, - { - "func_name": "MDURATION", - "req_param": [ - "settlement", - "maturity", - "coupon", - "yld", - "frequency" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "MDURATION(${1:settlement},${2: maturity},${3: coupon},${4: yld},${5: frequency}${6:,${7: [basis]}})" - }, - { - "func_name": "MEDIAN", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "MEDIAN(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "MID", - "req_param": [ - "text", - "start_num", - "num_chars" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "MID(${1:text},${2: start_num},${3: num_chars})" - }, - { - "func_name": "MIDB", - "req_param": [ - "text", - "start_num", - "num_bytes" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "MIDB(${1:text},${2: start_num},${3: num_bytes})" - }, - { - "func_name": "MIN", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "MIN(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "MINA", - "req_param": [ - "value1" - ], - "opt_param": [ - "value2" - ], - "ellipsis": true, - "comp_str": "MINA(${1:value1}${2:,${3: [value2], ...}})" - }, - { - "func_name": "MINIFS", - "req_param": [ - "min_range", - "criteria_range1", - "criteria1" - ], - "opt_param": [ - "criteria_range2", - "criteria2" - ], - "ellipsis": true, - "comp_str": "MINIFS(${1:min_range},${2: criteria_range1},${3: criteria1}${4:,${5: [criteria_range2]},${6: [criteria2], ...}})" - }, - { - "func_name": "MINUTE", - "req_param": [ - "serial_number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "MINUTE(${1:serial_number})" - }, - { - "func_name": "MINVERSE", - "req_param": [ - "array" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "MINVERSE(${1:array})" - }, - { - "func_name": "MIRR", - "req_param": [ - "values", - "finance_rate", - "reinvest_rate" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "MIRR(${1:values},${2: finance_rate},${3: reinvest_rate})" - }, - { - "func_name": "MMULT", - "req_param": [ - "array1", - "array2" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "MMULT(${1:array1},${2: array2})" - }, - { - "func_name": "MOD", - "req_param": [ - "number", - "divisor" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "MOD(${1:number},${2: divisor})" - }, - { - "func_name": "MODE", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "MODE(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "MODE.MULT", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "MODE.MULT(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "MODE.SNGL", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "MODE.SNGL(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "MONTH", - "req_param": [ - "serial_number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "MONTH(${1:serial_number})" - }, - { - "func_name": "MROUND", - "req_param": [ - "number", - "multiple" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "MROUND(${1:number},${2: multiple})" - }, - { - "func_name": "MULTINOMIAL", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "MULTINOMIAL(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "MUNIT", - "req_param": [ - "dimension" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "MUNIT(${1:dimension})" - }, - { - "func_name": "N", - "req_param": [ - "value" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "N(${1:value})" - }, - { - "func_name": "NEGBINOM.DIST", - "req_param": [ - "number_f", - "number_s", - "probability_s", - "cumulative" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "NEGBINOM.DIST(${1:number_f},${2: number_s},${3: probability_s},${4: cumulative})" - }, - { - "func_name": "NEGBINOMDIST", - "req_param": [ - "number_f", - "number_s", - "probability_s" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "NEGBINOMDIST(${1:number_f},${2: number_s},${3: probability_s})" - }, - { - "func_name": "NETWORKDAYS", - "req_param": [ - "start_date", - "end_date" - ], - "opt_param": [ - "holidays" - ], - "ellipsis": false, - "comp_str": "NETWORKDAYS(${1:start_date},${2: end_date}${3:,${4: [holidays]}})" - }, - { - "func_name": "NETWORKDAYS.INTL", - "req_param": [ - "start_date", - "end_date" - ], - "opt_param": [ - "weekend", - "holidays" - ], - "ellipsis": false, - "comp_str": "NETWORKDAYS.INTL(${1:start_date},${2: end_date}${3:,${4: [weekend]},${5: [holidays]}})" - }, - { - "func_name": "NOMINAL", - "req_param": [ - "effect_rate", - "npery" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "NOMINAL(${1:effect_rate},${2: npery})" - }, - { - "func_name": "NORM.DIST", - "req_param": [ - "x", - "mean", - "standard_dev", - "cumulative" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "NORM.DIST(${1:x},${2: mean},${3: standard_dev},${4: cumulative})" - }, - { - "func_name": "NORM.INV", - "req_param": [ - "probability", - "mean", - "standard_dev" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "NORM.INV(${1:probability},${2: mean},${3: standard_dev})" - }, - { - "func_name": "NORM.S.DIST", - "req_param": [ - "z", - "cumulative" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "NORM.S.DIST(${1:z},${2: cumulative})" - }, - { - "func_name": "NORM.S.INV", - "req_param": [ - "probability" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "NORM.S.INV(${1:probability})" - }, - { - "func_name": "NORMDIST", - "req_param": [ - "x", - "mean", - "standard_dev", - "cumulative" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "NORMDIST(${1:x},${2: mean},${3: standard_dev},${4: cumulative})" - }, - { - "func_name": "NORMINV", - "req_param": [ - "probability", - "mean", - "standard_dev" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "NORMINV(${1:probability},${2: mean},${3: standard_dev})" - }, - { - "func_name": "NORMSDIST", - "req_param": [ - "z" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "NORMSDIST(${1:z})" - }, - { - "func_name": "NORMSINV", - "req_param": [ - "probability" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "NORMSINV(${1:probability})" - }, - { - "func_name": "NOT", - "req_param": [ - "logical" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "NOT(${1:logical})" - }, - { - "func_name": "NPER", - "req_param": [ - "rate", - "pmt", - "pv" - ], - "opt_param": [ - "fv", - "type" - ], - "ellipsis": false, - "comp_str": "NPER(${1:rate},${2: pmt},${3: pv}${4:,${5: [fv]},${6: [type]}})" - }, - { - "func_name": "NPV", - "req_param": [ - "rate", - "value1" - ], - "opt_param": [ - "value2" - ], - "ellipsis": true, - "comp_str": "NPV(${1:rate},${2: value1}${3:,${4: [value2], ...}})" - }, - { - "func_name": "NUMBERVALUE", - "req_param": [ - "text" - ], - "opt_param": [ - "decimal_separator", - "group_separator" - ], - "ellipsis": false, - "comp_str": "NUMBERVALUE(${1:text}${2:,${3: [decimal_separator]},${4: [group_separator]}})" - }, - { - "func_name": "OCT2BIN", - "req_param": [ - "number" - ], - "opt_param": [ - "places" - ], - "ellipsis": false, - "comp_str": "OCT2BIN(${1:number}${2:,${3: [places]}})" - }, - { - "func_name": "OCT2DEC", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "OCT2DEC(${1:number})" - }, - { - "func_name": "OCT2HEX", - "req_param": [ - "number" - ], - "opt_param": [ - "places" - ], - "ellipsis": false, - "comp_str": "OCT2HEX(${1:number}${2:,${3: [places]}})" - }, - { - "func_name": "ODD", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ODD(${1:number})" - }, - { - "func_name": "ODDFPRICE", - "req_param": [ - "settlement", - "maturity", - "issue", - "first_coupon", - "rate", - "yld", - "redemption", - "frequency" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "ODDFPRICE(${1:settlement},${2: maturity},${3: issue},${4: first_coupon},${5: rate},${6: yld},${7: redemption},${8: frequency}${9:,${10: [basis]}})" - }, - { - "func_name": "ODDFYIELD", - "req_param": [ - "settlement", - "maturity", - "issue", - "first_coupon", - "rate", - "pr", - "redemption", - "frequency" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "ODDFYIELD(${1:settlement},${2: maturity},${3: issue},${4: first_coupon},${5: rate},${6: pr},${7: redemption},${8: frequency}${9:,${10: [basis]}})" - }, - { - "func_name": "ODDLPRICE", - "req_param": [ - "settlement", - "maturity", - "last_interest", - "rate", - "yld", - "redemption", - "frequency" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "ODDLPRICE(${1:settlement},${2: maturity},${3: last_interest},${4: rate},${5: yld},${6: redemption},${7: frequency}${8:,${9: [basis]}})" - }, - { - "func_name": "ODDLYIELD", - "req_param": [ - "settlement", - "maturity", - "last_interest", - "rate", - "pr", - "redemption", - "frequency" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "ODDLYIELD(${1:settlement},${2: maturity},${3: last_interest},${4: rate},${5: pr},${6: redemption},${7: frequency}${8:,${9: [basis]}})" - }, - { - "func_name": "OFFSET", - "req_param": [ - "reference", - "rows", - "cols" - ], - "opt_param": [ - "height", - "width" - ], - "ellipsis": false, - "comp_str": "OFFSET(${1:reference},${2: rows},${3: cols}${4:,${5: [height]},${6: [width]}})" - }, - { - "func_name": "OR", - "req_param": [ - "logical1" - ], - "opt_param": [ - "logical2" - ], - "ellipsis": true, - "comp_str": "OR(${1:logical1}${2:,${3: [logical2], ...}})" - }, - { - "func_name": "PDURATION", - "req_param": [ - "rate", - "py", - "fv" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "PDURATION(${1:rate},${2: py},${3: fv})" - }, - { - "func_name": "PEARSON", - "req_param": [ - "array1", - "array2" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "PEARSON(${1:array1},${2: array2})" - }, - { - "func_name": "PERCENTILE", - "req_param": [ - "array", - "k" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "PERCENTILE(${1:array},${2: k})" - }, - { - "func_name": "PERCENTILE.EXC", - "req_param": [ - "array", - "k" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "PERCENTILE.EXC(${1:array},${2: k})" - }, - { - "func_name": "PERCENTILE.INC", - "req_param": [ - "array", - "k" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "PERCENTILE.INC(${1:array},${2: k})" - }, - { - "func_name": "PERCENTRANK", - "req_param": [ - "array", - "x" - ], - "opt_param": [ - "significance" - ], - "ellipsis": false, - "comp_str": "PERCENTRANK(${1:array},${2: x}${3:,${4: [significance]}})" - }, - { - "func_name": "PERCENTRANK.EXC", - "req_param": [ - "array", - "x" - ], - "opt_param": [ - "significance" - ], - "ellipsis": false, - "comp_str": "PERCENTRANK.EXC(${1:array},${2: x}${3:,${4: [significance]}})" - }, - { - "func_name": "PERCENTRANK.INC", - "req_param": [ - "array", - "x" - ], - "opt_param": [ - "significance" - ], - "ellipsis": false, - "comp_str": "PERCENTRANK.INC(${1:array},${2: x}${3:,${4: [significance]}})" - }, - { - "func_name": "PERMUT", - "req_param": [ - "number", - "number_chosen" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "PERMUT(${1:number},${2: number_chosen})" - }, - { - "func_name": "PERMUTATIONA", - "req_param": [ - "number", - "number_chosen" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "PERMUTATIONA(${1:number},${2: number_chosen})" - }, - { - "func_name": "PHI", - "req_param": [ - "x" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "PHI(${1:x})" - }, - { - "func_name": "PHONETIC", - "req_param": [ - "reference" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "PHONETIC(${1:reference})" - }, - { - "func_name": "PMT", - "req_param": [ - "rate", - "nper", - "pv" - ], - "opt_param": [ - "fv", - "type" - ], - "ellipsis": false, - "comp_str": "PMT(${1:rate},${2: nper},${3: pv}${4:,${5: [fv]},${6: [type]}})" - }, - { - "func_name": "POISSON", - "req_param": [ - "x", - "mean", - "cumulative" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "POISSON(${1:x},${2: mean},${3: cumulative})" - }, - { - "func_name": "POISSON.DIST", - "req_param": [ - "x", - "mean", - "cumulative" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "POISSON.DIST(${1:x},${2: mean},${3: cumulative})" - }, - { - "func_name": "POWER", - "req_param": [ - "number", - "power" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "POWER(${1:number},${2: power})" - }, - { - "func_name": "PPMT", - "req_param": [ - "rate", - "per", - "nper", - "pv" - ], - "opt_param": [ - "fv", - "type" - ], - "ellipsis": false, - "comp_str": "PPMT(${1:rate},${2: per},${3: nper},${4: pv}${5:,${6: [fv]},${7: [type]}})" - }, - { - "func_name": "PRICE", - "req_param": [ - "settlement", - "maturity", - "rate", - "yld", - "redemption", - "frequency" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "PRICE(${1:settlement},${2: maturity},${3: rate},${4: yld},${5: redemption},${6: frequency}${7:,${8: [basis]}})" - }, - { - "func_name": "PRICEDISC", - "req_param": [ - "settlement", - "maturity", - "discount", - "redemption" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "PRICEDISC(${1:settlement},${2: maturity},${3: discount},${4: redemption}${5:,${6: [basis]}})" - }, - { - "func_name": "PRICEMAT", - "req_param": [ - "settlement", - "maturity", - "issue", - "rate", - "yld" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "PRICEMAT(${1:settlement},${2: maturity},${3: issue},${4: rate},${5: yld}${6:,${7: [basis]}})" - }, - { - "func_name": "PROB", - "req_param": [ - "x_range", - "prob_range", - "lower_limit" - ], - "opt_param": [ - "upper_limit" - ], - "ellipsis": false, - "comp_str": "PROB(${1:x_range},${2: prob_range},${3: lower_limit}${4:,${5: [upper_limit]}})" - }, - { - "func_name": "PRODUCT", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "PRODUCT(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "PROPER", - "req_param": [ - "text" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "PROPER(${1:text})" - }, - { - "func_name": "PV", - "req_param": [ - "rate", - "nper", - "pmt" - ], - "opt_param": [ - "fv", - "typel" - ], - "ellipsis": false, - "comp_str": "PV(${1:rate},${2: nper},${3: pmt}${4:,${5: [fv]},${6: [typel]}})" - }, - { - "func_name": "QUARTILE", - "req_param": [ - "array", - "quart" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "QUARTILE(${1:array},${2: quart})" - }, - { - "func_name": "QUARTILE.EXC", - "req_param": [ - "array", - "quart" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "QUARTILE.EXC(${1:array},${2: quart})" - }, - { - "func_name": "QUARTILE.INC", - "req_param": [ - "array", - "quart" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "QUARTILE.INC(${1:array},${2: quart})" - }, - { - "func_name": "QUOTIENT", - "req_param": [ - "numerator", - "denominator" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "QUOTIENT(${1:numerator},${2: denominator})" - }, - { - "func_name": "RADIANS", - "req_param": [ - "angle" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "RADIANS(${1:angle})" - }, - { - "func_name": "RANDARRAY", - "req_param": [], - "opt_param": [ - "rows", - "columns", - "min", - "max", - "integer" - ], - "ellipsis": false, - "comp_str": "RANDARRAY(${1:,${2: [rows]},${3: [columns]},${4: [min]},${5: [max]},${6: [integer]}})" - }, - { - "func_name": "RANDBETWEEN", - "req_param": [ - "bottom", - "top" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "RANDBETWEEN(${1:bottom},${2: top})" - }, - { - "func_name": "RANK", - "req_param": [ - "number", - "ref" - ], - "opt_param": [ - "order" - ], - "ellipsis": false, - "comp_str": "RANK(${1:number},${2: ref}${3:,${4: [order]}})" - }, - { - "func_name": "RANK.AVG", - "req_param": [ - "number", - "ref" - ], - "opt_param": [ - "order" - ], - "ellipsis": false, - "comp_str": "RANK.AVG(${1:number},${2: ref}${3:,${4: [order]}})" - }, - { - "func_name": "RANK.EQ", - "req_param": [ - "number", - "ref" - ], - "opt_param": [ - "order" - ], - "ellipsis": false, - "comp_str": "RANK.EQ(${1:number},${2: ref}${3:,${4: [order]}})" - }, - { - "func_name": "RATE", - "req_param": [ - "nper", - "pmt", - "pv" - ], - "opt_param": [ - "fv", - "type", - "guess" - ], - "ellipsis": false, - "comp_str": "RATE(${1:nper},${2: pmt},${3: pv}${4:,${5: [fv]},${6: [type]},${7: [guess]}})" - }, - { - "func_name": "RECEIVED", - "req_param": [ - "settlement", - "maturity", - "investment", - "discount" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "RECEIVED(${1:settlement},${2: maturity},${3: investment},${4: discount}${5:,${6: [basis]}})" - }, - { - "func_name": "REDUCE", - "req_param": [ - "initial_value", - "array", - "function" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "REDUCE(${1:initial_value},${2: array},${3: function})" - }, - { - "func_name": "REGISTER", - "req_param": [ - "module_text", - "procedure", - "type_text" - ], - "opt_param": [ - "argument1" - ], - "ellipsis": true, - "comp_str": "REGISTER(${1:module_text},${2: procedure},${3: type_text}${4:,${5: [argument1], ...}})" - }, - { - "func_name": "REGISTER.ID", - "req_param": [ - "module_text", - "procedure" - ], - "opt_param": [ - "type_text" - ], - "ellipsis": false, - "comp_str": "REGISTER.ID(${1:module_text},${2: procedure}${3:,${4: [type_text]}})" - }, - { - "func_name": "REPLACE", - "req_param": [ - "old_text", - "start_num", - "num_chars", - "new_text" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "REPLACE(${1:old_text},${2: start_num},${3: num_chars},${4: new_text})" - }, - { - "func_name": "REPLACEB", - "req_param": [ - "old_text", - "start_num", - "num_bytes", - "new_text" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "REPLACEB(${1:old_text},${2: start_num},${3: num_bytes},${4: new_text})" - }, - { - "func_name": "REPT", - "req_param": [ - "text", - "number_times" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "REPT(${1:text},${2: number_times})" - }, - { - "func_name": "RIGHT", - "req_param": [ - "text" - ], - "opt_param": [ - "num_chars" - ], - "ellipsis": false, - "comp_str": "RIGHT(${1:text}${2:,${3: [num_chars]}})" - }, - { - "func_name": "RIGHTB", - "req_param": [ - "text" - ], - "opt_param": [ - "num_bytes" - ], - "ellipsis": false, - "comp_str": "RIGHTB(${1:text}${2:,${3: [num_bytes]}})" - }, - { - "func_name": "ROMAN", - "req_param": [ - "number" - ], - "opt_param": [ - "form" - ], - "ellipsis": false, - "comp_str": "ROMAN(${1:number}${2:,${3: [form]}})" - }, - { - "func_name": "ROUND", - "req_param": [ - "number", - "num_digits" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ROUND(${1:number},${2: num_digits})" - }, - { - "func_name": "ROUNDDOWN", - "req_param": [ - "number", - "num_digits" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ROUNDDOWN(${1:number},${2: num_digits})" - }, - { - "func_name": "ROUNDUP", - "req_param": [ - "number", - "num_digits" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ROUNDUP(${1:number},${2: num_digits})" - }, - { - "func_name": "ROW", - "req_param": [], - "opt_param": [ - "reference" - ], - "ellipsis": false, - "comp_str": "ROW(${1:,${2: [reference]}})" - }, - { - "func_name": "ROWS", - "req_param": [ - "array" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "ROWS(${1:array})" - }, - { - "func_name": "RRI", - "req_param": [ - "nper", - "pv", - "fv" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "RRI(${1:nper},${2: pv},${3: fv})" - }, - { - "func_name": "RSQ", - "req_param": [ - "known_ys", - "known_xs" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "RSQ(${1:known_ys},${2: known_xs})" - }, - { - "func_name": "RTD", - "req_param": [ - "progID", - "server", - "topic1" - ], - "opt_param": [ - "topic2" - ], - "ellipsis": true, - "comp_str": "RTD(${1:progID},${2: server},${3: topic1}${4:,${5: [topic2], ...}})" - }, - { - "func_name": "SCAN", - "req_param": [ - "initial_value", - "array", - "function" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "SCAN(${1:initial_value},${2: array},${3: function})" - }, - { - "func_name": "SEARCH", - "req_param": [ - "find_text", - "within_text" - ], - "opt_param": [ - "start_num" - ], - "ellipsis": false, - "comp_str": "SEARCH(${1:find_text},${2: within_text}${3:,${4: [start_num]}})" - }, - { - "func_name": "SEARCHB", - "req_param": [ - "find_text", - "within_text" - ], - "opt_param": [ - "start_num" - ], - "ellipsis": false, - "comp_str": "SEARCHB(${1:find_text},${2: within_text}${3:,${4: [start_num]}})" - }, - { - "func_name": "SEC", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "SEC(${1:number})" - }, - { - "func_name": "SECH", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "SECH(${1:number})" - }, - { - "func_name": "SECOND", - "req_param": [ - "serial_number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "SECOND(${1:serial_number})" - }, - { - "func_name": "SEQUENCE", - "req_param": [ - "rows" - ], - "opt_param": [ - "columns", - "start", - "step" - ], - "ellipsis": false, - "comp_str": "SEQUENCE(${1:rows}${2:,${3: [columns]},${4: [start]},${5: [step]}})" - }, - { - "func_name": "SERIESSUM", - "req_param": [ - "x", - "n", - "m", - "coefficients" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "SERIESSUM(${1:x},${2: n},${3: m},${4: coefficients})" - }, - { - "func_name": "SHEET", - "req_param": [], - "opt_param": [ - "value" - ], - "ellipsis": false, - "comp_str": "SHEET(${1:,${2: [value]}})" - }, - { - "func_name": "SHEETS", - "req_param": [], - "opt_param": [ - "reference" - ], - "ellipsis": false, - "comp_str": "SHEETS(${1:,${2: [reference]}})" - }, - { - "func_name": "SIGN", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "SIGN(${1:number})" - }, - { - "func_name": "SIN", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "SIN(${1:number})" - }, - { - "func_name": "SINH", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "SINH(${1:number})" - }, - { - "func_name": "SKEW", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "SKEW(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "SKEW.P", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "SKEW.P(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "SLN", - "req_param": [ - "cost", - "salvage", - "life" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "SLN(${1:cost},${2: salvage},${3: life})" - }, - { - "func_name": "SLOPE", - "req_param": [ - "known_ys", - "known_xs" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "SLOPE(${1:known_ys},${2: known_xs})" - }, - { - "func_name": "SMALL", - "req_param": [ - "array", - "k" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "SMALL(${1:array},${2: k})" - }, - { - "func_name": "SORT", - "req_param": [ - "array" - ], - "opt_param": [ - "sort_index", - "sort_order", - "by_col" - ], - "ellipsis": false, - "comp_str": "SORT(${1:array}${2:,${3: [sort_index]},${4: [sort_order]},${5: [by_col]}})" - }, - { - "func_name": "SORTBY", - "req_param": [ - "array", - "by_array1" - ], - "opt_param": [ - "sort_order1" - ], - "ellipsis": true, - "comp_str": "SORTBY(${1:array},${2: by_array1}${3:,${4: [sort_order1], ...}})" - }, - { - "func_name": "SQRT", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "SQRT(${1:number})" - }, - { - "func_name": "SQRTPI", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "SQRTPI(${1:number})" - }, - { - "func_name": "STANDARDIZE", - "req_param": [ - "x", - "mean", - "standard_dev" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "STANDARDIZE(${1:x},${2: mean},${3: standard_dev})" - }, - { - "func_name": "STDEV", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "STDEV(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "STDEV.P", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "STDEV.P(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "STDEV.S", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "STDEV.S(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "STDEVA", - "req_param": [ - "value1" - ], - "opt_param": [ - "value2" - ], - "ellipsis": true, - "comp_str": "STDEVA(${1:value1}${2:,${3: [value2], ...}})" - }, - { - "func_name": "STDEVP", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "STDEVP(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "STDEVPA", - "req_param": [ - "value1" - ], - "opt_param": [ - "value2" - ], - "ellipsis": true, - "comp_str": "STDEVPA(${1:value1}${2:,${3: [value2], ...}})" - }, - { - "func_name": "STEYX", - "req_param": [ - "known_ys", - "known_xs" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "STEYX(${1:known_ys},${2: known_xs})" - }, - { - "func_name": "STOCKHISTORY", - "req_param": [ - "stock", - "start_date" - ], - "opt_param": [ - "end_date", - "interval", - "headers", - "properties" - ], - "ellipsis": true, - "comp_str": "STOCKHISTORY(${1:stock},${2: start_date}${3:,${4: [end_date]},${5: [interval]},${6: [headers]},${7: [properties], ...}})" - }, - { - "func_name": "SUBSTITUTE", - "req_param": [ - "text", - "old_text", - "new_text" - ], - "opt_param": [ - "instance_num" - ], - "ellipsis": false, - "comp_str": "SUBSTITUTE(${1:text},${2: old_text},${3: new_text}${4:,${5: [instance_num]}})" - }, - { - "func_name": "SUBTOTAL", - "req_param": [ - "function_num", - "ref1" - ], - "opt_param": [ - "ref2" - ], - "ellipsis": true, - "comp_str": "SUBTOTAL(${1:function_num},${2: ref1}${3:,${4: [ref2], ...}})" - }, - { - "func_name": "SUM", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "SUM(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "SUMIF", - "req_param": [ - "range", - "criteria" - ], - "opt_param": [ - "sum_range" - ], - "ellipsis": false, - "comp_str": "SUMIF(${1:range},${2: criteria}${3:,${4: [sum_range]}})" - }, - { - "func_name": "SUMIFS", - "req_param": [ - "sum_range", - "criteria_range1", - "criteria1" - ], - "opt_param": [ - "criteria_range2", - "criteria2" - ], - "ellipsis": true, - "comp_str": "SUMIFS(${1:sum_range},${2: criteria_range1},${3: criteria1}${4:,${5: [criteria_range2]},${6: [criteria2], ...}})" - }, - { - "func_name": "SUMPRODUCT", - "req_param": [ - "array1" - ], - "opt_param": [ - "array2", - "array3" - ], - "ellipsis": true, - "comp_str": "SUMPRODUCT(${1:array1}${2:,${3: [array2]},${4: [array3], ...}})" - }, - { - "func_name": "SUMSQ", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "SUMSQ(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "SUMX2MY2", - "req_param": [ - "array_x", - "array_y" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "SUMX2MY2(${1:array_x},${2: array_y})" - }, - { - "func_name": "SUMX2PY2", - "req_param": [ - "array_x", - "array_y" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "SUMX2PY2(${1:array_x},${2: array_y})" - }, - { - "func_name": "SUMXMY2", - "req_param": [ - "array_x", - "array_y" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "SUMXMY2(${1:array_x},${2: array_y})" - }, - { - "func_name": "SWITCH", - "req_param": [ - "expression", - "value1", - "result1" - ], - "opt_param": [ - "default_or_value2", - "result2" - ], - "ellipsis": true, - "comp_str": "SWITCH(${1:expression},${2: value1},${3: result1}${4:,${5: [default_or_value2]},${6: [result2], ...}})" - }, - { - "func_name": "SYD", - "req_param": [ - "cost", - "salvage", - "life", - "per" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "SYD(${1:cost},${2: salvage},${3: life},${4: per})" - }, - { - "func_name": "T", - "req_param": [ - "value" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "T(${1:value})" - }, - { - "func_name": "T.DIST", - "req_param": [ - "x", - "deg_freedom", - "cumulative" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "T.DIST(${1:x},${2: deg_freedom},${3: cumulative})" - }, - { - "func_name": "T.DIST.2T", - "req_param": [ - "x", - "deg_freedom" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "T.DIST.2T(${1:x},${2: deg_freedom})" - }, - { - "func_name": "T.DIST.RT", - "req_param": [ - "x", - "deg_freedom" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "T.DIST.RT(${1:x},${2: deg_freedom})" - }, - { - "func_name": "T.INV", - "req_param": [ - "probability", - "deg_freedom" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "T.INV(${1:probability},${2: deg_freedom})" - }, - { - "func_name": "T.INV.2T", - "req_param": [ - "probability", - "deg_freedom" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "T.INV.2T(${1:probability},${2: deg_freedom})" - }, - { - "func_name": "T.TEST", - "req_param": [ - "array1", - "array2", - "tails", - "type" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "T.TEST(${1:array1},${2: array2},${3: tails},${4: type})" - }, - { - "func_name": "TAKE", - "req_param": [ - "array", - "rows" - ], - "opt_param": [ - "columns" - ], - "ellipsis": false, - "comp_str": "TAKE(${1:array},${2: rows}${3:,${4: [columns]}})" - }, - { - "func_name": "TAN", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "TAN(${1:number})" - }, - { - "func_name": "TANH", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "TANH(${1:number})" - }, - { - "func_name": "TBILLEQ", - "req_param": [ - "settlement", - "maturity", - "discount" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "TBILLEQ(${1:settlement},${2: maturity},${3: discount})" - }, - { - "func_name": "TBILLPRICE", - "req_param": [ - "settlement", - "maturity", - "discount" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "TBILLPRICE(${1:settlement},${2: maturity},${3: discount})" - }, - { - "func_name": "TBILLYIELD", - "req_param": [ - "settlement", - "maturity", - "pr" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "TBILLYIELD(${1:settlement},${2: maturity},${3: pr})" - }, - { - "func_name": "TDIST", - "req_param": [ - "x", - "deg_freedom", - "tails" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "TDIST(${1:x},${2: deg_freedom},${3: tails})" - }, - { - "func_name": "TEXT", - "req_param": [ - "value", - "format_text" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "TEXT(${1:value},${2: format_text})" - }, - { - "func_name": "TEXTAFTER", - "req_param": [ - "text", - "delimiter" - ], - "opt_param": [ - "instance_num", - "match_mode", - "match_end", - "if_not_found" - ], - "ellipsis": false, - "comp_str": "TEXTAFTER(${1:text},${2: delimiter}${3:,${4: [instance_num]},${5: [match_mode]},${6: [match_end]},${7: [if_not_found]}})" - }, - { - "func_name": "TEXTBEFORE", - "req_param": [ - "text", - "delimiter" - ], - "opt_param": [ - "instance_num", - "match_mode", - "match_end", - "if_not_found" - ], - "ellipsis": false, - "comp_str": "TEXTBEFORE(${1:text},${2: delimiter}${3:,${4: [instance_num]},${5: [match_mode]},${6: [match_end]},${7: [if_not_found]}})" - }, - { - "func_name": "TEXTJOIN", - "req_param": [ - "delimiter", - "ignore_empty", - "text1" - ], - "opt_param": [ - "text2" - ], - "ellipsis": true, - "comp_str": "TEXTJOIN(${1:delimiter},${2: ignore_empty},${3: text1}${4:,${5: [text2], ...}})" - }, - { - "func_name": "TEXTSPLIT", - "req_param": [ - "text", - "col_delimiter" - ], - "opt_param": [ - "row_delimiter", - "ignore_empty", - "match_mode", - "pad_with" - ], - "ellipsis": false, - "comp_str": "TEXTSPLIT(${1:text},${2: col_delimiter}${3:,${4: [row_delimiter]},${5: [ignore_empty]},${6: [match_mode]},${7: [pad_with]}})" - }, - { - "func_name": "TIME", - "req_param": [ - "hour", - "minute", - "second" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "TIME(${1:hour},${2: minute},${3: second})" - }, - { - "func_name": "TIMEVALUE", - "req_param": [ - "time_text" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "TIMEVALUE(${1:time_text})" - }, - { - "func_name": "TINV", - "req_param": [ - "probability", - "deg_freedom" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "TINV(${1:probability},${2: deg_freedom})" - }, - { - "func_name": "TOCOL", - "req_param": [ - "array" - ], - "opt_param": [ - "ignore", - "scan_by_column" - ], - "ellipsis": false, - "comp_str": "TOCOL(${1:array}${2:,${3: [ignore]},${4: [scan_by_column]}})" - }, - { - "func_name": "TOROW", - "req_param": [ - "array" - ], - "opt_param": [ - "ignore", - "scan_by_column" - ], - "ellipsis": false, - "comp_str": "TOROW(${1:array}${2:,${3: [ignore]},${4: [scan_by_column]}})" - }, - { - "func_name": "TRANSPOSE", - "req_param": [ - "array" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "TRANSPOSE(${1:array})" - }, - { - "func_name": "TREND", - "req_param": [ - "known_ys" - ], - "opt_param": [ - "known_xs", - "new_xs", - "const" - ], - "ellipsis": false, - "comp_str": "TREND(${1:known_ys}${2:,${3: [known_xs]},${4: [new_xs]},${5: [const]}})" - }, - { - "func_name": "TRIM", - "req_param": [ - "text" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "TRIM(${1:text})" - }, - { - "func_name": "TRIMMEAN", - "req_param": [ - "array", - "percent" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "TRIMMEAN(${1:array},${2: percent})" - }, - { - "func_name": "TRUNC", - "req_param": [ - "number" - ], - "opt_param": [ - "num_digits" - ], - "ellipsis": false, - "comp_str": "TRUNC(${1:number}${2:,${3: [num_digits]}})" - }, - { - "func_name": "TTEST", - "req_param": [ - "array1", - "array2", - "tails", - "type" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "TTEST(${1:array1},${2: array2},${3: tails},${4: type})" - }, - { - "func_name": "TYPE", - "req_param": [ - "value" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "TYPE(${1:value})" - }, - { - "func_name": "UNICHAR", - "req_param": [ - "number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "UNICHAR(${1:number})" - }, - { - "func_name": "UNICODE", - "req_param": [ - "text" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "UNICODE(${1:text})" - }, - { - "func_name": "UNIQUE", - "req_param": [ - "array" - ], - "opt_param": [ - "by_col", - "exactly_once" - ], - "ellipsis": false, - "comp_str": "UNIQUE(${1:array}${2:,${3: [by_col]},${4: [exactly_once]}})" - }, - { - "func_name": "UNREGISTER", - "req_param": [ - "register_id" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "UNREGISTER(${1:register_id})" - }, - { - "func_name": "UPPER", - "req_param": [ - "text" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "UPPER(${1:text})" - }, - { - "func_name": "VALUE", - "req_param": [ - "text" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "VALUE(${1:text})" - }, - { - "func_name": "VALUETOTEXT", - "req_param": [ - "value" - ], - "opt_param": [ - "format" - ], - "ellipsis": false, - "comp_str": "VALUETOTEXT(${1:value}${2:,${3: [format]}})" - }, - { - "func_name": "VAR", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "VAR(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "VAR.P", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "VAR.P(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "VAR.S", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "VAR.S(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "VARA", - "req_param": [ - "value1" - ], - "opt_param": [ - "value2" - ], - "ellipsis": true, - "comp_str": "VARA(${1:value1}${2:,${3: [value2], ...}})" - }, - { - "func_name": "VARP", - "req_param": [ - "number1" - ], - "opt_param": [ - "number2" - ], - "ellipsis": true, - "comp_str": "VARP(${1:number1}${2:,${3: [number2], ...}})" - }, - { - "func_name": "VARPA", - "req_param": [ - "value1" - ], - "opt_param": [ - "value2" - ], - "ellipsis": true, - "comp_str": "VARPA(${1:value1}${2:,${3: [value2], ...}})" - }, - { - "func_name": "VDB", - "req_param": [ - "cost", - "salvage", - "life", - "start_period", - "end_period" - ], - "opt_param": [ - "factor", - "no_switch" - ], - "ellipsis": false, - "comp_str": "VDB(${1:cost},${2: salvage},${3: life},${4: start_period},${5: end_period}${6:,${7: [factor]},${8: [no_switch]}})" - }, - { - "func_name": "VLOOKUP", - "req_param": [ - "lookup_value", - "table_array", - "col_index_num" - ], - "opt_param": [ - "range_lookup" - ], - "ellipsis": false, - "comp_str": "VLOOKUP(${1:lookup_value},${2: table_array},${3: col_index_num}${4:,${5: [range_lookup]}})" - }, - { - "func_name": "VSTACK", - "req_param": [ - "array1" - ], - "opt_param": [ - "array2" - ], - "ellipsis": true, - "comp_str": "VSTACK(${1:array1}${2:,${3: [array2], ...}})" - }, - { - "func_name": "WEBSERVICE", - "req_param": [ - "url" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "WEBSERVICE(${1:url})" - }, - { - "func_name": "WEEKDAY", - "req_param": [ - "serial_number" - ], - "opt_param": [ - "return_type" - ], - "ellipsis": false, - "comp_str": "WEEKDAY(${1:serial_number}${2:,${3: [return_type]}})" - }, - { - "func_name": "WEEKNUM", - "req_param": [ - "serial_number" - ], - "opt_param": [ - "return_type" - ], - "ellipsis": false, - "comp_str": "WEEKNUM(${1:serial_number}${2:,${3: [return_type]}})" - }, - { - "func_name": "WEIBULL", - "req_param": [ - "x", - "alpha", - "beta", - "cumulative" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "WEIBULL(${1:x},${2: alpha},${3: beta},${4: cumulative})" - }, - { - "func_name": "WEIBULL.DIST", - "req_param": [ - "x", - "alpha", - "beta", - "cumulative" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "WEIBULL.DIST(${1:x},${2: alpha},${3: beta},${4: cumulative})" - }, - { - "func_name": "WORKDAY", - "req_param": [ - "start_date", - "days" - ], - "opt_param": [ - "holidays" - ], - "ellipsis": false, - "comp_str": "WORKDAY(${1:start_date},${2: days}${3:,${4: [holidays]}})" - }, - { - "func_name": "WORKDAY.INTL", - "req_param": [ - "start_date", - "days" - ], - "opt_param": [ - "weekend", - "holidays" - ], - "ellipsis": false, - "comp_str": "WORKDAY.INTL(${1:start_date},${2: days}${3:,${4: [weekend]},${5: [holidays]}})" - }, - { - "func_name": "WRAPCOLS", - "req_param": [ - "vector", - "wrap_count" - ], - "opt_param": [ - "pad_with" - ], - "ellipsis": false, - "comp_str": "WRAPCOLS(${1:vector},${2: wrap_count}${3:,${4: [pad_with]}})" - }, - { - "func_name": "WRAPROWS", - "req_param": [ - "vector", - "wrap_count" - ], - "opt_param": [ - "pad_with" - ], - "ellipsis": false, - "comp_str": "WRAPROWS(${1:vector},${2: wrap_count}${3:,${4: [pad_with]}})" - }, - { - "func_name": "XIRR", - "req_param": [ - "values", - "dates" - ], - "opt_param": [ - "guess" - ], - "ellipsis": false, - "comp_str": "XIRR(${1:values},${2: dates}${3:,${4: [guess]}})" - }, - { - "func_name": "XLOOKUP", - "req_param": [ - "lookup_value", - "lookup_array", - "return_array" - ], - "opt_param": [ - "if_not_found", - "match_mode", - "search_mode" - ], - "ellipsis": false, - "comp_str": "XLOOKUP(${1:lookup_value},${2: lookup_array},${3: return_array}${4:,${5: [if_not_found]},${6: [match_mode]},${7: [search_mode]}})" - }, - { - "func_name": "XMATCH", - "req_param": [ - "lookup_value", - "lookup_array" - ], - "opt_param": [ - "match_mode", - "search_mode" - ], - "ellipsis": false, - "comp_str": "XMATCH(${1:lookup_value},${2: lookup_array}${3:,${4: [match_mode]},${5: [search_mode]}})" - }, - { - "func_name": "XNPV", - "req_param": [ - "rate", - "values", - "dates" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "XNPV(${1:rate},${2: values},${3: dates})" - }, - { - "func_name": "XOR", - "req_param": [ - "logical1" - ], - "opt_param": [ - "logical2" - ], - "ellipsis": true, - "comp_str": "XOR(${1:logical1}${2:,${3: [logical2], ...}})" - }, - { - "func_name": "YEAR", - "req_param": [ - "serial_number" - ], - "opt_param": [], - "ellipsis": false, - "comp_str": "YEAR(${1:serial_number})" - }, - { - "func_name": "YEARFRAC", - "req_param": [ - "start_date", - "end_date" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "YEARFRAC(${1:start_date},${2: end_date}${3:,${4: [basis]}})" - }, - { - "func_name": "YIELD", - "req_param": [ - "settlement", - "maturity", - "rate", - "pr", - "redemption", - "frequency" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "YIELD(${1:settlement},${2: maturity},${3: rate},${4: pr},${5: redemption},${6: frequency}${7:,${8: [basis]}})" - }, - { - "func_name": "YIELDDISC", - "req_param": [ - "settlement", - "maturity", - "pr", - "redemption" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "YIELDDISC(${1:settlement},${2: maturity},${3: pr},${4: redemption}${5:,${6: [basis]}})" - }, - { - "func_name": "YIELDMAT", - "req_param": [ - "settlement", - "maturity", - "issue", - "rate", - "pr" - ], - "opt_param": [ - "basis" - ], - "ellipsis": false, - "comp_str": "YIELDMAT(${1:settlement},${2: maturity},${3: issue},${4: rate},${5: pr}${6:,${7: [basis]}})" - }, - { - "func_name": "Z.TEST", - "req_param": [ - "array", - "x" - ], - "opt_param": [ - "sigma" - ], - "ellipsis": false, - "comp_str": "Z.TEST(${1:array},${2: x}${3:,${4: [sigma]}})" - }, - { - "func_name": "ZTEST", - "req_param": [ - "array", - "x" - ], - "opt_param": [ - "sigma" - ], - "ellipsis": false, - "comp_str": "ZTEST(${1:array},${2: x}${3:,${4: [sigma]}})" - } -] \ No newline at end of file diff --git a/resources/completion_builder/mg.py b/resources/completion_builder/mg.py index 991d3d3..fde6413 100755 --- a/resources/completion_builder/mg.py +++ b/resources/completion_builder/mg.py @@ -14,7 +14,7 @@ def merge_function_args_with_desc(sheet_app: str, write_json_file: bool = True): # completion-arg functions file - func_file = open(f'{sheet_app}_funcs_comp.json', 'r') + func_file = open(f'{sheet_app}_funcs.json', 'r') js_func = json.load(func_file) func_file.close() From 21a3ea82ca9b9bc34eac8365a40af0b59973ae7d Mon Sep 17 00:00:00 2001 From: Michael Lyons Date: Sun, 9 Feb 2025 17:40:21 -0500 Subject: [PATCH 09/12] Add argument parser to ld.py --- resources/completion_builder/ld.py | 38 +++++++++++++++++++++++++----- 1 file changed, 32 insertions(+), 6 deletions(-) diff --git a/resources/completion_builder/ld.py b/resources/completion_builder/ld.py index d100145..656e941 100755 --- a/resources/completion_builder/ld.py +++ b/resources/completion_builder/ld.py @@ -2,13 +2,39 @@ import json import pandas as pd -import sys +from argparse import ArgumentParser -app = sys.argv[1] +from SpreadsheetFunction import APP_SUFFIXES, SpreadsheetFunction -# Must use na_filter = False to prevent the func_name field of the NA() function's object being set to null. -ref_file = pd.read_excel(f'{app}_funcs_ref.xlsx', sheet_name = 'Sheet1', na_filter = False).to_json(orient = 'records', indent = 4) +def dump_function_args(sheet_app: str, write_json_file: bool = True): -o = open(f'{app}_funcs_ref.json', 'w') + # Must use na_filter = False to prevent the func_name field of the NA() function's object being set to null. + ref_file = pd.read_excel( + f'{sheet_app}_funcs_ref.xlsx', + sheet_name='Sheet1', + na_filter=False + ).to_json(orient='records', indent=4) -o.write(ref_file) + if write_json_file: + with open(f'{sheet_app}_funcs_ref.json', 'w') as o: + o.write(ref_file) + + return ref_file + + +if __name__ == '__main__': + parser = ArgumentParser( + description='Dump spreadsheet function descriptions to JSON from Excel') + parser.add_argument( + '-s', '--spreadsheet-app', + choices=APP_SUFFIXES, + default='excel', + help='spreadsheet application') + parser.add_argument( + '-j', '--dump-json', + type=bool, + default=True, + help='dump JSON output to a file') + args = parser.parse_args() + + dump_function_args(args.spreadsheet_app, args.dump_json) From 4f644ccbb13a6d70eb3f73aaeb8e5a5601de47cf Mon Sep 17 00:00:00 2001 From: Michael Lyons Date: Sun, 9 Feb 2025 17:41:53 -0500 Subject: [PATCH 10/12] Import other Python directly to main.py --- .../completion_builder/.sublime-completions | 2058 ++++++++--------- resources/completion_builder/main.py | 86 +- 2 files changed, 1068 insertions(+), 1076 deletions(-) diff --git a/resources/completion_builder/.sublime-completions b/resources/completion_builder/.sublime-completions index 6b17cf4..2e7d524 100644 --- a/resources/completion_builder/.sublime-completions +++ b/resources/completion_builder/.sublime-completions @@ -2,3588 +2,3588 @@ "scope": "source.sheet.excel - string - comment", "completions": [ { - "trigger": "ABS", + "trigger": "abs", "contents": "ABS(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the absolute value of a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ACCRINT", + "trigger": "accrint", "contents": "ACCRINT(${1:issue},${2: first_interest},${3: settlement},${4: rate},${5: par},${6: frequency}${7:,${8: [basis]},${9: [calc_method]}})", "annotation": "Financial", "details": "Returns the accrued interest for a security that pays periodic interest.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ACCRINTM", + "trigger": "accrintm", "contents": "ACCRINTM(${1:issue},${2: settlement},${3: rate},${4: par}${5:,${6: [basis]}})", "annotation": "Financial", "details": "Returns the accrued interest for a security that pays interest at maturity.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ACOS", + "trigger": "acos", "contents": "ACOS(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the arccosine of a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ACOSH", + "trigger": "acosh", "contents": "ACOSH(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the inverse hyperbolic cosine of a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ACOT", + "trigger": "acot", "contents": "ACOT(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the arccotangent of a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ACOTH", + "trigger": "acoth", "contents": "ACOTH(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the hyperbolic arccotangent of a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ADDRESS", + "trigger": "address", "contents": "ADDRESS(${1:row_num},${2: column_num}${3:,${4: [abs_num]},${5: [a1]},${6: [sheet_text]}})", "annotation": "Lookup and reference", "details": "Returns a reference as text to a single cell in a worksheet.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "AGGREGATE", + "trigger": "aggregate", "contents": "AGGREGATE(${1:function_num},${2: options},${3: array}${4:,${5: [k]}})", "annotation": "Math and trigonometry", "details": "Returns an aggregate in a list or database.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "AMORDEGRC", + "trigger": "amordegrc", "contents": "AMORDEGRC(${1:cost},${2: date_purchased},${3: first_period},${4: salvage},${5: period},${6: rate}${7:,${8: [basis]}})", "annotation": "Financial", "details": "Returns the depreciation for each accounting period by using a depreciation coefficient.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "AMORLINC", + "trigger": "amorlinc", "contents": "AMORLINC(${1:cost},${2: date_purchased},${3: first_period},${4: salvage},${5: period},${6: rate}${7:,${8: [basis]}})", "annotation": "Financial", "details": "Returns the depreciation for each accounting period.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "AND", + "trigger": "and", "contents": "AND(${1:logical1}${2:,${3: [logical2], ...}})", "annotation": "Logical", "details": "Returns TRUE if all of its arguments are TRUE.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ARABIC", + "trigger": "arabic", "contents": "ARABIC(${1:text})", "annotation": "Math and trigonometry", "details": "Converts a Roman number to Arabic, as a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "AREAS", + "trigger": "areas", "contents": "AREAS(${1:reference})", "annotation": "Lookup and reference", "details": "Returns the number of areas in a reference.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ARRAYTOTEXT", + "trigger": "arraytotext", "contents": "ARRAYTOTEXT(${1:array}${2:,${3: [format]}})", "annotation": "Text", "details": "Returns an array of text values from any specified range.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ASC", + "trigger": "asc", "contents": "ASC(${1:text})", "annotation": "Text", "details": "Changes full-width (double-byte) English letters or katakana within a character string to half-width (single-byte) characters.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ASIN", + "trigger": "asin", "contents": "ASIN(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the arcsine of a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ASINH", + "trigger": "asinh", "contents": "ASINH(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the inverse hyperbolic sine of a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ATAN", + "trigger": "atan", "contents": "ATAN(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the arctangent of a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ATAN2", + "trigger": "atan2", "contents": "ATAN2(${1:x_num},${2: y_num})", "annotation": "Math and trigonometry", "details": "Returns the arctangent from x- and y-coordinates.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ATANH", + "trigger": "atanh", "contents": "ATANH(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the inverse hyperbolic tangent of a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "AVEDEV", + "trigger": "avedev", "contents": "AVEDEV(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Statistical", "details": "Returns the average of the absolute deviations of data points from their mean.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "AVERAGE", + "trigger": "average", "contents": "AVERAGE(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Statistical", "details": "Returns the average of its arguments.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "AVERAGEA", + "trigger": "averagea", "contents": "AVERAGEA(${1:value1}${2:,${3: [value2], ...}})", "annotation": "Statistical", "details": "Returns the average of its arguments, including numbers, text, and logical values.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "AVERAGEIF", + "trigger": "averageif", "contents": "AVERAGEIF(${1:range},${2: criteria}${3:,${4: [average_range]}})", "annotation": "Statistical", "details": "Returns the average (arithmetic mean) of all the cells in a range that meet a given criteria.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "AVERAGEIFS", + "trigger": "averageifs", "contents": "AVERAGEIFS(${1:average_range},${2: criteria_range1},${3: criteria1}${4:,${5: [criteria_range2]},${6: [criteria2], ...}})", "annotation": "Statistical", "details": "Returns the average (arithmetic mean) of all cells that meet multiple criteria.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BAHTTEXT", + "trigger": "bahttext", "contents": "BAHTTEXT(${1:number})", "annotation": "Text", "details": "Converts a number to text, using the \u00df (baht) currency format.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BASE", + "trigger": "base", "contents": "BASE(${1:number},${2: radix}${3:,${4: [min_length]}})", "annotation": "Math and trigonometry", "details": "Converts a number into a text representation with the given radix (base).", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BESSELI", + "trigger": "besseli", "contents": "BESSELI(${1:x},${2: n})", "annotation": "Engineering", "details": "Returns the modified Bessel function In(x).", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BESSELJ", + "trigger": "besselj", "contents": "BESSELJ(${1:x},${2: n})", "annotation": "Engineering", "details": "Returns the Bessel function Jn(x).", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BESSELK", + "trigger": "besselk", "contents": "BESSELK(${1:x},${2: n})", "annotation": "Engineering", "details": "Returns the modified Bessel function Kn(x).", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BESSELY", + "trigger": "bessely", "contents": "BESSELY(${1:x},${2: n})", "annotation": "Engineering", "details": "Returns the Bessel function Yn(x).", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BETA.DIST", + "trigger": "beta.dist", "contents": "BETA.DIST(${1:x},${2: alpha},${3: beta},${4: cumulative}${5:,${6: [A]},${7: [B]}})", "annotation": "Statistical", "details": "Returns the beta cumulative distribution function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BETA.INV", + "trigger": "beta.inv", "contents": "BETA.INV(${1:probability},${2: alpha},${3: beta}${4:,${5: [A]},${6: [B]}})", "annotation": "Statistical", "details": "Returns the inverse of the cumulative distribution function for a specified beta distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BETADIST", + "trigger": "betadist", "contents": "BETADIST(${1:x},${2: alpha},${3: beta}${4:,${5: [A]},${6: [B]}})", "annotation": "Compatibility", "details": "Returns the beta cumulative distribution function. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BETAINV", + "trigger": "betainv", "contents": "BETAINV(${1:probability},${2: alpha},${3: beta}${4:,${5: [A]},${6: [B]}})", "annotation": "Compatibility", "details": "Returns the inverse of the cumulative distribution function for a specified beta. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BIN2DEC", + "trigger": "bin2dec", "contents": "BIN2DEC(${1:number})", "annotation": "Engineering", "details": "Converts a binary number to decimal.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BIN2HEX", + "trigger": "bin2hex", "contents": "BIN2HEX(${1:number}${2:,${3: [places]}})", "annotation": "Engineering", "details": "Converts a binary number to hexadecimal.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BIN2OCT", + "trigger": "bin2oct", "contents": "BIN2OCT(${1:number}${2:,${3: [places]}})", "annotation": "Engineering", "details": "Converts a binary number to octal.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BINOM.DIST", + "trigger": "binom.dist", "contents": "BINOM.DIST(${1:number_s},${2: trials},${3: probability_s},${4: cumulative})", "annotation": "Statistical", "details": "Returns the individual term binomial distribution probability.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BINOM.DIST.RANGE", + "trigger": "binom.dist.range", "contents": "BINOM.DIST.RANGE(${1:trials},${2: probability_s},${3: number_s}${4:,${5: [number_s2]}})", "annotation": "Statistical", "details": "Returns the probability of a trial result using a binomial distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BINOM.INV", + "trigger": "binom.inv", "contents": "BINOM.INV(${1:trials},${2: probability_s},${3: alpha})", "annotation": "Statistical", "details": "Returns the smallest value for which the cumulative binomial distribution is less than or equal to a criterion value.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BINOMDIST", + "trigger": "binomdist", "contents": "BINOMDIST(${1:number_s},${2: trials},${3: probability_s},${4: cumulative})", "annotation": "Compatibility", "details": "Returns the individual term binomial distribution probability. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BITAND", + "trigger": "bitand", "contents": "BITAND(${1:number1},${2: number2})", "annotation": "Engineering", "details": "Returns a 'Bitwise And' of two numbers.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BITLSHIFT", + "trigger": "bitlshift", "contents": "BITLSHIFT(${1:number},${2: shift_amount})", "annotation": "Engineering", "details": "Returns a value number shifted left by shift_amount bits.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BITOR", + "trigger": "bitor", "contents": "BITOR(${1:number1},${2: number2})", "annotation": "Engineering", "details": "Returns a bitwise OR of 2 numbers.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BITRSHIFT", + "trigger": "bitrshift", "contents": "BITRSHIFT(${1:number},${2: shift_amount})", "annotation": "Engineering", "details": "Returns a value number shifted right by shift_amount bits.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BITXOR", + "trigger": "bitxor", "contents": "BITXOR(${1:number1},${2: number2})", "annotation": "Engineering", "details": "Returns a bitwise 'Exclusive Or' of two numbers.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BYCOL", + "trigger": "bycol", "contents": "BYCOL(${1:array}${2:,${3: [function]}})", "annotation": "Array", "details": "Applies a LAMBDA to each column and returns an array of the results.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "BYROW", + "trigger": "byrow", "contents": "BYROW(${1:array}${2:,${3: [function]}})", "annotation": "Array", "details": "Applies a LAMBDA to each row and returns an array of the results.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CALL", + "trigger": "call", "contents": "CALL(${1:register_id}${2:,${3: [argument1], ...}})", "annotation": "Add-in", "details": "Calls a procedure in a specified DLL or code resource.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CEILING", + "trigger": "ceiling", "contents": "CEILING(${1:number},${2: significance})", "annotation": "Math and trigonometry", "details": "Rounds a number to the nearest integer or to the nearest multiple of significance.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CEILING.MATH", + "trigger": "ceiling.math", "contents": "CEILING.MATH(${1:number}${2:,${3: [significance]},${4: [mode]}})", "annotation": "Math and trigonometry", "details": "Rounds a number up, to the nearest integer or to the nearest multiple of significance.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CEILING.PRECISE", + "trigger": "ceiling.precise", "contents": "CEILING.PRECISE(${1:number}${2:,${3: [significance]}})", "annotation": "Math and trigonometry", "details": "Rounds a number the nearest integer or to the nearest multiple of significance. Regardless of the sign of the number, the number is rounded up.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CELL", + "trigger": "cell", "contents": "CELL(${1:info_type}${2:,${3: [reference]}})", "annotation": "Information", "details": "Returns information about the formatting, location, or contents of a cell. This function is not available in Excel Online.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CHAR", + "trigger": "char", "contents": "CHAR(${1:number})", "annotation": "Text", "details": "Returns the character specified by the code number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CHIDIST", + "trigger": "chidist", "contents": "CHIDIST(${1:x},${2: deg_freedom})", "annotation": "Compatibility", "details": "Returns the one-tailed probability of the chi-squared. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CHIINV", + "trigger": "chiinv", "contents": "CHIINV(${1:probability},${2: deg_freedom})", "annotation": "Compatibility", "details": "Returns the inverse of the one-tailed probability of the chi-squared. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CHISQ.DIST", + "trigger": "chisq.dist", "contents": "CHISQ.DIST(${1:x},${2: deg_freedom},${3: cumulative})", "annotation": "Statistical", "details": "Returns the left-tailed probability of the chi-squared distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CHISQ.DIST.RT", + "trigger": "chisq.dist.rt", "contents": "CHISQ.DIST.RT(${1:x},${2: deg_freedom})", "annotation": "Statistical", "details": "Returns the right-tailed probability of the chi-squared distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CHISQ.INV", + "trigger": "chisq.inv", "contents": "CHISQ.INV(${1:probability},${2: deg_freedom})", "annotation": "Statistical", "details": "Returns the inverse of the left-tailed probability of the chi-squared distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CHISQ.INV.RT", + "trigger": "chisq.inv.rt", "contents": "CHISQ.INV.RT(${1:probability},${2: deg_freedom})", "annotation": "Statistical", "details": "Returns the inverse of the right-tailed probability of the chi-squared distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CHISQ.TEST", + "trigger": "chisq.test", "contents": "CHISQ.TEST(${1:actual_range},${2: expected_range})", "annotation": "Statistical", "details": "Returns the test for independence: the value from the chi-squared distribution for the statistic and the appropriate degrees of freedom.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CHITEST", + "trigger": "chitest", "contents": "CHITEST(${1:actual_range},${2: expected_range})", "annotation": "Compatibility", "details": "Returns the test for independence. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CHOOSE", + "trigger": "choose", "contents": "CHOOSE(${1:index_num},${2: value1}${3:,${4: [value2], ...}})", "annotation": "Lookup and reference", "details": "Chooses a value from a list of values.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CHOOSECOLS", + "trigger": "choosecols", "contents": "CHOOSECOLS(${1:array},${2: col_num1}${3:,${4: [col_num2], ...}})", "annotation": "Array", "details": "Returns columns from an array or reference.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CHOOSEROWS", + "trigger": "chooserows", "contents": "CHOOSEROWS(${1:array},${2: row_num1}${3:,${4: [row_num2], ...}})", "annotation": "Array", "details": "Returns rows from an array of reference.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CLEAN", + "trigger": "clean", "contents": "CLEAN(${1:text})", "annotation": "Text", "details": "Removes all nonprintable characters from text.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CODE", + "trigger": "code", "contents": "CODE(${1:text})", "annotation": "Text", "details": "Returns a numeric code for the first character in a text string.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COLUMN", + "trigger": "column", "contents": "COLUMN(${1:,${2: [reference]}})", "annotation": "Lookup and reference", "details": "Returns the column number of a reference.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COLUMNS", + "trigger": "columns", "contents": "COLUMNS(${1:array})", "annotation": "Lookup and reference", "details": "Returns the number of columns in a reference.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COMBIN", + "trigger": "combin", "contents": "COMBIN(${1:number},${2: number_chosen})", "annotation": "Math and trigonometry", "details": "Returns the number of combinations for a given number of objects.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COMBINA", + "trigger": "combina", "contents": "COMBINA(${1:number},${2: number_chosen})", "annotation": "Math and trigonometry", "details": "Returns the number of combinations with repetitions for a given number of items.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COMPLEX", + "trigger": "complex", "contents": "COMPLEX(${1:real_num},${2: i_num}${3:,${4: [suffix]}})", "annotation": "Engineering", "details": "Converts real and imaginary coefficients into a complex number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CONCAT", + "trigger": "concat", "contents": "CONCAT(${1:text1}${2:,${3: [text2], ...}})", "annotation": "Text", "details": "Combines the text from multiple ranges and/or strings, but it doesn't provide the delimiter or IgnoreEmpty arguments. This function isn't available in Excel 2016 for Mac.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CONCATENATE", + "trigger": "concatenate", "contents": "CONCATENATE(${1:text1}${2:,${3: [text2], ...}})", "annotation": "Text", "details": "Joins several text items into one text item.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CONFIDENCE", + "trigger": "confidence", "contents": "CONFIDENCE(${1:alpha},${2: standard_dev},${3: size})", "annotation": "Compatibility", "details": "Returns the confidence interval for a population mean. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CONFIDENCE.NORM", + "trigger": "confidence.norm", "contents": "CONFIDENCE.NORM(${1:alpha},${2: standard_dev},${3: size})", "annotation": "Statistical", "details": "Returns the confidence interval for a population mean.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CONFIDENCE.T", + "trigger": "confidence.t", "contents": "CONFIDENCE.T(${1:alpha},${2: standard_dev},${3: size})", "annotation": "Statistical", "details": "Returns the confidence interval for a population mean, using a Student's t distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CONVERT", + "trigger": "convert", "contents": "CONVERT(${1:number},${2: from_unit},${3: to_unit})", "annotation": "Engineering", "details": "Converts a number from one measurement system to another.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CORREL", + "trigger": "correl", "contents": "CORREL(${1:array1},${2: array2})", "annotation": "Statistical", "details": "Returns the correlation coefficient between two data sets.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COS", + "trigger": "cos", "contents": "COS(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the cosine of a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COSH", + "trigger": "cosh", "contents": "COSH(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the hyperbolic cosine of a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COT", + "trigger": "cot", "contents": "COT(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the cotangent of a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COTH", + "trigger": "coth", "contents": "COTH(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the cotangent of an angle.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COUNT", + "trigger": "count", "contents": "COUNT(${1:value1}${2:,${3: [value2], ...}})", "annotation": "Statistical", "details": "Counts how many numbers are in the list of arguments.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COUNTA", + "trigger": "counta", "contents": "COUNTA(${1:value1}${2:,${3: [value2], ...}})", "annotation": "Statistical", "details": "Counts how many values are in the list of arguments.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COUNTBLANK", + "trigger": "countblank", "contents": "COUNTBLANK(${1:range})", "annotation": "Statistical", "details": "Counts the number of blank cells within a range.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COUNTIF", + "trigger": "countif", "contents": "COUNTIF(${1:range},${2: criteria})", "annotation": "Statistical", "details": "Counts the number of cells within a range that meet the given criteria.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COUNTIFS", + "trigger": "countifs", "contents": "COUNTIFS(${1:criteria_range1},${2: criteria1}${3:,${4: [criteria_range2]},${5: [criteria2], ...}})", "annotation": "Statistical", "details": "Counts the number of cells within a range that meet multiple criteria.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COUPDAYBS", + "trigger": "coupdaybs", "contents": "COUPDAYBS(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})", "annotation": "Financial", "details": "Returns the number of days from the beginning of the coupon period to the settlement date.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COUPDAYS", + "trigger": "coupdays", "contents": "COUPDAYS(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})", "annotation": "Financial", "details": "Returns the number of days in the coupon period that contains the settlement date.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COUPDAYSNC", + "trigger": "coupdaysnc", "contents": "COUPDAYSNC(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})", "annotation": "Financial", "details": "Returns the number of days from the settlement date to the next coupon date.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COUPNCD", + "trigger": "coupncd", "contents": "COUPNCD(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})", "annotation": "Financial", "details": "Returns the next coupon date after the settlement date.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COUPNUM", + "trigger": "coupnum", "contents": "COUPNUM(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})", "annotation": "Financial", "details": "Returns the number of coupons payable between the settlement date and maturity date.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COUPPCD", + "trigger": "couppcd", "contents": "COUPPCD(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})", "annotation": "Financial", "details": "Returns the previous coupon date before the settlement date.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COVAR", + "trigger": "covar", "contents": "COVAR(${1:array1},${2: array2})", "annotation": "Compatibility", "details": "Returns covariance, the average of the products of paired deviations. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COVARIANCE.P", + "trigger": "covariance.p", "contents": "COVARIANCE.P(${1:array1},${2: array2})", "annotation": "Statistical", "details": "Returns covariance, the average of the products of paired deviations.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "COVARIANCE.S", + "trigger": "covariance.s", "contents": "COVARIANCE.S(${1:array1},${2: array2})", "annotation": "Statistical", "details": "Returns the sample covariance, the average of the products deviations for each data point pair in two data sets.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CRITBINOM", + "trigger": "critbinom", "contents": "CRITBINOM(${1:trials},${2: probability_s},${3: alpha})", "annotation": "Compatibility", "details": "Returns the smallest value for which the cumulative binomial distribution is less than or equal to a criterion value. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CSC", + "trigger": "csc", "contents": "CSC(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the cosecant of an angle.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CSCH", + "trigger": "csch", "contents": "CSCH(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the hyperbolic cosecant of an angle.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CUBEKPIMEMBER", + "trigger": "cubekpimember", "contents": "CUBEKPIMEMBER(${1:connection},${2: kpi_name},${3: kpi_property}${4:,${5: [caption]}})", "annotation": "Cube", "details": "Returns a key performance (KPI) name, property, and measure, and displays the name and property in the cell. A KPI is a quantifiable measurement, such as monthly gross profit or quarterly employee turnover, used to monitor an organization's performance.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CUBEMEMBER", + "trigger": "cubemember", "contents": "CUBEMEMBER(${1:connection},${2: member_expression}${3:,${4: [caption]}})", "annotation": "Cube", "details": "Returns a member or tuple in a cube hierarchy. Use to validate that the member or tuple exists in the cube.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CUBEMEMBERPROPERTY", + "trigger": "cubememberproperty", "contents": "CUBEMEMBERPROPERTY(${1:connection},${2: member_expression},${3: property})", "annotation": "Cube", "details": "Returns the value of a member property in the cube. Use to validate that a member name exists within the cube and to return the specified property for this member.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CUBERANKEDMEMBER", + "trigger": "cuberankedmember", "contents": "CUBERANKEDMEMBER(${1:connection},${2: set_expression},${3: rank}${4:,${5: [caption]}})", "annotation": "Cube", "details": "Returns the nth, or ranked, member in a set. Use to return one or more elements in a set, such as the top sales performer or top 10 students.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CUBESET", + "trigger": "cubeset", "contents": "CUBESET(${1:connection},${2: set_expression}${3:,${4: [caption]},${5: [sort_order]},${6: [sort_by]}})", "annotation": "Cube", "details": "Defines a calculated set of members or tuples by sending a set expression to the cube on the server, which creates the set, and then returns that set to Microsoft Office Excel.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CUBESETCOUNT", + "trigger": "cubesetcount", "contents": "CUBESETCOUNT(${1:set})", "annotation": "Cube", "details": "Returns the number of items in a set.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CUBEVALUE", + "trigger": "cubevalue", "contents": "CUBEVALUE(${1:connection}${2:,${3: [member_expression1], ...}})", "annotation": "Cube", "details": "Returns an aggregated value from a cube.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CUMIPMT", + "trigger": "cumipmt", "contents": "CUMIPMT(${1:rate},${2: nper},${3: pv},${4: start_period},${5: end_period},${6: type})", "annotation": "Financial", "details": "Returns the cumulative interest paid between two periods.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "CUMPRINC", + "trigger": "cumprinc", "contents": "CUMPRINC(${1:rate},${2: nper},${3: pv},${4: start_period},${5: end_period},${6: type})", "annotation": "Financial", "details": "Returns the cumulative principal paid on a loan between two periods.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DATE", + "trigger": "date", "contents": "DATE(${1:year},${2: month},${3: day})", "annotation": "Date and time", "details": "Returns the serial number of a particular date.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DATEDIF", + "trigger": "datedif", "contents": "DATEDIF(${1:start_date},${2: end_date},${3: unit})", "annotation": "Date and time", "details": "Calculates the number of days, months, or years between two dates. This is useful in formulas where you need to calculate an age.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DATEVALUE", + "trigger": "datevalue", "contents": "DATEVALUE(${1:date_text})", "annotation": "Date and time", "details": "Converts a date in the form of text to a serial number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DAVERAGE", + "trigger": "daverage", "contents": "DAVERAGE(${1:database},${2: field},${3: criteria})", "annotation": "Database", "details": "Returns the average of selected database entries.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DAY", + "trigger": "day", "contents": "DAY(${1:serial_number})", "annotation": "Date and time", "details": "Converts a serial number to a day of the month.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DAYS", + "trigger": "days", "contents": "DAYS(${1:end_date},${2: start_date})", "annotation": "Date and time", "details": "Returns the number of days between two dates.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DAYS360", + "trigger": "days360", "contents": "DAYS360(${1:start_date},${2: end_date}${3:,${4: [method]}})", "annotation": "Date and time", "details": "Calculates the number of days between two dates based on a 360-day year.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DB", + "trigger": "db", "contents": "DB(${1:cost},${2: salvage},${3: life},${4: period}${5:,${6: [month]}})", "annotation": "Financial", "details": "Returns the depreciation of an asset for a specified period by using the fixed-declining balance method.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DBCS", + "trigger": "dbcs", "contents": "DBCS(${1:text})", "annotation": "Text", "details": "Changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DCOUNT", + "trigger": "dcount", "contents": "DCOUNT(${1:database},${2: field},${3: criteria})", "annotation": "Database", "details": "Counts the cells that contain numbers in a database.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DCOUNTA", + "trigger": "dcounta", "contents": "DCOUNTA(${1:database},${2: field},${3: criteria})", "annotation": "Database", "details": "Counts nonblank cells in a database.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DDB", + "trigger": "ddb", "contents": "DDB(${1:cost},${2: salvage},${3: life},${4: period}${5:,${6: [factor]}})", "annotation": "Financial", "details": "Returns the depreciation of an asset for a specified period by using the double-declining balance method or some other method that you specify.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DEC2BIN", + "trigger": "dec2bin", "contents": "DEC2BIN(${1:number}${2:,${3: [places]}})", "annotation": "Engineering", "details": "Converts a decimal number to binary.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DEC2HEX", + "trigger": "dec2hex", "contents": "DEC2HEX(${1:number}${2:,${3: [places]}})", "annotation": "Engineering", "details": "Converts a decimal number to hexadecimal.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DEC2OCT", + "trigger": "dec2oct", "contents": "DEC2OCT(${1:number}${2:,${3: [places]}})", "annotation": "Engineering", "details": "Converts a decimal number to octal.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DECIMAL", + "trigger": "decimal", "contents": "DECIMAL(${1:number},${2: radix})", "annotation": "Math and trigonometry", "details": "Converts a text representation of a number in a given base into a decimal number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DEGREES", + "trigger": "degrees", "contents": "DEGREES(${1:angle})", "annotation": "Math and trigonometry", "details": "Converts radians to degrees.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DELTA", + "trigger": "delta", "contents": "DELTA(${1:number1}${2:,${3: [number2]}})", "annotation": "Engineering", "details": "Tests whether two values are equal.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DEVSQ", + "trigger": "devsq", "contents": "DEVSQ(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Statistical", "details": "Returns the sum of squares of deviations.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DGET", + "trigger": "dget", "contents": "DGET(${1:database},${2: field},${3: criteria})", "annotation": "Database", "details": "Extracts from a database a single record that matches the specified criteria.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DISC", + "trigger": "disc", "contents": "DISC(${1:settlement},${2: maturity},${3: pr},${4: redemption}${5:,${6: [basis]}})", "annotation": "Financial", "details": "Returns the discount rate for a security.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DMAX", + "trigger": "dmax", "contents": "DMAX(${1:database},${2: field},${3: criteria})", "annotation": "Database", "details": "Returns the maximum value from selected database entries.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DMIN", + "trigger": "dmin", "contents": "DMIN(${1:database},${2: field},${3: criteria})", "annotation": "Database", "details": "Returns the minimum value from selected database entries.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DOLLAR", + "trigger": "dollar", "contents": "DOLLAR(${1:number}${2:,${3: [decimals]}})", "annotation": "Text", "details": "Converts a number to text, using the $ (dollar) currency format.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DOLLARDE", + "trigger": "dollarde", "contents": "DOLLARDE(${1:fractional_dollar},${2: fraction})", "annotation": "Financial", "details": "Converts a dollar price, expressed as a fraction, into a dollar price, expressed as a decimal number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DOLLARFR", + "trigger": "dollarfr", "contents": "DOLLARFR(${1:decimal_dollar},${2: fraction})", "annotation": "Financial", "details": "Converts a dollar price, expressed as a decimal number, into a dollar price, expressed as a fraction.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DPRODUCT", + "trigger": "dproduct", "contents": "DPRODUCT(${1:database},${2: field},${3: criteria})", "annotation": "Database", "details": "Multiplies the values in a particular field of records that match the criteria in a database.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DROP", + "trigger": "drop", "contents": "DROP(${1:array},${2: rows}${3:,${4: [columns]}})", "annotation": "Array", "details": "Removes rows or columns from the start or end of an array.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DSTDEV", + "trigger": "dstdev", "contents": "DSTDEV(${1:database},${2: field},${3: criteria})", "annotation": "Database", "details": "Estimates the standard deviation based on a sample of selected database entries.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DSTDEVP", + "trigger": "dstdevp", "contents": "DSTDEVP(${1:database},${2: field},${3: criteria})", "annotation": "Database", "details": "Calculates the standard deviation based on the entire population of selected database entries.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DSUM", + "trigger": "dsum", "contents": "DSUM(${1:database},${2: field},${3: criteria})", "annotation": "Database", "details": "Adds the numbers in the field column of records in the database that match the criteria.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DURATION", + "trigger": "duration", "contents": "DURATION(${1:settlement},${2: maturity},${3: coupon},${4: yld},${5: frequency}${6:,${7: [basis]}})", "annotation": "Financial", "details": "Returns the annual duration of a security with periodic interest payments.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DVAR", + "trigger": "dvar", "contents": "DVAR(${1:database},${2: field},${3: criteria})", "annotation": "Database", "details": "Estimates variance based on a sample from selected database entries.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "DVARP", + "trigger": "dvarp", "contents": "DVARP(${1:database},${2: field},${3: criteria})", "annotation": "Database", "details": "Calculates variance based on the entire population of selected database entries.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "EDATE", + "trigger": "edate", "contents": "EDATE(${1:start_date},${2: months})", "annotation": "Date and time", "details": "Returns the serial number of the date that is the indicated number of months before or after the start date.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "EFFECT", + "trigger": "effect", "contents": "EFFECT(${1:nominal_rate},${2: npery})", "annotation": "Financial", "details": "Returns the effective annual interest rate.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ENCODEURL", + "trigger": "encodeurl", "contents": "ENCODEURL(${1:text})", "annotation": "Web", "details": "Returns a URL-encoded string. This function is not available in Excel Online.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "EOMONTH", + "trigger": "eomonth", "contents": "EOMONTH(${1:start_date},${2: months})", "annotation": "Date and time", "details": "Returns the serial number of the last day of the month before or after a specified number of months.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ERF", + "trigger": "erf", "contents": "ERF(${1:lower_limit}${2:,${3: [upper_limit]}})", "annotation": "Engineering", "details": "Returns the error function integrated between lower_limit and upper_limit.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ERF.PRECISE", + "trigger": "erf.precise", "contents": "ERF.PRECISE(${1:x})", "annotation": "Engineering", "details": "Returns the error function integrated between lower_limit and 0.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ERFC", + "trigger": "erfc", "contents": "ERFC(${1:x})", "annotation": "Engineering", "details": "Returns the complementary error function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ERFC.PRECISE", + "trigger": "erfc.precise", "contents": "ERFC.PRECISE(${1:x})", "annotation": "Engineering", "details": "Returns the complementary ERF function integrated between x and infinity.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ERROR.TYPE", + "trigger": "error.type", "contents": "ERROR.TYPE(${1:error_val})", "annotation": "Information", "details": "Returns a number corresponding to an error type.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "EUROCONVERT", + "trigger": "euroconvert", "contents": "EUROCONVERT(${1:number},${2: source},${3: target},${4: full_precision},${5: triangulation_precision})", "annotation": "Add-in", "details": "Converts a number to euros, from euros to euro member currency, or between euro member currencies using euro as intermediary.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "EVEN", + "trigger": "even", "contents": "EVEN(${1:number})", "annotation": "Math and trigonometry", "details": "Rounds a number up to the nearest even integer.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "EXACT", + "trigger": "exact", "contents": "EXACT(${1:text1},${2: text2})", "annotation": "Text", "details": "Checks to see if two text values are identical.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "EXP", + "trigger": "exp", "contents": "EXP(${1:number})", "annotation": "Math and trigonometry", "details": "Returns e raised to the power of a given number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "EXPAND", + "trigger": "expand", "contents": "EXPAND(${1:array},${2: rows}${3:,${4: [columns]},${5: [pad_with]}})", "annotation": "Array", "details": "Expands an array to the specified dimensions. ", - "kind": "function" + "kind": "snippet" }, { - "trigger": "EXPON.DIST", + "trigger": "expon.dist", "contents": "EXPON.DIST(${1:x},${2: lambda},${3: cumulative})", "annotation": "Statistical", "details": "Returns the exponential distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "EXPONDIST", + "trigger": "expondist", "contents": "EXPONDIST(${1:x},${2: lambda},${3: cumulative})", "annotation": "Compatibility", "details": "Returns the exponential. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "F.DIST", + "trigger": "f.dist", "contents": "F.DIST(${1:x},${2: deg_freedom1},${3: deg_freedom2},${4: cumulative})", "annotation": "Statistical", "details": "Returns the (left-tailed) F probability distribution (degree of diversity) for two data sets.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "F.DIST.RT", + "trigger": "f.dist.rt", "contents": "F.DIST.RT(${1:x},${2: deg_freedom1},${3: deg_freedom2})", "annotation": "Statistical", "details": "Returns the (right-tailed) F probability distribution (degree of diversity) for two data sets.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "F.INV", + "trigger": "f.inv", "contents": "F.INV(${1:probability},${2: deg_freedom1},${3: deg_freedom2})", "annotation": "Statistical", "details": "Returns the inverse of the (left-tailed) F probability distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "F.INV.RT", + "trigger": "f.inv.rt", "contents": "F.INV.RT(${1:probability},${2: deg_freedom1},${3: deg_freedom2})", "annotation": "Statistical", "details": "Returns the inverse of the (right-tailed) F probability distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "F.TEST", + "trigger": "f.test", "contents": "F.TEST(${1:array1},${2: array2})", "annotation": "Statistical", "details": "Returns the result of an F-test.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FACT", + "trigger": "fact", "contents": "FACT(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the factorial of a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FACTDOUBLE", + "trigger": "factdouble", "contents": "FACTDOUBLE(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the double factorial of a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FDIST", + "trigger": "fdist", "contents": "FDIST(${1:x},${2: deg_freedom1},${3: deg_freedom2})", "annotation": "Compatibility", "details": "Returns the F probability. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FILTER", + "trigger": "filter", "contents": "FILTER(${1:array},${2: include}${3:,${4: [if_empty]}})", "annotation": "Lookup and reference", "details": "Filters a range of data based on criteria you define.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FILTERXML", + "trigger": "filterxml", "contents": "FILTERXML(${1:xml},${2: xpath})", "annotation": "Web", "details": "Returns specific data from the XML content by using the specified XPath. This function is not available in Excel Online.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FIND", + "trigger": "find", "contents": "FIND(${1:find_text},${2: within_text}${3:,${4: [start_num]}})", "annotation": "Text", "details": "Returns the position of a substring within a text string, case-sensitive.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FINDB", + "trigger": "findb", "contents": "FINDB(${1:find_text},${2: within_text}${3:,${4: [start_num]}})", "annotation": "Text", "details": "Returns the position of the last occurrence of a specified substring within a text string, counting by bytes.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FINV", + "trigger": "finv", "contents": "FINV(${1:probability},${2: deg_freedom1},${3: deg_freedom2})", "annotation": "Compatibility", "details": "Returns the inverse of the F probability distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FISHER", + "trigger": "fisher", "contents": "FISHER(${1:x})", "annotation": "Statistical", "details": "Returns the Fisher transformation.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FISHERINV", + "trigger": "fisherinv", "contents": "FISHERINV(${1:y})", "annotation": "Statistical", "details": "Returns the inverse of the Fisher transformation.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FIXED", + "trigger": "fixed", "contents": "FIXED(${1:number}${2:,${3: [decimals]},${4: [no_commas]}})", "annotation": "Text", "details": "Formats a number as text with a fixed number of decimals.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FLOOR", + "trigger": "floor", "contents": "FLOOR(${1:number},${2: significance})", "annotation": "Compatibility", "details": "Rounds a number down, toward zero. In Excel 2007 and Excel 2010, this is a Math and trigonometry function.. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FLOOR.MATH", + "trigger": "floor.math", "contents": "FLOOR.MATH(${1:number}${2:,${3: [significance]},${4: [mode]}})", "annotation": "Math and trigonometry", "details": "Rounds a number down, to the nearest integer or to the nearest multiple of significance.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FLOOR.PRECISE", + "trigger": "floor.precise", "contents": "FLOOR.PRECISE(${1:number}${2:,${3: [significance]}})", "annotation": "Math and trigonometry", "details": "Rounds a number the nearest integer or to the nearest multiple of significance. Regardless of the sign of the number, the number is rounded up.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FORECAST", + "trigger": "forecast", "contents": "FORECAST(${1:x},${2: known_ys},${3: known_xs})", "annotation": "Statistical", "details": "Returns a value along a linear trend. In Excel 2016, this function is replaced with FORECAST.LINEAR as part of the new Forecasting functions, but it's still available for compatibility with earlier versions.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FORECAST.ETS", + "trigger": "forecast.ets", "contents": "FORECAST.ETS(${1:target_date},${2: values},${3: timeline}${4:,${5: [seasonality]},${6: [data_completion]},${7: [aggregation]}})", "annotation": "Statistical", "details": "Returns a future value based on existing (historical) values by using the AAA version of the Exponential Smoothing (ETS) algorithm. This function isn't available in Excel 2016 for Mac.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FORECAST.ETS.CONFINT", + "trigger": "forecast.ets.confint", "contents": "FORECAST.ETS.CONFINT(${1:target_date},${2: values},${3: timeline}${4:,${5: [confidence_level]},${6: [seasonality]},${7: [data_completion]},${8: [aggregation]}})", "annotation": "Statistical", "details": "Returns a confidence interval for the forecast value at the specified target date. This function isn't available in Excel 2016 for Mac.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FORECAST.ETS.SEASONALITY", + "trigger": "forecast.ets.seasonality", "contents": "FORECAST.ETS.SEASONALITY(${1:values},${2: timeline}${3:,${4: [data_completion]},${5: [aggregation]}})", "annotation": "Statistical", "details": "Returns the length of the repetitive pattern Excel detects for the specified time series. This function isn't available in Excel 2016 for Mac.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FORECAST.ETS.STAT", + "trigger": "forecast.ets.stat", "contents": "FORECAST.ETS.STAT(${1:values},${2: timeline},${3: statistic_type}${4:,${5: [seasonality]},${6: [data_completion]},${7: [aggregation]}})", "annotation": "Statistical", "details": "Returns a statistical value as a result of time series forecasting. This function isn't available in Excel 2016 for Mac.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FORECAST.LINEAR", + "trigger": "forecast.linear", "contents": "FORECAST.LINEAR(${1:x},${2: known_ys},${3: known_xs})", "annotation": "Statistical", "details": "Returns a future value based on existing values. This function isn't available in Excel 2016 for Mac.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FORMULATEXT", + "trigger": "formulatext", "contents": "FORMULATEXT(${1:reference})", "annotation": "Lookup and reference", "details": "Returns the formula at the given reference as text.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FREQUENCY", + "trigger": "frequency", "contents": "FREQUENCY(${1:data_array},${2: bins_array})", "annotation": "Statistical", "details": "Returns a frequency distribution as a vertical array.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FTEST", + "trigger": "ftest", "contents": "FTEST(${1:array1},${2: array2})", "annotation": "Compatibility", "details": "Returns the result of an F-test. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FV", + "trigger": "fv", "contents": "FV(${1:rate},${2: nper},${3: pmt}${4:,${5: [pv]},${6: [type]}})", "annotation": "Financial", "details": "Returns the future value of an investment.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "FVSCHEDULE", + "trigger": "fvschedule", "contents": "FVSCHEDULE(${1:principal},${2: schedule})", "annotation": "Financial", "details": "Returns the future value of an initial principal after applying a series of compound interest rates.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "GAMMA", + "trigger": "gamma", "contents": "GAMMA(${1:x})", "annotation": "Statistical", "details": "Returns the Gamma function value.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "GAMMA.DIST", + "trigger": "gamma.dist", "contents": "GAMMA.DIST(${1:x},${2: alpha},${3: beta},${4: cumulative})", "annotation": "Statistical", "details": "Returns the gamma distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "GAMMA.INV", + "trigger": "gamma.inv", "contents": "GAMMA.INV(${1:probability},${2: alpha},${3: beta})", "annotation": "Statistical", "details": "Returns the inverse of the gamma cumulative distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "GAMMADIST", + "trigger": "gammadist", "contents": "GAMMADIST(${1:x},${2: alpha},${3: beta},${4: cumulative})", "annotation": "Compatibility", "details": "Returns the gamma. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "GAMMAINV", + "trigger": "gammainv", "contents": "GAMMAINV(${1:probability},${2: alpha},${3: beta})", "annotation": "Compatibility", "details": "Returns the inverse of the gamma cumulative. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "GAMMALN", + "trigger": "gammaln", "contents": "GAMMALN(${1:x})", "annotation": "Statistical", "details": "Returns the natural logarithm of the gamma function, \u0393(x).", - "kind": "function" + "kind": "snippet" }, { - "trigger": "GAMMALN.PRECISE", + "trigger": "gammaln.precise", "contents": "GAMMALN.PRECISE(${1:x})", "annotation": "Statistical", "details": "Returns the natural logarithm of the gamma function, \u0393(x).", - "kind": "function" + "kind": "snippet" }, { - "trigger": "GAUSS", + "trigger": "gauss", "contents": "GAUSS(${1:x})", "annotation": "Statistical", "details": "Returns 0.5 less than the standard normal cumulative distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "GCD", + "trigger": "gcd", "contents": "GCD(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Math and trigonometry", "details": "Returns the greatest common divisor.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "GEOMEAN", + "trigger": "geomean", "contents": "GEOMEAN(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Statistical", "details": "Returns the geometric mean.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "GESTEP", + "trigger": "gestep", "contents": "GESTEP(${1:number}${2:,${3: [step]}})", "annotation": "Engineering", "details": "Tests whether a number is greater than a threshold value.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "GETPIVOTDATA", + "trigger": "getpivotdata", "contents": "GETPIVOTDATA(${1:data_field},${2: pivot_table}${3:,${4: [field1]},${5: [item1], ...}})", "annotation": "Add-in and Automation", "details": "Returns data stored in a PivotTable report.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "GROWTH", + "trigger": "growth", "contents": "GROWTH(${1:known_ys}${2:,${3: [known_xs]},${4: [new_xs]},${5: [const]}})", "annotation": "Statistical", "details": "Returns values along an exponential trend.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "HARMEAN", + "trigger": "harmean", "contents": "HARMEAN(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Statistical", "details": "Returns the harmonic mean.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "HEX2BIN", + "trigger": "hex2bin", "contents": "HEX2BIN(${1:number}${2:,${3: [places]}})", "annotation": "Engineering", "details": "Converts a hexadecimal number to binary.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "HEX2DEC", + "trigger": "hex2dec", "contents": "HEX2DEC(${1:number})", "annotation": "Engineering", "details": "Converts a hexadecimal number to decimal.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "HEX2OCT", + "trigger": "hex2oct", "contents": "HEX2OCT(${1:number}${2:,${3: [places]}})", "annotation": "Engineering", "details": "Converts a hexadecimal number to octal.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "HLOOKUP", + "trigger": "hlookup", "contents": "HLOOKUP(${1:lookup_value},${2: table_array},${3: row_index_num}${4:,${5: [range_lookup]}})", "annotation": "Lookup and reference", "details": "Looks in the top row of an array and returns the value of the indicated cell.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "HOUR", + "trigger": "hour", "contents": "HOUR(${1:serial_number})", "annotation": "Date and time", "details": "Converts a serial number to an hour.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "HSTACK", + "trigger": "hstack", "contents": "HSTACK(${1:array1}${2:,${3: [array2], ...}})", "annotation": "Array", "details": "Horizontally combine arrays into one array.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "HYPERLINK", + "trigger": "hyperlink", "contents": "HYPERLINK(${1:link_location}${2:,${3: [friendly_name]}})", "annotation": "Lookup and reference", "details": "Creates a shortcut or jump that opens a document stored on a network server, an intranet, or the Internet.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "HYPGEOM.DIST", + "trigger": "hypgeom.dist", "contents": "HYPGEOM.DIST(${1:sample_s},${2: number_sample},${3: population_s},${4: number_pop},${5: cumulative})", "annotation": "Statistical", "details": "Returns the hypergeometric distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "HYPGEOMDIST", + "trigger": "hypgeomdist", "contents": "HYPGEOMDIST(${1:sample_s},${2: number_sample},${3: population_s},${4: number_pop})", "annotation": "Compatibility", "details": "Returns the hypergeometric. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IF", + "trigger": "if", "contents": "IF(${1:logical_test}${2:,${3: [value_if_true]},${4: [value_if_false]}})", "annotation": "Logical", "details": "Specifies a logical test to perform.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IFERROR", + "trigger": "iferror", "contents": "IFERROR(${1:value},${2: value_if_error})", "annotation": "Logical", "details": "Returns a value you specify if a formula evaluates to an error.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IFNA", + "trigger": "ifna", "contents": "IFNA(${1:value},${2: value_if_na})", "annotation": "Logical", "details": "Returns the value you specify if the expression resolves to #N/A, otherwise. Returns the result of the expression.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IFS", + "trigger": "ifs", "contents": "IFS(${1:logical_test1},${2: value_if_true1}${3:,${4: [logical_test2]},${5: [value_if_true2], ...}})", "annotation": "Logical", "details": "Checks whether one or more conditions are met and returns a value that corresponds to the first TRUE condition. This function isn't available in Excel 2016 for Mac.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMABS", + "trigger": "imabs", "contents": "IMABS(${1:inumber})", "annotation": "Engineering", "details": "Returns the absolute value (modulus) of a complex number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMAGE", + "trigger": "image", "contents": "IMAGE(${1:source}${2:,${3: [alt_text]},${4: [sizing]},${5: [height]},${6: [width]}})", "annotation": "Lookup and reference", "details": "Returns an image from a given source.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMAGINARY", + "trigger": "imaginary", "contents": "IMAGINARY(${1:inumber})", "annotation": "Engineering", "details": "Returns the imaginary coefficient of a complex number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMARGUMENT", + "trigger": "imargument", "contents": "IMARGUMENT(${1:inumber})", "annotation": "Engineering", "details": "Returns the argument theta, an angle expressed in radians.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMCONJUGATE", + "trigger": "imconjugate", "contents": "IMCONJUGATE(${1:inumber})", "annotation": "Engineering", "details": "Returns the complex conjugate of a complex number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMCOS", + "trigger": "imcos", "contents": "IMCOS(${1:inumber})", "annotation": "Engineering", "details": "Returns the cosine of a complex number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMCOSH", + "trigger": "imcosh", "contents": "IMCOSH(${1:inumber})", "annotation": "Engineering", "details": "Returns the hyperbolic cosine of a complex number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMCOT", + "trigger": "imcot", "contents": "IMCOT(${1:inumber})", "annotation": "Engineering", "details": "Returns the cotangent of a complex number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMCSC", + "trigger": "imcsc", "contents": "IMCSC(${1:inumber})", "annotation": "Engineering", "details": "Returns the cosecant of a complex number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMCSCH", + "trigger": "imcsch", "contents": "IMCSCH(${1:inumber})", "annotation": "Engineering", "details": "Returns the hyperbolic cosecant of a complex number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMDIV", + "trigger": "imdiv", "contents": "IMDIV(${1:inumber1},${2: inumber2})", "annotation": "Engineering", "details": "Returns the quotient of two complex numbers.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMEXP", + "trigger": "imexp", "contents": "IMEXP(${1:inumber})", "annotation": "Engineering", "details": "Returns the exponential of a complex number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMLN", + "trigger": "imln", "contents": "IMLN(${1:inumber})", "annotation": "Engineering", "details": "Returns the natural logarithm of a complex number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMLOG10", + "trigger": "imlog10", "contents": "IMLOG10(${1:inumber})", "annotation": "Engineering", "details": "Returns the base-10 logarithm of a complex number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMLOG2", + "trigger": "imlog2", "contents": "IMLOG2(${1:inumber})", "annotation": "Engineering", "details": "Returns the base-2 logarithm of a complex number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMPOWER", + "trigger": "impower", "contents": "IMPOWER(${1:inumber},${2: number})", "annotation": "Engineering", "details": "Returns a complex number raised to an integer power.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMPRODUCT", + "trigger": "improduct", "contents": "IMPRODUCT(${1:inumber1}${2:,${3: [inumber2], ...}})", "annotation": "Engineering", "details": "Returns the product of complex numbers.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMREAL", + "trigger": "imreal", "contents": "IMREAL(${1:inumber})", "annotation": "Engineering", "details": "Returns the real coefficient of a complex number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMSEC", + "trigger": "imsec", "contents": "IMSEC(${1:inumber})", "annotation": "Engineering", "details": "Returns the secant of a complex number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMSECH", + "trigger": "imsech", "contents": "IMSECH(${1:inumber})", "annotation": "Engineering", "details": "Returns the hyperbolic secant of a complex number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMSIN", + "trigger": "imsin", "contents": "IMSIN(${1:inumber})", "annotation": "Engineering", "details": "Returns the sine of a complex number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMSINH", + "trigger": "imsinh", "contents": "IMSINH(${1:inumber})", "annotation": "Engineering", "details": "Returns the hyperbolic sine of a complex number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMSQRT", + "trigger": "imsqrt", "contents": "IMSQRT(${1:inumber})", "annotation": "Engineering", "details": "Returns the square root of a complex number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMSUB", + "trigger": "imsub", "contents": "IMSUB(${1:inumber1},${2: inumber2})", "annotation": "Engineering", "details": "Returns the difference between two complex numbers.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMSUM", + "trigger": "imsum", "contents": "IMSUM(${1:inumber1}${2:,${3: [inumber2], ...}})", "annotation": "Engineering", "details": "Returns the sum of complex numbers.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IMTAN", + "trigger": "imtan", "contents": "IMTAN(${1:inumber})", "annotation": "Engineering", "details": "Returns the tangent of a complex number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "INDEX", + "trigger": "index", "contents": "INDEX(${1:array},${2: row_num}${3:,${4: [column_num]}})", "annotation": "Lookup and reference", "details": "Uses an index to choose a value from a reference or array.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "INDIRECT", + "trigger": "indirect", "contents": "INDIRECT(${1:ref_text}${2:,${3: [a1]}})", "annotation": "Lookup and reference", "details": "Returns a reference indicated by a text value.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "INFO", + "trigger": "info", "contents": "INFO(${1:type_text})", "annotation": "Information", "details": "Returns information about the current operating environment. This function is not available in Excel Online.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "INT", + "trigger": "int", "contents": "INT(${1:number})", "annotation": "Math and trigonometry", "details": "Rounds a number down to the nearest integer.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "INTERCEPT", + "trigger": "intercept", "contents": "INTERCEPT(${1:known_ys},${2: known_xs})", "annotation": "Statistical", "details": "Returns the intercept of the linear regression line.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "INTRATE", + "trigger": "intrate", "contents": "INTRATE(${1:settlement},${2: maturity},${3: investment},${4: redemption}${5:,${6: [basis]}})", "annotation": "Financial", "details": "Returns the interest rate for a fully invested security.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IPMT", + "trigger": "ipmt", "contents": "IPMT(${1:rate},${2: per},${3: nper},${4: pv}${5:,${6: [fv]},${7: [type]}})", "annotation": "Financial", "details": "Returns the interest payment for an investment for a given period.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "IRR", + "trigger": "irr", "contents": "IRR(${1:values}${2:,${3: [guess]}})", "annotation": "Financial", "details": "Returns the internal rate of return for a series of cash flows.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ISBLANK", + "trigger": "isblank", "contents": "ISBLANK(${1:value})", "annotation": "Information", "details": "Returns TRUE if the value is blank.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ISERR", + "trigger": "iserr", "contents": "ISERR(${1:value})", "annotation": "Information", "details": "Returns TRUE if the value is any error value except #N/A.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ISERROR", + "trigger": "iserror", "contents": "ISERROR(${1:value})", "annotation": "Information", "details": "Returns TRUE if the value is any error value.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ISEVEN", + "trigger": "iseven", "contents": "ISEVEN(${1:number})", "annotation": "Information", "details": "Returns TRUE if the number is even.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ISFORMULA", + "trigger": "isformula", "contents": "ISFORMULA(${1:reference})", "annotation": "Information", "details": "Returns TRUE if there is a reference to a cell that contains a formula.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ISLOGICAL", + "trigger": "islogical", "contents": "ISLOGICAL(${1:value})", "annotation": "Information", "details": "Returns TRUE if the value is a logical value.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ISNA", + "trigger": "isna", "contents": "ISNA(${1:value})", "annotation": "Information", "details": "Returns TRUE if the value is the #N/A error value.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ISNONTEXT", + "trigger": "isnontext", "contents": "ISNONTEXT(${1:value})", "annotation": "Information", "details": "Returns TRUE if the value is not text.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ISNUMBER", + "trigger": "isnumber", "contents": "ISNUMBER(${1:value})", "annotation": "Information", "details": "Returns TRUE if the value is a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ISO.CEILING", + "trigger": "iso.ceiling", "contents": "ISO.CEILING(${1:number}${2:,${3: [significance]}})", "annotation": "Math and trigonometry", "details": "Returns a number that is rounded up to the nearest integer or to the nearest multiple of significance.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ISODD", + "trigger": "isodd", "contents": "ISODD(${1:number})", "annotation": "Information", "details": "Returns TRUE if the number is odd.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ISOMITTED", + "trigger": "isomitted", "contents": "ISOMITTED(${1:argument})", "annotation": "Information", "details": "Checks whether the value is omitted, and returns TRUE or FALSE.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ISOWEEKNUM", + "trigger": "isoweeknum", "contents": "ISOWEEKNUM(${1:date})", "annotation": "Date and time", "details": "Returns the number of the ISO week number of the year for a given date.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ISPMT", + "trigger": "ispmt", "contents": "ISPMT(${1:rate},${2: per},${3: nper},${4: pv})", "annotation": "Financial", "details": "Calculates the interest paid during a specific period of an investment.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ISREF", + "trigger": "isref", "contents": "ISREF(${1:value})", "annotation": "Information", "details": "Returns TRUE if the value is a reference.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ISTEXT", + "trigger": "istext", "contents": "ISTEXT(${1:value})", "annotation": "Information", "details": "Returns TRUE if the value is text.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "JIS", + "trigger": "jis", "contents": "JIS(${1:text})", "annotation": "Text", "details": "Changes half-width characters to full-width characters.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "KURT", + "trigger": "kurt", "contents": "KURT(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Statistical", "details": "Returns the kurtosis of a data set.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "LAMBDA", + "trigger": "lambda", "contents": "LAMBDA(${1:parameter_or_calculation1}${2:,${3: [parameter_or_calculation2], ...}})", "annotation": "Formulas", "details": "Creates a function value, which can be called within formulas.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "LARGE", + "trigger": "large", "contents": "LARGE(${1:array},${2: k})", "annotation": "Statistical", "details": "Returns the k-th largest value in a data set.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "LCM", + "trigger": "lcm", "contents": "LCM(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Math and trigonometry", "details": "Returns the least common multiple.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "LEFT", + "trigger": "left", "contents": "LEFT(${1:text}${2:,${3: [num_chars]}})", "annotation": "Text", "details": "Extracts a specified number of characters from the start (left) of a text string.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "LEFTB", + "trigger": "leftb", "contents": "LEFTB(${1:text}${2:,${3: [num_bytes]}})", "annotation": "Text", "details": "Returns the first character or characters in a text string based on bytes.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "LEN", + "trigger": "len", "contents": "LEN(${1:text})", "annotation": "Text", "details": "Returns the total number of characters in a text string, including spaces.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "LENB", + "trigger": "lenb", "contents": "LENB(${1:text})", "annotation": "Text", "details": "Returns the number of bytes used to represent a string.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "LET", + "trigger": "let", "contents": "LET(${1:name1},${2: name_value1},${3: calculation_or_name2}${4:,${5: [name_value2], ...}})", "annotation": "Formulas", "details": "Assigns names to calculation results to allow storing intermediate calculations, values, or defining names inside a formula", - "kind": "function" + "kind": "snippet" }, { - "trigger": "LINEST", + "trigger": "linest", "contents": "LINEST(${1:known_ys}${2:,${3: [known_xs]},${4: [const]},${5: [stats]}})", "annotation": "Statistical", "details": "Returns the parameters of a linear trend.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "LN", + "trigger": "ln", "contents": "LN(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the natural logarithm of a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "LOG", + "trigger": "log", "contents": "LOG(${1:number}${2:,${3: [base]}})", "annotation": "Math and trigonometry", "details": "Returns the logarithm of a number to a specified base.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "LOG10", + "trigger": "log10", "contents": "LOG10(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the base-10 logarithm of a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "LOGEST", + "trigger": "logest", "contents": "LOGEST(${1:known_ys}${2:,${3: [known_xs]},${4: [const]},${5: [stats]}})", "annotation": "Statistical", "details": "Returns the parameters of an exponential trend.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "LOGINV", + "trigger": "loginv", "contents": "LOGINV(${1:probability},${2: mean},${3: standard_dev})", "annotation": "Compatibility", "details": "Returns the inverse of the lognormal cumulative distribution. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "LOGNORM.DIST", + "trigger": "lognorm.dist", "contents": "LOGNORM.DIST(${1:x},${2: mean},${3: standard_dev},${4: cumulative})", "annotation": "Statistical", "details": "Returns the lognormal distribution of x, where ln(x) is normally distributed with parameters Mean and Standard_dev.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "LOGNORM.INV", + "trigger": "lognorm.inv", "contents": "LOGNORM.INV(${1:probability},${2: mean},${3: standard_dev})", "annotation": "Statistical", "details": "Returns the inverse of the lognormal cumulative distribution function of x, where ln(x) is normally distributed with parameters Mean and Standard_dev.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "LOGNORMDIST", + "trigger": "lognormdist", "contents": "LOGNORMDIST(${1:x},${2: mean},${3: standard_dev})", "annotation": "Compatibility", "details": "Returns the cumulative lognormal distribution. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "LOOKUP", + "trigger": "lookup", "contents": "LOOKUP(${1:lookup_value},${2: lookup_vector}${3:,${4: [result_vector]}})", "annotation": "Lookup and reference", "details": "Looks up values in a vector or array.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "LOWER", + "trigger": "lower", "contents": "LOWER(${1:text})", "annotation": "Text", "details": "Converts text to lowercase.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MAKEARRAY", + "trigger": "makearray", "contents": "MAKEARRAY(${1:rows},${2: columns},${3: function})", "annotation": "Array", "details": "Returns a calculated array of a specified row and column size, by applying a LAMBDA function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MAP", + "trigger": "map", "contents": "MAP(${1:array},${2: lambda_or_array2}${3:,${4: [lambda_or_array3], ...}})", "annotation": "Array", "details": "Returns an array formed by 'mapping' each value in the array(s) to a new value by applying a lambda to create a new value.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MATCH", + "trigger": "match", "contents": "MATCH(${1:lookup_value},${2: lookup_array}${3:,${4: [match_type]}})", "annotation": "Lookup and reference", "details": "Looks up values in a reference or array.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MAX", + "trigger": "max", "contents": "MAX(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Statistical", "details": "Returns the maximum value in a list of arguments.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MAXA", + "trigger": "maxa", "contents": "MAXA(${1:value1}${2:,${3: [value2], ...}})", "annotation": "Statistical", "details": "Returns the maximum value in a list of arguments, including numbers, text, and logical values.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MAXIFS", + "trigger": "maxifs", "contents": "MAXIFS(${1:max_range},${2: criteria_range1},${3: criteria1}${4:,${5: [criteria_range2]},${6: [criteria2], ...}})", "annotation": "Statistical", "details": "Returns the maximum value among cells specified by a given set of conditions or criteria. This function isn't available in Excel 2016 for Mac.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MDETERM", + "trigger": "mdeterm", "contents": "MDETERM(${1:array})", "annotation": "Math and trigonometry", "details": "Returns the matrix determinant of an array.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MDURATION", + "trigger": "mduration", "contents": "MDURATION(${1:settlement},${2: maturity},${3: coupon},${4: yld},${5: frequency}${6:,${7: [basis]}})", "annotation": "Financial", "details": "Returns the Macauley modified duration for a security with an assumed par value of $100.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MEDIAN", + "trigger": "median", "contents": "MEDIAN(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Statistical", "details": "Returns the median of the given numbers.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MID", + "trigger": "mid", "contents": "MID(${1:text},${2: start_num},${3: num_chars})", "annotation": "Text", "details": "Extracts a substring from a text string, starting at a specified position for a given length.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MIDB", + "trigger": "midb", "contents": "MIDB(${1:text},${2: start_num},${3: num_bytes})", "annotation": "Text", "details": "Returns a specific number of bytes from a text string, starting at a specified position.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MIN", + "trigger": "min", "contents": "MIN(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Statistical", "details": "Returns the minimum value in a list of arguments.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MINA", + "trigger": "mina", "contents": "MINA(${1:value1}${2:,${3: [value2], ...}})", "annotation": "Statistical", "details": "Returns the smallest value in a list of arguments, including numbers, text, and logical values.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MINIFS", + "trigger": "minifs", "contents": "MINIFS(${1:min_range},${2: criteria_range1},${3: criteria1}${4:,${5: [criteria_range2]},${6: [criteria2], ...}})", "annotation": "Statistical", "details": "Returns the minimum value among cells specified by a given set of conditions or criteria. This function isn't available in Excel 2016 for Mac.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MINUTE", + "trigger": "minute", "contents": "MINUTE(${1:serial_number})", "annotation": "Date and time", "details": "Converts a serial number to a minute.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MINVERSE", + "trigger": "minverse", "contents": "MINVERSE(${1:array})", "annotation": "Math and trigonometry", "details": "Returns the matrix inverse of an array.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MIRR", + "trigger": "mirr", "contents": "MIRR(${1:values},${2: finance_rate},${3: reinvest_rate})", "annotation": "Financial", "details": "Returns the internal rate of return where positive and negative cash flows are financed at different rates.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MMULT", + "trigger": "mmult", "contents": "MMULT(${1:array1},${2: array2})", "annotation": "Math and trigonometry", "details": "Returns the matrix product of two arrays.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MOD", + "trigger": "mod", "contents": "MOD(${1:number},${2: divisor})", "annotation": "Math and trigonometry", "details": "Returns the remainder from division.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MODE", + "trigger": "mode", "contents": "MODE(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Compatibility", "details": "Returns the most common value in a data set. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MODE.MULT", + "trigger": "mode.mult", "contents": "MODE.MULT(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Statistical", "details": "Returns a vertical array of the most frequently occurring, or repetitive values in an array or range of data.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MODE.SNGL", + "trigger": "mode.sngl", "contents": "MODE.SNGL(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Statistical", "details": "Returns the most common value in a data set.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MONTH", + "trigger": "month", "contents": "MONTH(${1:serial_number})", "annotation": "Date and time", "details": "Converts a serial number to a month.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MROUND", + "trigger": "mround", "contents": "MROUND(${1:number},${2: multiple})", "annotation": "Math and trigonometry", "details": "Returns a number rounded to the desired multiple.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MULTINOMIAL", + "trigger": "multinomial", "contents": "MULTINOMIAL(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Math and trigonometry", "details": "Returns the multinomial of a set of numbers.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "MUNIT", + "trigger": "munit", "contents": "MUNIT(${1:dimension})", "annotation": "Math and trigonometry", "details": "Returns the unit matrix or the specified dimension.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "N", + "trigger": "n", "contents": "N(${1:value})", "annotation": "Information", "details": "Returns a value converted to a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "NA", - "contents": "=NA()", + "trigger": "na", + "contents": "NA()", "annotation": "Information", "details": "Returns the error value #N/A.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "NEGBINOM.DIST", + "trigger": "negbinom.dist", "contents": "NEGBINOM.DIST(${1:number_f},${2: number_s},${3: probability_s},${4: cumulative})", "annotation": "Statistical", "details": "Returns the negative binomial distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "NEGBINOMDIST", + "trigger": "negbinomdist", "contents": "NEGBINOMDIST(${1:number_f},${2: number_s},${3: probability_s})", "annotation": "Compatibility", "details": "Returns the negative binomial. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "NETWORKDAYS", + "trigger": "networkdays", "contents": "NETWORKDAYS(${1:start_date},${2: end_date}${3:,${4: [holidays]}})", "annotation": "Date and time", "details": "Returns the number of whole workdays between two dates.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "NETWORKDAYS.INTL", + "trigger": "networkdays.intl", "contents": "NETWORKDAYS.INTL(${1:start_date},${2: end_date}${3:,${4: [weekend]},${5: [holidays]}})", "annotation": "Date and time", "details": "Returns the number of whole workdays between two dates using parameters to indicate which and how many days are weekend days.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "NOMINAL", + "trigger": "nominal", "contents": "NOMINAL(${1:effect_rate},${2: npery})", "annotation": "Financial", "details": "Returns the annual nominal interest rate.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "NORM.DIST", + "trigger": "norm.dist", "contents": "NORM.DIST(${1:x},${2: mean},${3: standard_dev},${4: cumulative})", "annotation": "Statistical", "details": "Returns the normal cumulative distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "NORM.INV", + "trigger": "norm.inv", "contents": "NORM.INV(${1:probability},${2: mean},${3: standard_dev})", "annotation": "Compatibility", "details": "Returns the inverse of the normal cumulative. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "NORM.S.DIST", + "trigger": "norm.s.dist", "contents": "NORM.S.DIST(${1:z},${2: cumulative})", "annotation": "Statistical", "details": "Returns the standard normal cumulative distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "NORM.S.INV", + "trigger": "norm.s.inv", "contents": "NORM.S.INV(${1:probability})", "annotation": "Statistical", "details": "Returns the inverse of the standard normal cumulative distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "NORMDIST", + "trigger": "normdist", "contents": "NORMDIST(${1:x},${2: mean},${3: standard_dev},${4: cumulative})", "annotation": "Compatibility", "details": "Returns the normal cumulative. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "NORMINV", + "trigger": "norminv", "contents": "NORMINV(${1:probability},${2: mean},${3: standard_dev})", "annotation": "Statistical", "details": "Returns the inverse of the normal cumulative distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "NORMSDIST", + "trigger": "normsdist", "contents": "NORMSDIST(${1:z})", "annotation": "Compatibility", "details": "Returns the standard normal cumulative. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "NORMSINV", + "trigger": "normsinv", "contents": "NORMSINV(${1:probability})", "annotation": "Compatibility", "details": "Returns the inverse of the standard normal cumulative. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "NOT", + "trigger": "not", "contents": "NOT(${1:logical})", "annotation": "Logical", "details": "Reverses the logic of its argument.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "NOW", - "contents": "=NOW()", + "trigger": "now", + "contents": "NOW()", "annotation": "Date and time", "details": "Returns the serial number of the current date and time.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "NPER", + "trigger": "nper", "contents": "NPER(${1:rate},${2: pmt},${3: pv}${4:,${5: [fv]},${6: [type]}})", "annotation": "Financial", "details": "Returns the number of periods for an investment.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "NPV", + "trigger": "npv", "contents": "NPV(${1:rate},${2: value1}${3:,${4: [value2], ...}})", "annotation": "Financial", "details": "Returns the net present value of an investment based on a series of periodic cash flows and a discount rate.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "NUMBERVALUE", + "trigger": "numbervalue", "contents": "NUMBERVALUE(${1:text}${2:,${3: [decimal_separator]},${4: [group_separator]}})", "annotation": "Text", "details": "Converts text to number in a locale-independent manner.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "OCT2BIN", + "trigger": "oct2bin", "contents": "OCT2BIN(${1:number}${2:,${3: [places]}})", "annotation": "Engineering", "details": "Converts an octal number to binary.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "OCT2DEC", + "trigger": "oct2dec", "contents": "OCT2DEC(${1:number})", "annotation": "Engineering", "details": "Converts an octal number to decimal.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "OCT2HEX", + "trigger": "oct2hex", "contents": "OCT2HEX(${1:number}${2:,${3: [places]}})", "annotation": "Engineering", "details": "Converts an octal number to hexadecimal.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ODD", + "trigger": "odd", "contents": "ODD(${1:number})", "annotation": "Math and trigonometry", "details": "Rounds a number up to the nearest odd integer.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ODDFPRICE", + "trigger": "oddfprice", "contents": "ODDFPRICE(${1:settlement},${2: maturity},${3: issue},${4: first_coupon},${5: rate},${6: yld},${7: redemption},${8: frequency}${9:,${10: [basis]}})", "annotation": "Financial", "details": "Returns the price per $100 face value of a security with an odd first period.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ODDFYIELD", + "trigger": "oddfyield", "contents": "ODDFYIELD(${1:settlement},${2: maturity},${3: issue},${4: first_coupon},${5: rate},${6: pr},${7: redemption},${8: frequency}${9:,${10: [basis]}})", "annotation": "Financial", "details": "Returns the yield of a security with an odd first period.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ODDLPRICE", + "trigger": "oddlprice", "contents": "ODDLPRICE(${1:settlement},${2: maturity},${3: last_interest},${4: rate},${5: yld},${6: redemption},${7: frequency}${8:,${9: [basis]}})", "annotation": "Financial", "details": "Returns the price per $100 face value of a security with an odd last period.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ODDLYIELD", + "trigger": "oddlyield", "contents": "ODDLYIELD(${1:settlement},${2: maturity},${3: last_interest},${4: rate},${5: pr},${6: redemption},${7: frequency}${8:,${9: [basis]}})", "annotation": "Financial", "details": "Returns the yield of a security with an odd last period.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "OFFSET", + "trigger": "offset", "contents": "OFFSET(${1:reference},${2: rows},${3: cols}${4:,${5: [height]},${6: [width]}})", "annotation": "Lookup and reference", "details": "Returns a reference offset from a given reference.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "OR", + "trigger": "or", "contents": "OR(${1:logical1}${2:,${3: [logical2], ...}})", "annotation": "Logical", "details": "Returns TRUE if any argument is TRUE.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "PDURATION", + "trigger": "pduration", "contents": "PDURATION(${1:rate},${2: py},${3: fv})", "annotation": "Financial", "details": "Returns the number of periods required by an investment to reach a specified value.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "PEARSON", + "trigger": "pearson", "contents": "PEARSON(${1:array1},${2: array2})", "annotation": "Statistical", "details": "Returns the Pearson product moment correlation coefficient.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "PERCENTILE", + "trigger": "percentile", "contents": "PERCENTILE(${1:array},${2: k})", "annotation": "Compatibility", "details": "Returns the k-th percentile of values in a range. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "PERCENTILE.EXC", + "trigger": "percentile.exc", "contents": "PERCENTILE.EXC(${1:array},${2: k})", "annotation": "Statistical", "details": "Returns the k-th percentile of values in a range, where k is in the range 0..1, exclusive.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "PERCENTILE.INC", + "trigger": "percentile.inc", "contents": "PERCENTILE.INC(${1:array},${2: k})", "annotation": "Statistical", "details": "Returns the k-th percentile of values in a range.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "PERCENTRANK", + "trigger": "percentrank", "contents": "PERCENTRANK(${1:array},${2: x}${3:,${4: [significance]}})", "annotation": "Compatibility", "details": "Returns the percentage rank of a value in a data set. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "PERCENTRANK.EXC", + "trigger": "percentrank.exc", "contents": "PERCENTRANK.EXC(${1:array},${2: x}${3:,${4: [significance]}})", "annotation": "Statistical", "details": "Returns the rank of a value in a data set as a percentage (0..1, exclusive) of the data set.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "PERCENTRANK.INC", + "trigger": "percentrank.inc", "contents": "PERCENTRANK.INC(${1:array},${2: x}${3:,${4: [significance]}})", "annotation": "Statistical", "details": "Returns the percentage rank of a value in a data set.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "PERMUT", + "trigger": "permut", "contents": "PERMUT(${1:number},${2: number_chosen})", "annotation": "Statistical", "details": "Returns the number of permutations for a given number of objects.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "PERMUTATIONA", + "trigger": "permutationa", "contents": "PERMUTATIONA(${1:number},${2: number_chosen})", "annotation": "Statistical", "details": "Returns the number of permutations for a given number of objects (with repetitions) that can be selected from the total objects.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "PHI", + "trigger": "phi", "contents": "PHI(${1:x})", "annotation": "Statistical", "details": "Returns the value of the density function for a standard normal distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "PHONETIC", + "trigger": "phonetic", "contents": "PHONETIC(${1:reference})", "annotation": "Text", "details": "Extracts the phonetic (furigana) characters from a text string.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "PI", - "contents": "=PI()", + "trigger": "pi", + "contents": "PI()", "annotation": "Math and trigonometry", "details": "Returns the value of pi.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "PMT", + "trigger": "pmt", "contents": "PMT(${1:rate},${2: nper},${3: pv}${4:,${5: [fv]},${6: [type]}})", "annotation": "Financial", "details": "Returns the periodic payment for an annuity.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "POISSON", + "trigger": "poisson", "contents": "POISSON(${1:x},${2: mean},${3: cumulative})", "annotation": "Compatibility", "details": "Returns the Poisson. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "POISSON.DIST", + "trigger": "poisson.dist", "contents": "POISSON.DIST(${1:x},${2: mean},${3: cumulative})", "annotation": "Statistical", "details": "Returns the Poisson distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "POWER", + "trigger": "power", "contents": "POWER(${1:number},${2: power})", "annotation": "Math and trigonometry", "details": "Returns the result of a number raised to a power.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "PPMT", + "trigger": "ppmt", "contents": "PPMT(${1:rate},${2: per},${3: nper},${4: pv}${5:,${6: [fv]},${7: [type]}})", "annotation": "Financial", "details": "Returns the payment on the principal for an investment for a given period.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "PRICE", + "trigger": "price", "contents": "PRICE(${1:settlement},${2: maturity},${3: rate},${4: yld},${5: redemption},${6: frequency}${7:,${8: [basis]}})", "annotation": "Financial", "details": "Returns the price per $100 face value of a security that pays periodic interest.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "PRICEDISC", + "trigger": "pricedisc", "contents": "PRICEDISC(${1:settlement},${2: maturity},${3: discount},${4: redemption}${5:,${6: [basis]}})", "annotation": "Financial", "details": "Returns the price per $100 face value of a discounted security.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "PRICEMAT", + "trigger": "pricemat", "contents": "PRICEMAT(${1:settlement},${2: maturity},${3: issue},${4: rate},${5: yld}${6:,${7: [basis]}})", "annotation": "Financial", "details": "Returns the price per $100 face value of a security that pays interest at maturity.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "PROB", + "trigger": "prob", "contents": "PROB(${1:x_range},${2: prob_range},${3: lower_limit}${4:,${5: [upper_limit]}})", "annotation": "Statistical", "details": "Returns the probability that values in a range are between two limits.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "PRODUCT", + "trigger": "product", "contents": "PRODUCT(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Math and trigonometry", "details": "Multiplies its arguments.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "PROPER", + "trigger": "proper", "contents": "PROPER(${1:text})", "annotation": "Text", "details": "Capitalizes the first letter in each word of a text value.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "PV", + "trigger": "pv", "contents": "PV(${1:rate},${2: nper},${3: pmt}${4:,${5: [fv]},${6: [typel]}})", "annotation": "Financial", "details": "Returns the present value of an investment.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "QUARTILE", + "trigger": "quartile", "contents": "QUARTILE(${1:array},${2: quart})", "annotation": "Compatibility", "details": "Returns the quartile of a data set. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "QUARTILE.EXC", + "trigger": "quartile.exc", "contents": "QUARTILE.EXC(${1:array},${2: quart})", "annotation": "Statistical", "details": "Returns the quartile of the data set, based on percentile values from 0..1, exclusive.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "QUARTILE.INC", + "trigger": "quartile.inc", "contents": "QUARTILE.INC(${1:array},${2: quart})", "annotation": "Statistical", "details": "Returns the quartile of a data set.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "QUOTIENT", + "trigger": "quotient", "contents": "QUOTIENT(${1:numerator},${2: denominator})", "annotation": "Math and trigonometry", "details": "Returns the integer portion of a division.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "RADIANS", + "trigger": "radians", "contents": "RADIANS(${1:angle})", "annotation": "Math and trigonometry", "details": "Converts degrees to radians.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "RAND", - "contents": "=RAND()", + "trigger": "rand", + "contents": "RAND()", "annotation": "Math and trigonometry", "details": "Returns a random number between 0 and 1.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "RANDARRAY", + "trigger": "randarray", "contents": "RANDARRAY(${1:,${2: [rows]},${3: [columns]},${4: [min]},${5: [max]},${6: [integer]}})", "annotation": "Math and trigonometry", "details": "Returns an array of random numbers between 0 and 1. However, you can specify the number of rows and columns to fill, minimum and maximum values, and whether to return whole numbers or decimal values.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "RANDBETWEEN", + "trigger": "randbetween", "contents": "RANDBETWEEN(${1:bottom},${2: top})", "annotation": "Math and trigonometry", "details": "Returns a random number between the numbers you specify.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "RANK", + "trigger": "rank", "contents": "RANK(${1:number},${2: ref}${3:,${4: [order]}})", "annotation": "Compatibility", "details": "Returns the rank of a number in a list of numbers. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "RANK.AVG", + "trigger": "rank.avg", "contents": "RANK.AVG(${1:number},${2: ref}${3:,${4: [order]}})", "annotation": "Statistical", "details": "Returns the rank of a number in a list of numbers. Ties take the average rank.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "RANK.EQ", + "trigger": "rank.eq", "contents": "RANK.EQ(${1:number},${2: ref}${3:,${4: [order]}})", "annotation": "Statistical", "details": "Returns the rank of a number in a list of numbers. Ties take the top rank.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "RATE", + "trigger": "rate", "contents": "RATE(${1:nper},${2: pmt},${3: pv}${4:,${5: [fv]},${6: [type]},${7: [guess]}})", "annotation": "Financial", "details": "Returns the interest rate per period of an annuity.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "RECEIVED", + "trigger": "received", "contents": "RECEIVED(${1:settlement},${2: maturity},${3: investment},${4: discount}${5:,${6: [basis]}})", "annotation": "Financial", "details": "Returns the amount received at maturity for a fully invested security.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "REDUCE", + "trigger": "reduce", "contents": "REDUCE(${1:initial_value},${2: array},${3: function})", "annotation": "Array", "details": "Reduces an array to an accumulated value by applying a LAMBDA function to each value and returning the total value in the accumulator.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "REGISTER", + "trigger": "register", "contents": "REGISTER(${1:module_text},${2: procedure},${3: type_text}${4:,${5: [argument1], ...}})", "annotation": "Add-in", "details": "Returns a reference to the spcified DLL or code resource.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "REGISTER.ID", + "trigger": "register.id", "contents": "REGISTER.ID(${1:module_text},${2: procedure}${3:,${4: [type_text]}})", "annotation": "Add-in", "details": "Returns the register ID of the specified DLL or code resource.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "REPLACE", + "trigger": "replace", "contents": "REPLACE(${1:old_text},${2: start_num},${3: num_chars},${4: new_text})", "annotation": "Text", "details": "Replaces part of a text string with another string, based on a given start position and length.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "REPLACEB", + "trigger": "replaceb", "contents": "REPLACEB(${1:old_text},${2: start_num},${3: num_bytes},${4: new_text})", "annotation": "Text", "details": "Replaces a specified number of bytes in a text string with another text string.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "REPT", + "trigger": "rept", "contents": "REPT(${1:text},${2: number_times})", "annotation": "Text", "details": "Repeats text a given number of times.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "RIGHT", + "trigger": "right", "contents": "RIGHT(${1:text}${2:,${3: [num_chars]}})", "annotation": "Text", "details": "Extracts a specified number of characters from the end (right) of a text string.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "RIGHTB", + "trigger": "rightb", "contents": "RIGHTB(${1:text}${2:,${3: [num_bytes]}})", "annotation": "Text", "details": "Returns the last character or characters in a text string based on bytes.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ROMAN", + "trigger": "roman", "contents": "ROMAN(${1:number}${2:,${3: [form]}})", "annotation": "Math and trigonometry", "details": "Converts an arabic numeral to roman, as text.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ROUND", + "trigger": "round", "contents": "ROUND(${1:number},${2: num_digits})", "annotation": "Math and trigonometry", "details": "Rounds a number to a specified number of digits.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ROUNDDOWN", + "trigger": "rounddown", "contents": "ROUNDDOWN(${1:number},${2: num_digits})", "annotation": "Math and trigonometry", "details": "Rounds a number down, toward zero.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ROUNDUP", + "trigger": "roundup", "contents": "ROUNDUP(${1:number},${2: num_digits})", "annotation": "Math and trigonometry", "details": "Rounds a number up, away from zero.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ROW", + "trigger": "row", "contents": "ROW(${1:,${2: [reference]}})", "annotation": "Lookup and reference", "details": "Returns the row number of a reference.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ROWS", + "trigger": "rows", "contents": "ROWS(${1:array})", "annotation": "Lookup and reference", "details": "Returns the number of rows in a reference.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "RRI", + "trigger": "rri", "contents": "RRI(${1:nper},${2: pv},${3: fv})", "annotation": "Financial", "details": "Returns an equivalent interest rate for the growth of an investment.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "RSQ", + "trigger": "rsq", "contents": "RSQ(${1:known_ys},${2: known_xs})", "annotation": "Statistical", "details": "Returns the square of the Pearson product moment correlation coefficient.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "RTD", + "trigger": "rtd", "contents": "RTD(${1:progID},${2: server},${3: topic1}${4:,${5: [topic2], ...}})", "annotation": "Lookup and reference", "details": "Retrieves real-time data from a program that supports COM automation.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SCAN", + "trigger": "scan", "contents": "SCAN(${1:initial_value},${2: array},${3: function})", "annotation": "Array", "details": "Scans an array by applying a LAMBDA to each value and returns an array that has each intermediate value.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SEARCH", + "trigger": "search", "contents": "SEARCH(${1:find_text},${2: within_text}${3:,${4: [start_num]}})", "annotation": "Text", "details": "Finds the position of a substring within a text string, case-insensitive.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SEARCHB", + "trigger": "searchb", "contents": "SEARCHB(${1:find_text},${2: within_text}${3:,${4: [start_num]}})", "annotation": "Text", "details": "Returns the position of a specified substring within a text string, counting by bytes.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SEC", + "trigger": "sec", "contents": "SEC(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the secant of an angle.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SECH", + "trigger": "sech", "contents": "SECH(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the hyperbolic secant of an angle.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SECOND", + "trigger": "second", "contents": "SECOND(${1:serial_number})", "annotation": "Date and time", "details": "Converts a serial number to a second.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SEQUENCE", + "trigger": "sequence", "contents": "SEQUENCE(${1:rows}${2:,${3: [columns]},${4: [start]},${5: [step]}})", "annotation": "Math and trigonometry", "details": "Generates a list of sequential numbers in an array, such as 1, 2, 3, 4", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SERIESSUM", + "trigger": "seriessum", "contents": "SERIESSUM(${1:x},${2: n},${3: m},${4: coefficients})", "annotation": "Math and trigonometry", "details": "Returns the sum of a power series based on the formula.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SHEET", + "trigger": "sheet", "contents": "SHEET(${1:,${2: [value]}})", "annotation": "Information", "details": "Returns the sheet number of the referenced sheet.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SHEETS", + "trigger": "sheets", "contents": "SHEETS(${1:,${2: [reference]}})", "annotation": "Information", "details": "Returns the number of sheets in a reference.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SIGN", + "trigger": "sign", "contents": "SIGN(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the sign of a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SIN", + "trigger": "sin", "contents": "SIN(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the sine of the given angle.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SINH", + "trigger": "sinh", "contents": "SINH(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the hyperbolic sine of a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SKEW", + "trigger": "skew", "contents": "SKEW(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Statistical", "details": "Returns the skewness of a distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SKEW.P", + "trigger": "skew.p", "contents": "SKEW.P(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Statistical", "details": "Returns the skewness of a distribution based on a population.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SLN", + "trigger": "sln", "contents": "SLN(${1:cost},${2: salvage},${3: life})", "annotation": "Financial", "details": "Returns the straight-line depreciation of an asset for one period.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SLOPE", + "trigger": "slope", "contents": "SLOPE(${1:known_ys},${2: known_xs})", "annotation": "Statistical", "details": "Returns the slope of the linear regression line.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SMALL", + "trigger": "small", "contents": "SMALL(${1:array},${2: k})", "annotation": "Statistical", "details": "Returns the k-th smallest value in a data set.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SORT", + "trigger": "sort", "contents": "SORT(${1:array}${2:,${3: [sort_index]},${4: [sort_order]},${5: [by_col]}})", "annotation": "Lookup and reference", "details": "Sorts the contents of a range or array", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SORTBY", + "trigger": "sortby", "contents": "SORTBY(${1:array},${2: by_array1}${3:,${4: [sort_order1], ...}})", "annotation": "Lookup and reference", "details": "Sorts the contents of a range or array based on the values in a corresponding range or array", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SQRT", + "trigger": "sqrt", "contents": "SQRT(${1:number})", "annotation": "Math and trigonometry", "details": "Returns a positive square root.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SQRTPI", + "trigger": "sqrtpi", "contents": "SQRTPI(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the square root of (number * pi).", - "kind": "function" + "kind": "snippet" }, { - "trigger": "STANDARDIZE", + "trigger": "standardize", "contents": "STANDARDIZE(${1:x},${2: mean},${3: standard_dev})", "annotation": "Statistical", "details": "Returns a normalized value.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "STDEV", + "trigger": "stdev", "contents": "STDEV(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Compatibility", "details": "Estimates standard deviation based on a sample. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "STDEV.P", + "trigger": "stdev.p", "contents": "STDEV.P(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Statistical", "details": "Calculates standard deviation based on the entire population.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "STDEV.S", + "trigger": "stdev.s", "contents": "STDEV.S(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Statistical", "details": "Estimates standard deviation based on a sample.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "STDEVA", + "trigger": "stdeva", "contents": "STDEVA(${1:value1}${2:,${3: [value2], ...}})", "annotation": "Statistical", "details": "Estimates standard deviation based on a sample, including numbers, text, and logical values.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "STDEVP", + "trigger": "stdevp", "contents": "STDEVP(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Compatibility", "details": "Calculates standard deviation based on the entire population. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "STDEVPA", + "trigger": "stdevpa", "contents": "STDEVPA(${1:value1}${2:,${3: [value2], ...}})", "annotation": "Statistical", "details": "Calculates standard deviation based on the entire population, including numbers, text, and logical values.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "STEYX", + "trigger": "steyx", "contents": "STEYX(${1:known_ys},${2: known_xs})", "annotation": "Statistical", "details": "Returns the standard error of the predicted y-value for each x in the regression.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "STOCKHISTORY", + "trigger": "stockhistory", "contents": "STOCKHISTORY(${1:stock},${2: start_date}${3:,${4: [end_date]},${5: [interval]},${6: [headers]},${7: [properties], ...}})", "annotation": "Financial", "details": "Retrieves historical data about a financial instrument.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SUBSTITUTE", + "trigger": "substitute", "contents": "SUBSTITUTE(${1:text},${2: old_text},${3: new_text}${4:,${5: [instance_num]}})", "annotation": "Text", "details": "Substitutes new text for old text in a text string.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SUBTOTAL", + "trigger": "subtotal", "contents": "SUBTOTAL(${1:function_num},${2: ref1}${3:,${4: [ref2], ...}})", "annotation": "Math and trigonometry", "details": "Returns a subtotal in a list or database.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SUM", + "trigger": "sum", "contents": "SUM(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Math and trigonometry", "details": "Adds its arguments.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SUMIF", + "trigger": "sumif", "contents": "SUMIF(${1:range},${2: criteria}${3:,${4: [sum_range]}})", "annotation": "Math and trigonometry", "details": "Adds the cells specified by a given criteria.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SUMIFS", + "trigger": "sumifs", "contents": "SUMIFS(${1:sum_range},${2: criteria_range1},${3: criteria1}${4:,${5: [criteria_range2]},${6: [criteria2], ...}})", "annotation": "Math and trigonometry", "details": "Adds the cells in a range that meet multiple criteria.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SUMPRODUCT", + "trigger": "sumproduct", "contents": "SUMPRODUCT(${1:array1}${2:,${3: [array2]},${4: [array3], ...}})", "annotation": "Math and trigonometry", "details": "Returns the sum of the products of corresponding array components.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SUMSQ", + "trigger": "sumsq", "contents": "SUMSQ(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Math and trigonometry", "details": "Returns the sum of the squares of the arguments.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SUMX2MY2", + "trigger": "sumx2my2", "contents": "SUMX2MY2(${1:array_x},${2: array_y})", "annotation": "Math and trigonometry", "details": "Returns the sum of the difference of squares of corresponding values in two arrays.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SUMX2PY2", + "trigger": "sumx2py2", "contents": "SUMX2PY2(${1:array_x},${2: array_y})", "annotation": "Math and trigonometry", "details": "Returns the sum of the sum of squares of corresponding values in two arrays.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SUMXMY2", + "trigger": "sumxmy2", "contents": "SUMXMY2(${1:array_x},${2: array_y})", "annotation": "Math and trigonometry", "details": "Returns the sum of squares of differences of corresponding values in two arrays.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SWITCH", + "trigger": "switch", "contents": "SWITCH(${1:expression},${2: value1},${3: result1}${4:,${5: [default_or_value2]},${6: [result2], ...}})", "annotation": "Logical", "details": "Evaluates an expression against a list of values and returns the result corresponding to the first matching value. If there is no match, an optional default value may be returned. This function isn't available in Excel 2016 for Mac.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "SYD", + "trigger": "syd", "contents": "SYD(${1:cost},${2: salvage},${3: life},${4: per})", "annotation": "Financial", "details": "Returns the sum-of-years' digits depreciation of an asset for a specified period.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "T", + "trigger": "t", "contents": "T(${1:value})", "annotation": "Text", "details": "Converts its arguments to text.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "T.DIST", + "trigger": "t.dist", "contents": "T.DIST(${1:x},${2: deg_freedom},${3: cumulative})", "annotation": "Statistical", "details": "Returns the left-tailed Student t-distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "T.DIST.2T", + "trigger": "t.dist.2t", "contents": "T.DIST.2T(${1:x},${2: deg_freedom})", "annotation": "Statistical", "details": "Returns the two-tailed Student t-distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "T.DIST.RT", + "trigger": "t.dist.rt", "contents": "T.DIST.RT(${1:x},${2: deg_freedom})", "annotation": "Statistical", "details": "Returns the right-tailed Student's t-distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "T.INV", + "trigger": "t.inv", "contents": "T.INV(${1:probability},${2: deg_freedom})", "annotation": "Statistical", "details": "Returns the left-tailed inverse of the Student's t-distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "T.INV.2T", + "trigger": "t.inv.2t", "contents": "T.INV.2T(${1:probability},${2: deg_freedom})", "annotation": "Statistical", "details": "Returns the two-tailed inverse of the Student's t-distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "T.TEST", + "trigger": "t.test", "contents": "T.TEST(${1:array1},${2: array2},${3: tails},${4: type})", "annotation": "Statistical", "details": "Returns the probability associated with a Student's t-test.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TAKE", + "trigger": "take", "contents": "TAKE(${1:array},${2: rows}${3:,${4: [columns]}})", "annotation": "Array", "details": "Returns rows or columns from the start or end of an array.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TAN", + "trigger": "tan", "contents": "TAN(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the tangent of a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TANH", + "trigger": "tanh", "contents": "TANH(${1:number})", "annotation": "Math and trigonometry", "details": "Returns the hyperbolic tangent of a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TBILLEQ", + "trigger": "tbilleq", "contents": "TBILLEQ(${1:settlement},${2: maturity},${3: discount})", "annotation": "Financial", "details": "Returns the bond-equivalent yield for a Treasury bill.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TBILLPRICE", + "trigger": "tbillprice", "contents": "TBILLPRICE(${1:settlement},${2: maturity},${3: discount})", "annotation": "Financial", "details": "Returns the price per $100 face value for a Treasury bill.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TBILLYIELD", + "trigger": "tbillyield", "contents": "TBILLYIELD(${1:settlement},${2: maturity},${3: pr})", "annotation": "Financial", "details": "Returns the yield for a Treasury bill.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TDIST", + "trigger": "tdist", "contents": "TDIST(${1:x},${2: deg_freedom},${3: tails})", "annotation": "Compatibility", "details": "Returns the Student's t-distribution. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TEXT", + "trigger": "text", "contents": "TEXT(${1:value},${2: format_text})", "annotation": "Text", "details": "Formats a number and converts it to text.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TEXTAFTER", + "trigger": "textafter", "contents": "TEXTAFTER(${1:text},${2: delimiter}${3:,${4: [instance_num]},${5: [match_mode]},${6: [match_end]},${7: [if_not_found]}})", "annotation": "Text", "details": "Returns text that's after delimiting characters.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TEXTBEFORE", + "trigger": "textbefore", "contents": "TEXTBEFORE(${1:text},${2: delimiter}${3:,${4: [instance_num]},${5: [match_mode]},${6: [match_end]},${7: [if_not_found]}})", "annotation": "Text", "details": "Returns text that's before delimiting characters.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TEXTJOIN", + "trigger": "textjoin", "contents": "TEXTJOIN(${1:delimiter},${2: ignore_empty},${3: text1}${4:,${5: [text2], ...}})", "annotation": "Text", "details": "Combines the text from multiple ranges and/or strings, and includes a delimiter you specify between each text value that will be combined. If the delimiter is an empty text string, this function will effectively concatenate the ranges. This function isn't available in Excel 2016 for Mac.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TEXTSPLIT", + "trigger": "textsplit", "contents": "TEXTSPLIT(${1:text},${2: col_delimiter}${3:,${4: [row_delimiter]},${5: [ignore_empty]},${6: [match_mode]},${7: [pad_with]}})", "annotation": "Text", "details": "Splits text into rows or columns using delimiters.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TIME", + "trigger": "time", "contents": "TIME(${1:hour},${2: minute},${3: second})", "annotation": "Date and time", "details": "Returns the serial number of a particular time.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TIMEVALUE", + "trigger": "timevalue", "contents": "TIMEVALUE(${1:time_text})", "annotation": "Date and time", "details": "Converts a time in the form of text to a serial number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TINV", + "trigger": "tinv", "contents": "TINV(${1:probability},${2: deg_freedom})", "annotation": "Compatibility", "details": "Returns the inverse of the Student's t-distribution. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TOCOL", + "trigger": "tocol", "contents": "TOCOL(${1:array}${2:,${3: [ignore]},${4: [scan_by_column]}})", "annotation": "Array", "details": "Returns the array as a column.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TODAY", - "contents": "=TODAY()", + "trigger": "today", + "contents": "TODAY()", "annotation": "Date and time", "details": "Returns the serial number of today's date.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TOROW", + "trigger": "torow", "contents": "TOROW(${1:array}${2:,${3: [ignore]},${4: [scan_by_column]}})", "annotation": "Array", "details": "Returns the array as a row.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TRANSPOSE", + "trigger": "transpose", "contents": "TRANSPOSE(${1:array})", "annotation": "Lookup and reference", "details": "Returns the transpose of an array.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TREND", + "trigger": "trend", "contents": "TREND(${1:known_ys}${2:,${3: [known_xs]},${4: [new_xs]},${5: [const]}})", "annotation": "Statistical", "details": "Returns values along a linear trend.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TRIM", + "trigger": "trim", "contents": "TRIM(${1:text})", "annotation": "Text", "details": "Removes spaces from text.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TRIMMEAN", + "trigger": "trimmean", "contents": "TRIMMEAN(${1:array},${2: percent})", "annotation": "Statistical", "details": "Returns the mean of the interior of a data set.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TRUNC", + "trigger": "trunc", "contents": "TRUNC(${1:number}${2:,${3: [num_digits]}})", "annotation": "Math and trigonometry", "details": "Truncates a number to an integer.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TTEST", + "trigger": "ttest", "contents": "TTEST(${1:array1},${2: array2},${3: tails},${4: type})", "annotation": "Compatibility", "details": "Returns the probability associated with a Student's t-test. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "TYPE", + "trigger": "type", "contents": "TYPE(${1:value})", "annotation": "Information", "details": "Returns a number indicating the data type of a value.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "UNICHAR", + "trigger": "unichar", "contents": "UNICHAR(${1:number})", "annotation": "Text", "details": "Returns the Unicode character that is references by the given numeric value.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "UNICODE", + "trigger": "unicode", "contents": "UNICODE(${1:text})", "annotation": "Text", "details": "Returns the number (code point) that corresponds to the first character of the text.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "UNIQUE", + "trigger": "unique", "contents": "UNIQUE(${1:array}${2:,${3: [by_col]},${4: [exactly_once]}})", "annotation": "Lookup and reference", "details": "Returns a list of unique values in a list or range", - "kind": "function" + "kind": "snippet" }, { - "trigger": "UNREGISTER", + "trigger": "unregister", "contents": "UNREGISTER(${1:register_id})", "annotation": "Add-in", "details": "Removes the registration of a DLL or code resource.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "UPPER", + "trigger": "upper", "contents": "UPPER(${1:text})", "annotation": "Text", "details": "Converts text to uppercase.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "VALUE", + "trigger": "value", "contents": "VALUE(${1:text})", "annotation": "Text", "details": "Converts a text argument to a number.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "VALUETOTEXT", + "trigger": "valuetotext", "contents": "VALUETOTEXT(${1:value}${2:,${3: [format]}})", "annotation": "Text", "details": "Returns text from any specified value", - "kind": "function" + "kind": "snippet" }, { - "trigger": "VAR", + "trigger": "var", "contents": "VAR(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Compatibility", "details": "Estimates variance based on a sample. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "VAR.P", + "trigger": "var.p", "contents": "VAR.P(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Statistical", "details": "Calculates variance based on the entire population.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "VAR.S", + "trigger": "var.s", "contents": "VAR.S(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Statistical", "details": "Estimates variance based on a sample.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "VARA", + "trigger": "vara", "contents": "VARA(${1:value1}${2:,${3: [value2], ...}})", "annotation": "Statistical", "details": "Estimates variance based on a sample, including numbers, text, and logical values.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "VARP", + "trigger": "varp", "contents": "VARP(${1:number1}${2:,${3: [number2], ...}})", "annotation": "Compatibility", "details": "Calculates variance based on the entire population. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "VARPA", + "trigger": "varpa", "contents": "VARPA(${1:value1}${2:,${3: [value2], ...}})", "annotation": "Statistical", "details": "Calculates variance based on the entire population, including numbers, text, and logical values.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "VDB", + "trigger": "vdb", "contents": "VDB(${1:cost},${2: salvage},${3: life},${4: start_period},${5: end_period}${6:,${7: [factor]},${8: [no_switch]}})", "annotation": "Financial", "details": "Returns the depreciation of an asset for a specified or partial period by using a declining balance method.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "VLOOKUP", + "trigger": "vlookup", "contents": "VLOOKUP(${1:lookup_value},${2: table_array},${3: col_index_num}${4:,${5: [range_lookup]}})", "annotation": "Lookup and reference", "details": "Looks in the first column of an array and moves across the row to return the value of a cell.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "VSTACK", + "trigger": "vstack", "contents": "VSTACK(${1:array1}${2:,${3: [array2], ...}})", "annotation": "Array", "details": "Vertically combine arrays into one array.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "WEBSERVICE", + "trigger": "webservice", "contents": "WEBSERVICE(${1:url})", "annotation": "Web", "details": "Returns data from a web service. This function is not available in Excel Online.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "WEEKDAY", + "trigger": "weekday", "contents": "WEEKDAY(${1:serial_number}${2:,${3: [return_type]}})", "annotation": "Date and time", "details": "Converts a serial number to a day of the week.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "WEEKNUM", + "trigger": "weeknum", "contents": "WEEKNUM(${1:serial_number}${2:,${3: [return_type]}})", "annotation": "Date and time", "details": "Converts a serial number to a number representing where the week falls numerically with a year.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "WEIBULL", + "trigger": "weibull", "contents": "WEIBULL(${1:x},${2: alpha},${3: beta},${4: cumulative})", "annotation": "Compatibility", "details": "Calculates variance based on the entire population, including numbers, text, and logical values. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "WEIBULL.DIST", + "trigger": "weibull.dist", "contents": "WEIBULL.DIST(${1:x},${2: alpha},${3: beta},${4: cumulative})", "annotation": "Statistical", "details": "Returns the Weibull distribution.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "WORKDAY", + "trigger": "workday", "contents": "WORKDAY(${1:start_date},${2: days}${3:,${4: [holidays]}})", "annotation": "Date and time", "details": "Returns the serial number of the date before or after a specified number of workdays.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "WORKDAY.INTL", + "trigger": "workday.intl", "contents": "WORKDAY.INTL(${1:start_date},${2: days}${3:,${4: [weekend]},${5: [holidays]}})", "annotation": "Date and time", "details": "Returns the serial number of the date before or after a specified number of workdays using parameters to indicate which and how many days are weekend days.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "WRAPCOLS", + "trigger": "wrapcols", "contents": "WRAPCOLS(${1:vector},${2: wrap_count}${3:,${4: [pad_with]}})", "annotation": "Array", "details": "Wraps a row or column to a specified height.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "WRAPROWS", + "trigger": "wraprows", "contents": "WRAPROWS(${1:vector},${2: wrap_count}${3:,${4: [pad_with]}})", "annotation": "Array", "details": "Wraps a row or column to a specified width.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "XIRR", + "trigger": "xirr", "contents": "XIRR(${1:values},${2: dates}${3:,${4: [guess]}})", "annotation": "Financial", "details": "Returns the internal rate of return for a schedule of cash flows that is not necessarily periodic.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "XLOOKUP", + "trigger": "xlookup", "contents": "XLOOKUP(${1:lookup_value},${2: lookup_array},${3: return_array}${4:,${5: [if_not_found]},${6: [match_mode]},${7: [search_mode]}})", "annotation": "Lookup and reference", "details": "Searches a range or an array, and returns an item corresponding to the first match it finds. If a match doesn't exist,then XLOOKUP can return the closest (approximate) match.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "XMATCH", + "trigger": "xmatch", "contents": "XMATCH(${1:lookup_value},${2: lookup_array}${3:,${4: [match_mode]},${5: [search_mode]}})", "annotation": "Lookup and reference", "details": "Returns the relative position of an item in an array or range of cells.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "XNPV", + "trigger": "xnpv", "contents": "XNPV(${1:rate},${2: values},${3: dates})", "annotation": "Financial", "details": "Returns the net present value for a schedule of cash flows that is not necessarily periodic.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "XOR", + "trigger": "xor", "contents": "XOR(${1:logical1}${2:,${3: [logical2], ...}})", "annotation": "Logical", "details": "Returns a logical exclusive OR of all arguments.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "YEAR", + "trigger": "year", "contents": "YEAR(${1:serial_number})", "annotation": "Date and time", "details": "Converts a serial number to a year.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "YEARFRAC", + "trigger": "yearfrac", "contents": "YEARFRAC(${1:start_date},${2: end_date}${3:,${4: [basis]}})", "annotation": "Date and time", "details": "Returns the year fraction representing the number of whole days between start_date and end_date.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "YIELD", + "trigger": "yield", "contents": "YIELD(${1:settlement},${2: maturity},${3: rate},${4: pr},${5: redemption},${6: frequency}${7:,${8: [basis]}})", "annotation": "Financial", "details": "Returns the yield on a security that pays periodic interest.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "YIELDDISC", + "trigger": "yielddisc", "contents": "YIELDDISC(${1:settlement},${2: maturity},${3: pr},${4: redemption}${5:,${6: [basis]}})", "annotation": "Financial", "details": "Returns the annual yield for a discounted security.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "YIELDMAT", + "trigger": "yieldmat", "contents": "YIELDMAT(${1:settlement},${2: maturity},${3: issue},${4: rate},${5: pr}${6:,${7: [basis]}})", "annotation": "Financial", "details": "Returns the annual yield of a security that pays interest at maturity.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "Z.TEST", + "trigger": "z.test", "contents": "Z.TEST(${1:array},${2: x}${3:,${4: [sigma]}})", "annotation": "Statistical", "details": "Returns the one-tailed probability-value of a z-test.", - "kind": "function" + "kind": "snippet" }, { - "trigger": "ZTEST", + "trigger": "ztest", "contents": "ZTEST(${1:array},${2: x}${3:,${4: [sigma]}})", "annotation": "Compatibility", "details": "Returns the one-tailed probability-value of a z-test. In Excel 2007, this is a Statistical function.", - "kind": "function" + "kind": "snippet" } ] } \ No newline at end of file diff --git a/resources/completion_builder/main.py b/resources/completion_builder/main.py index 3bddab6..b620237 100755 --- a/resources/completion_builder/main.py +++ b/resources/completion_builder/main.py @@ -1,50 +1,42 @@ #! /usr/bin/env python3 -import subprocess import json - -# Switch subscript versions as needed. -# These functions pass information through input/output files and sys.argv based on the value of `app`, -# so they can be used in any combination if that is maintained. -subscripts = ['js.py', 'cb.py', 'ld.py', 'mg.py'] - -# Takes values of 'excel', 'google', 'libre' -app = 'excel' - -# Boolean-toggled rerun of subscripts -toggle_rerun = True - -if toggle_rerun: - print(f'App Config: {app}') - for subscript in subscripts: - print(f'Running {subscript}...') - result = subprocess.run(['python3', subscript, app], check = True) - if result.returncode != 0: - print(f'Error occured while running {subscript}') - break - print(f'{subscript} completed successfully') - -master_file = open(f'{app}_funcs_master.json', 'r') - -master_list = json.load(master_file) - -master_file.close() - -completions = [] - -for func in master_list: - trigger = func.get('func_name') - contents = func.get('comp_str') - annotation = func.get('func_cat') - details = func.get('func_desc') - kind = 'function' - completions.append(dict(trigger = trigger, contents = contents, annotation = annotation, details = details, kind = kind)) - -dict_list = dict(scope = f'source.sheet.{app} - string - comment', completions = completions) - -json_out = json.dumps(dict_list, indent = 4) - -o = open('.sublime-completions', 'w') - -o.write(json_out) -o.close() +from argparse import ArgumentParser + +from SpreadsheetFunction import APP_SUFFIXES, SpreadsheetFunction +from js import parse_function_list +from ld import dump_function_args +from mg import merge_function_args_with_desc + +def main(sheet_app: str, write_intermediate_json: bool): + + # TODO: pass the data seamlessly without dumping files + parse_function_list(sheet_app, write_intermediate_json) + dump_function_args(sheet_app, write_intermediate_json) + functions = merge_function_args_with_desc(sheet_app, write_intermediate_json) + + completions = { + "scope": f'source.sheet.{sheet_app} - string - comment', + "completions": [f.to_sublime_snippet_completion() for f in functions], + } + + with open('.sublime-completions', 'w') as o: + json.dump(completions, o, indent=4) + + +if __name__ == '__main__': + parser = ArgumentParser( + description='Construct spreadsheet app function completions') + parser.add_argument( + '-s', '--spreadsheet-app', + choices=APP_SUFFIXES, + default='excel', + help='spreadsheet application') + parser.add_argument( + '-j', '--dump-json', + type=bool, + default=True, + help='dump JSON output to a file') + args = parser.parse_args() + + main(args.spreadsheet_app, args.dump_json) From d52c03b8c0d4b15ee855efb20d19e3dd26d0421a Mon Sep 17 00:00:00 2001 From: Michael Lyons Date: Sun, 9 Feb 2025 17:43:15 -0500 Subject: [PATCH 11/12] Add bare function names back into completions --- .../completion_builder/.sublime-completions | 3584 +++++++++++++++++ resources/completion_builder/main.py | 3 +- 2 files changed, 3586 insertions(+), 1 deletion(-) diff --git a/resources/completion_builder/.sublime-completions b/resources/completion_builder/.sublime-completions index 2e7d524..e3f1f78 100644 --- a/resources/completion_builder/.sublime-completions +++ b/resources/completion_builder/.sublime-completions @@ -3584,6 +3584,3590 @@ "annotation": "Compatibility", "details": "Returns the one-tailed probability-value of a z-test. In Excel 2007, this is a Statistical function.", "kind": "snippet" + }, + { + "trigger": "ABS", + "contents": "ABS", + "annotation": "Math and trigonometry", + "details": "Returns the absolute value of a number.", + "kind": "function" + }, + { + "trigger": "ACCRINT", + "contents": "ACCRINT", + "annotation": "Financial", + "details": "Returns the accrued interest for a security that pays periodic interest.", + "kind": "function" + }, + { + "trigger": "ACCRINTM", + "contents": "ACCRINTM", + "annotation": "Financial", + "details": "Returns the accrued interest for a security that pays interest at maturity.", + "kind": "function" + }, + { + "trigger": "ACOS", + "contents": "ACOS", + "annotation": "Math and trigonometry", + "details": "Returns the arccosine of a number.", + "kind": "function" + }, + { + "trigger": "ACOSH", + "contents": "ACOSH", + "annotation": "Math and trigonometry", + "details": "Returns the inverse hyperbolic cosine of a number.", + "kind": "function" + }, + { + "trigger": "ACOT", + "contents": "ACOT", + "annotation": "Math and trigonometry", + "details": "Returns the arccotangent of a number.", + "kind": "function" + }, + { + "trigger": "ACOTH", + "contents": "ACOTH", + "annotation": "Math and trigonometry", + "details": "Returns the hyperbolic arccotangent of a number.", + "kind": "function" + }, + { + "trigger": "ADDRESS", + "contents": "ADDRESS", + "annotation": "Lookup and reference", + "details": "Returns a reference as text to a single cell in a worksheet.", + "kind": "function" + }, + { + "trigger": "AGGREGATE", + "contents": "AGGREGATE", + "annotation": "Math and trigonometry", + "details": "Returns an aggregate in a list or database.", + "kind": "function" + }, + { + "trigger": "AMORDEGRC", + "contents": "AMORDEGRC", + "annotation": "Financial", + "details": "Returns the depreciation for each accounting period by using a depreciation coefficient.", + "kind": "function" + }, + { + "trigger": "AMORLINC", + "contents": "AMORLINC", + "annotation": "Financial", + "details": "Returns the depreciation for each accounting period.", + "kind": "function" + }, + { + "trigger": "AND", + "contents": "AND", + "annotation": "Logical", + "details": "Returns TRUE if all of its arguments are TRUE.", + "kind": "function" + }, + { + "trigger": "ARABIC", + "contents": "ARABIC", + "annotation": "Math and trigonometry", + "details": "Converts a Roman number to Arabic, as a number.", + "kind": "function" + }, + { + "trigger": "AREAS", + "contents": "AREAS", + "annotation": "Lookup and reference", + "details": "Returns the number of areas in a reference.", + "kind": "function" + }, + { + "trigger": "ARRAYTOTEXT", + "contents": "ARRAYTOTEXT", + "annotation": "Text", + "details": "Returns an array of text values from any specified range.", + "kind": "function" + }, + { + "trigger": "ASC", + "contents": "ASC", + "annotation": "Text", + "details": "Changes full-width (double-byte) English letters or katakana within a character string to half-width (single-byte) characters.", + "kind": "function" + }, + { + "trigger": "ASIN", + "contents": "ASIN", + "annotation": "Math and trigonometry", + "details": "Returns the arcsine of a number.", + "kind": "function" + }, + { + "trigger": "ASINH", + "contents": "ASINH", + "annotation": "Math and trigonometry", + "details": "Returns the inverse hyperbolic sine of a number.", + "kind": "function" + }, + { + "trigger": "ATAN", + "contents": "ATAN", + "annotation": "Math and trigonometry", + "details": "Returns the arctangent of a number.", + "kind": "function" + }, + { + "trigger": "ATAN2", + "contents": "ATAN2", + "annotation": "Math and trigonometry", + "details": "Returns the arctangent from x- and y-coordinates.", + "kind": "function" + }, + { + "trigger": "ATANH", + "contents": "ATANH", + "annotation": "Math and trigonometry", + "details": "Returns the inverse hyperbolic tangent of a number.", + "kind": "function" + }, + { + "trigger": "AVEDEV", + "contents": "AVEDEV", + "annotation": "Statistical", + "details": "Returns the average of the absolute deviations of data points from their mean.", + "kind": "function" + }, + { + "trigger": "AVERAGE", + "contents": "AVERAGE", + "annotation": "Statistical", + "details": "Returns the average of its arguments.", + "kind": "function" + }, + { + "trigger": "AVERAGEA", + "contents": "AVERAGEA", + "annotation": "Statistical", + "details": "Returns the average of its arguments, including numbers, text, and logical values.", + "kind": "function" + }, + { + "trigger": "AVERAGEIF", + "contents": "AVERAGEIF", + "annotation": "Statistical", + "details": "Returns the average (arithmetic mean) of all the cells in a range that meet a given criteria.", + "kind": "function" + }, + { + "trigger": "AVERAGEIFS", + "contents": "AVERAGEIFS", + "annotation": "Statistical", + "details": "Returns the average (arithmetic mean) of all cells that meet multiple criteria.", + "kind": "function" + }, + { + "trigger": "BAHTTEXT", + "contents": "BAHTTEXT", + "annotation": "Text", + "details": "Converts a number to text, using the \u00df (baht) currency format.", + "kind": "function" + }, + { + "trigger": "BASE", + "contents": "BASE", + "annotation": "Math and trigonometry", + "details": "Converts a number into a text representation with the given radix (base).", + "kind": "function" + }, + { + "trigger": "BESSELI", + "contents": "BESSELI", + "annotation": "Engineering", + "details": "Returns the modified Bessel function In(x).", + "kind": "function" + }, + { + "trigger": "BESSELJ", + "contents": "BESSELJ", + "annotation": "Engineering", + "details": "Returns the Bessel function Jn(x).", + "kind": "function" + }, + { + "trigger": "BESSELK", + "contents": "BESSELK", + "annotation": "Engineering", + "details": "Returns the modified Bessel function Kn(x).", + "kind": "function" + }, + { + "trigger": "BESSELY", + "contents": "BESSELY", + "annotation": "Engineering", + "details": "Returns the Bessel function Yn(x).", + "kind": "function" + }, + { + "trigger": "BETA.DIST", + "contents": "BETA.DIST", + "annotation": "Statistical", + "details": "Returns the beta cumulative distribution function.", + "kind": "function" + }, + { + "trigger": "BETA.INV", + "contents": "BETA.INV", + "annotation": "Statistical", + "details": "Returns the inverse of the cumulative distribution function for a specified beta distribution.", + "kind": "function" + }, + { + "trigger": "BETADIST", + "contents": "BETADIST", + "annotation": "Compatibility", + "details": "Returns the beta cumulative distribution function. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "BETAINV", + "contents": "BETAINV", + "annotation": "Compatibility", + "details": "Returns the inverse of the cumulative distribution function for a specified beta. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "BIN2DEC", + "contents": "BIN2DEC", + "annotation": "Engineering", + "details": "Converts a binary number to decimal.", + "kind": "function" + }, + { + "trigger": "BIN2HEX", + "contents": "BIN2HEX", + "annotation": "Engineering", + "details": "Converts a binary number to hexadecimal.", + "kind": "function" + }, + { + "trigger": "BIN2OCT", + "contents": "BIN2OCT", + "annotation": "Engineering", + "details": "Converts a binary number to octal.", + "kind": "function" + }, + { + "trigger": "BINOM.DIST", + "contents": "BINOM.DIST", + "annotation": "Statistical", + "details": "Returns the individual term binomial distribution probability.", + "kind": "function" + }, + { + "trigger": "BINOM.DIST.RANGE", + "contents": "BINOM.DIST.RANGE", + "annotation": "Statistical", + "details": "Returns the probability of a trial result using a binomial distribution.", + "kind": "function" + }, + { + "trigger": "BINOM.INV", + "contents": "BINOM.INV", + "annotation": "Statistical", + "details": "Returns the smallest value for which the cumulative binomial distribution is less than or equal to a criterion value.", + "kind": "function" + }, + { + "trigger": "BINOMDIST", + "contents": "BINOMDIST", + "annotation": "Compatibility", + "details": "Returns the individual term binomial distribution probability. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "BITAND", + "contents": "BITAND", + "annotation": "Engineering", + "details": "Returns a 'Bitwise And' of two numbers.", + "kind": "function" + }, + { + "trigger": "BITLSHIFT", + "contents": "BITLSHIFT", + "annotation": "Engineering", + "details": "Returns a value number shifted left by shift_amount bits.", + "kind": "function" + }, + { + "trigger": "BITOR", + "contents": "BITOR", + "annotation": "Engineering", + "details": "Returns a bitwise OR of 2 numbers.", + "kind": "function" + }, + { + "trigger": "BITRSHIFT", + "contents": "BITRSHIFT", + "annotation": "Engineering", + "details": "Returns a value number shifted right by shift_amount bits.", + "kind": "function" + }, + { + "trigger": "BITXOR", + "contents": "BITXOR", + "annotation": "Engineering", + "details": "Returns a bitwise 'Exclusive Or' of two numbers.", + "kind": "function" + }, + { + "trigger": "BYCOL", + "contents": "BYCOL", + "annotation": "Array", + "details": "Applies a LAMBDA to each column and returns an array of the results.", + "kind": "function" + }, + { + "trigger": "BYROW", + "contents": "BYROW", + "annotation": "Array", + "details": "Applies a LAMBDA to each row and returns an array of the results.", + "kind": "function" + }, + { + "trigger": "CALL", + "contents": "CALL", + "annotation": "Add-in", + "details": "Calls a procedure in a specified DLL or code resource.", + "kind": "function" + }, + { + "trigger": "CEILING", + "contents": "CEILING", + "annotation": "Math and trigonometry", + "details": "Rounds a number to the nearest integer or to the nearest multiple of significance.", + "kind": "function" + }, + { + "trigger": "CEILING.MATH", + "contents": "CEILING.MATH", + "annotation": "Math and trigonometry", + "details": "Rounds a number up, to the nearest integer or to the nearest multiple of significance.", + "kind": "function" + }, + { + "trigger": "CEILING.PRECISE", + "contents": "CEILING.PRECISE", + "annotation": "Math and trigonometry", + "details": "Rounds a number the nearest integer or to the nearest multiple of significance. Regardless of the sign of the number, the number is rounded up.", + "kind": "function" + }, + { + "trigger": "CELL", + "contents": "CELL", + "annotation": "Information", + "details": "Returns information about the formatting, location, or contents of a cell. This function is not available in Excel Online.", + "kind": "function" + }, + { + "trigger": "CHAR", + "contents": "CHAR", + "annotation": "Text", + "details": "Returns the character specified by the code number.", + "kind": "function" + }, + { + "trigger": "CHIDIST", + "contents": "CHIDIST", + "annotation": "Compatibility", + "details": "Returns the one-tailed probability of the chi-squared. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "CHIINV", + "contents": "CHIINV", + "annotation": "Compatibility", + "details": "Returns the inverse of the one-tailed probability of the chi-squared. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "CHISQ.DIST", + "contents": "CHISQ.DIST", + "annotation": "Statistical", + "details": "Returns the left-tailed probability of the chi-squared distribution.", + "kind": "function" + }, + { + "trigger": "CHISQ.DIST.RT", + "contents": "CHISQ.DIST.RT", + "annotation": "Statistical", + "details": "Returns the right-tailed probability of the chi-squared distribution.", + "kind": "function" + }, + { + "trigger": "CHISQ.INV", + "contents": "CHISQ.INV", + "annotation": "Statistical", + "details": "Returns the inverse of the left-tailed probability of the chi-squared distribution.", + "kind": "function" + }, + { + "trigger": "CHISQ.INV.RT", + "contents": "CHISQ.INV.RT", + "annotation": "Statistical", + "details": "Returns the inverse of the right-tailed probability of the chi-squared distribution.", + "kind": "function" + }, + { + "trigger": "CHISQ.TEST", + "contents": "CHISQ.TEST", + "annotation": "Statistical", + "details": "Returns the test for independence: the value from the chi-squared distribution for the statistic and the appropriate degrees of freedom.", + "kind": "function" + }, + { + "trigger": "CHITEST", + "contents": "CHITEST", + "annotation": "Compatibility", + "details": "Returns the test for independence. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "CHOOSE", + "contents": "CHOOSE", + "annotation": "Lookup and reference", + "details": "Chooses a value from a list of values.", + "kind": "function" + }, + { + "trigger": "CHOOSECOLS", + "contents": "CHOOSECOLS", + "annotation": "Array", + "details": "Returns columns from an array or reference.", + "kind": "function" + }, + { + "trigger": "CHOOSEROWS", + "contents": "CHOOSEROWS", + "annotation": "Array", + "details": "Returns rows from an array of reference.", + "kind": "function" + }, + { + "trigger": "CLEAN", + "contents": "CLEAN", + "annotation": "Text", + "details": "Removes all nonprintable characters from text.", + "kind": "function" + }, + { + "trigger": "CODE", + "contents": "CODE", + "annotation": "Text", + "details": "Returns a numeric code for the first character in a text string.", + "kind": "function" + }, + { + "trigger": "COLUMN", + "contents": "COLUMN", + "annotation": "Lookup and reference", + "details": "Returns the column number of a reference.", + "kind": "function" + }, + { + "trigger": "COLUMNS", + "contents": "COLUMNS", + "annotation": "Lookup and reference", + "details": "Returns the number of columns in a reference.", + "kind": "function" + }, + { + "trigger": "COMBIN", + "contents": "COMBIN", + "annotation": "Math and trigonometry", + "details": "Returns the number of combinations for a given number of objects.", + "kind": "function" + }, + { + "trigger": "COMBINA", + "contents": "COMBINA", + "annotation": "Math and trigonometry", + "details": "Returns the number of combinations with repetitions for a given number of items.", + "kind": "function" + }, + { + "trigger": "COMPLEX", + "contents": "COMPLEX", + "annotation": "Engineering", + "details": "Converts real and imaginary coefficients into a complex number.", + "kind": "function" + }, + { + "trigger": "CONCAT", + "contents": "CONCAT", + "annotation": "Text", + "details": "Combines the text from multiple ranges and/or strings, but it doesn't provide the delimiter or IgnoreEmpty arguments. This function isn't available in Excel 2016 for Mac.", + "kind": "function" + }, + { + "trigger": "CONCATENATE", + "contents": "CONCATENATE", + "annotation": "Text", + "details": "Joins several text items into one text item.", + "kind": "function" + }, + { + "trigger": "CONFIDENCE", + "contents": "CONFIDENCE", + "annotation": "Compatibility", + "details": "Returns the confidence interval for a population mean. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "CONFIDENCE.NORM", + "contents": "CONFIDENCE.NORM", + "annotation": "Statistical", + "details": "Returns the confidence interval for a population mean.", + "kind": "function" + }, + { + "trigger": "CONFIDENCE.T", + "contents": "CONFIDENCE.T", + "annotation": "Statistical", + "details": "Returns the confidence interval for a population mean, using a Student's t distribution.", + "kind": "function" + }, + { + "trigger": "CONVERT", + "contents": "CONVERT", + "annotation": "Engineering", + "details": "Converts a number from one measurement system to another.", + "kind": "function" + }, + { + "trigger": "CORREL", + "contents": "CORREL", + "annotation": "Statistical", + "details": "Returns the correlation coefficient between two data sets.", + "kind": "function" + }, + { + "trigger": "COS", + "contents": "COS", + "annotation": "Math and trigonometry", + "details": "Returns the cosine of a number.", + "kind": "function" + }, + { + "trigger": "COSH", + "contents": "COSH", + "annotation": "Math and trigonometry", + "details": "Returns the hyperbolic cosine of a number.", + "kind": "function" + }, + { + "trigger": "COT", + "contents": "COT", + "annotation": "Math and trigonometry", + "details": "Returns the cotangent of a number.", + "kind": "function" + }, + { + "trigger": "COTH", + "contents": "COTH", + "annotation": "Math and trigonometry", + "details": "Returns the cotangent of an angle.", + "kind": "function" + }, + { + "trigger": "COUNT", + "contents": "COUNT", + "annotation": "Statistical", + "details": "Counts how many numbers are in the list of arguments.", + "kind": "function" + }, + { + "trigger": "COUNTA", + "contents": "COUNTA", + "annotation": "Statistical", + "details": "Counts how many values are in the list of arguments.", + "kind": "function" + }, + { + "trigger": "COUNTBLANK", + "contents": "COUNTBLANK", + "annotation": "Statistical", + "details": "Counts the number of blank cells within a range.", + "kind": "function" + }, + { + "trigger": "COUNTIF", + "contents": "COUNTIF", + "annotation": "Statistical", + "details": "Counts the number of cells within a range that meet the given criteria.", + "kind": "function" + }, + { + "trigger": "COUNTIFS", + "contents": "COUNTIFS", + "annotation": "Statistical", + "details": "Counts the number of cells within a range that meet multiple criteria.", + "kind": "function" + }, + { + "trigger": "COUPDAYBS", + "contents": "COUPDAYBS", + "annotation": "Financial", + "details": "Returns the number of days from the beginning of the coupon period to the settlement date.", + "kind": "function" + }, + { + "trigger": "COUPDAYS", + "contents": "COUPDAYS", + "annotation": "Financial", + "details": "Returns the number of days in the coupon period that contains the settlement date.", + "kind": "function" + }, + { + "trigger": "COUPDAYSNC", + "contents": "COUPDAYSNC", + "annotation": "Financial", + "details": "Returns the number of days from the settlement date to the next coupon date.", + "kind": "function" + }, + { + "trigger": "COUPNCD", + "contents": "COUPNCD", + "annotation": "Financial", + "details": "Returns the next coupon date after the settlement date.", + "kind": "function" + }, + { + "trigger": "COUPNUM", + "contents": "COUPNUM", + "annotation": "Financial", + "details": "Returns the number of coupons payable between the settlement date and maturity date.", + "kind": "function" + }, + { + "trigger": "COUPPCD", + "contents": "COUPPCD", + "annotation": "Financial", + "details": "Returns the previous coupon date before the settlement date.", + "kind": "function" + }, + { + "trigger": "COVAR", + "contents": "COVAR", + "annotation": "Compatibility", + "details": "Returns covariance, the average of the products of paired deviations. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "COVARIANCE.P", + "contents": "COVARIANCE.P", + "annotation": "Statistical", + "details": "Returns covariance, the average of the products of paired deviations.", + "kind": "function" + }, + { + "trigger": "COVARIANCE.S", + "contents": "COVARIANCE.S", + "annotation": "Statistical", + "details": "Returns the sample covariance, the average of the products deviations for each data point pair in two data sets.", + "kind": "function" + }, + { + "trigger": "CRITBINOM", + "contents": "CRITBINOM", + "annotation": "Compatibility", + "details": "Returns the smallest value for which the cumulative binomial distribution is less than or equal to a criterion value. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "CSC", + "contents": "CSC", + "annotation": "Math and trigonometry", + "details": "Returns the cosecant of an angle.", + "kind": "function" + }, + { + "trigger": "CSCH", + "contents": "CSCH", + "annotation": "Math and trigonometry", + "details": "Returns the hyperbolic cosecant of an angle.", + "kind": "function" + }, + { + "trigger": "CUBEKPIMEMBER", + "contents": "CUBEKPIMEMBER", + "annotation": "Cube", + "details": "Returns a key performance (KPI) name, property, and measure, and displays the name and property in the cell. A KPI is a quantifiable measurement, such as monthly gross profit or quarterly employee turnover, used to monitor an organization's performance.", + "kind": "function" + }, + { + "trigger": "CUBEMEMBER", + "contents": "CUBEMEMBER", + "annotation": "Cube", + "details": "Returns a member or tuple in a cube hierarchy. Use to validate that the member or tuple exists in the cube.", + "kind": "function" + }, + { + "trigger": "CUBEMEMBERPROPERTY", + "contents": "CUBEMEMBERPROPERTY", + "annotation": "Cube", + "details": "Returns the value of a member property in the cube. Use to validate that a member name exists within the cube and to return the specified property for this member.", + "kind": "function" + }, + { + "trigger": "CUBERANKEDMEMBER", + "contents": "CUBERANKEDMEMBER", + "annotation": "Cube", + "details": "Returns the nth, or ranked, member in a set. Use to return one or more elements in a set, such as the top sales performer or top 10 students.", + "kind": "function" + }, + { + "trigger": "CUBESET", + "contents": "CUBESET", + "annotation": "Cube", + "details": "Defines a calculated set of members or tuples by sending a set expression to the cube on the server, which creates the set, and then returns that set to Microsoft Office Excel.", + "kind": "function" + }, + { + "trigger": "CUBESETCOUNT", + "contents": "CUBESETCOUNT", + "annotation": "Cube", + "details": "Returns the number of items in a set.", + "kind": "function" + }, + { + "trigger": "CUBEVALUE", + "contents": "CUBEVALUE", + "annotation": "Cube", + "details": "Returns an aggregated value from a cube.", + "kind": "function" + }, + { + "trigger": "CUMIPMT", + "contents": "CUMIPMT", + "annotation": "Financial", + "details": "Returns the cumulative interest paid between two periods.", + "kind": "function" + }, + { + "trigger": "CUMPRINC", + "contents": "CUMPRINC", + "annotation": "Financial", + "details": "Returns the cumulative principal paid on a loan between two periods.", + "kind": "function" + }, + { + "trigger": "DATE", + "contents": "DATE", + "annotation": "Date and time", + "details": "Returns the serial number of a particular date.", + "kind": "function" + }, + { + "trigger": "DATEDIF", + "contents": "DATEDIF", + "annotation": "Date and time", + "details": "Calculates the number of days, months, or years between two dates. This is useful in formulas where you need to calculate an age.", + "kind": "function" + }, + { + "trigger": "DATEVALUE", + "contents": "DATEVALUE", + "annotation": "Date and time", + "details": "Converts a date in the form of text to a serial number.", + "kind": "function" + }, + { + "trigger": "DAVERAGE", + "contents": "DAVERAGE", + "annotation": "Database", + "details": "Returns the average of selected database entries.", + "kind": "function" + }, + { + "trigger": "DAY", + "contents": "DAY", + "annotation": "Date and time", + "details": "Converts a serial number to a day of the month.", + "kind": "function" + }, + { + "trigger": "DAYS", + "contents": "DAYS", + "annotation": "Date and time", + "details": "Returns the number of days between two dates.", + "kind": "function" + }, + { + "trigger": "DAYS360", + "contents": "DAYS360", + "annotation": "Date and time", + "details": "Calculates the number of days between two dates based on a 360-day year.", + "kind": "function" + }, + { + "trigger": "DB", + "contents": "DB", + "annotation": "Financial", + "details": "Returns the depreciation of an asset for a specified period by using the fixed-declining balance method.", + "kind": "function" + }, + { + "trigger": "DBCS", + "contents": "DBCS", + "annotation": "Text", + "details": "Changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters.", + "kind": "function" + }, + { + "trigger": "DCOUNT", + "contents": "DCOUNT", + "annotation": "Database", + "details": "Counts the cells that contain numbers in a database.", + "kind": "function" + }, + { + "trigger": "DCOUNTA", + "contents": "DCOUNTA", + "annotation": "Database", + "details": "Counts nonblank cells in a database.", + "kind": "function" + }, + { + "trigger": "DDB", + "contents": "DDB", + "annotation": "Financial", + "details": "Returns the depreciation of an asset for a specified period by using the double-declining balance method or some other method that you specify.", + "kind": "function" + }, + { + "trigger": "DEC2BIN", + "contents": "DEC2BIN", + "annotation": "Engineering", + "details": "Converts a decimal number to binary.", + "kind": "function" + }, + { + "trigger": "DEC2HEX", + "contents": "DEC2HEX", + "annotation": "Engineering", + "details": "Converts a decimal number to hexadecimal.", + "kind": "function" + }, + { + "trigger": "DEC2OCT", + "contents": "DEC2OCT", + "annotation": "Engineering", + "details": "Converts a decimal number to octal.", + "kind": "function" + }, + { + "trigger": "DECIMAL", + "contents": "DECIMAL", + "annotation": "Math and trigonometry", + "details": "Converts a text representation of a number in a given base into a decimal number.", + "kind": "function" + }, + { + "trigger": "DEGREES", + "contents": "DEGREES", + "annotation": "Math and trigonometry", + "details": "Converts radians to degrees.", + "kind": "function" + }, + { + "trigger": "DELTA", + "contents": "DELTA", + "annotation": "Engineering", + "details": "Tests whether two values are equal.", + "kind": "function" + }, + { + "trigger": "DEVSQ", + "contents": "DEVSQ", + "annotation": "Statistical", + "details": "Returns the sum of squares of deviations.", + "kind": "function" + }, + { + "trigger": "DGET", + "contents": "DGET", + "annotation": "Database", + "details": "Extracts from a database a single record that matches the specified criteria.", + "kind": "function" + }, + { + "trigger": "DISC", + "contents": "DISC", + "annotation": "Financial", + "details": "Returns the discount rate for a security.", + "kind": "function" + }, + { + "trigger": "DMAX", + "contents": "DMAX", + "annotation": "Database", + "details": "Returns the maximum value from selected database entries.", + "kind": "function" + }, + { + "trigger": "DMIN", + "contents": "DMIN", + "annotation": "Database", + "details": "Returns the minimum value from selected database entries.", + "kind": "function" + }, + { + "trigger": "DOLLAR", + "contents": "DOLLAR", + "annotation": "Text", + "details": "Converts a number to text, using the $ (dollar) currency format.", + "kind": "function" + }, + { + "trigger": "DOLLARDE", + "contents": "DOLLARDE", + "annotation": "Financial", + "details": "Converts a dollar price, expressed as a fraction, into a dollar price, expressed as a decimal number.", + "kind": "function" + }, + { + "trigger": "DOLLARFR", + "contents": "DOLLARFR", + "annotation": "Financial", + "details": "Converts a dollar price, expressed as a decimal number, into a dollar price, expressed as a fraction.", + "kind": "function" + }, + { + "trigger": "DPRODUCT", + "contents": "DPRODUCT", + "annotation": "Database", + "details": "Multiplies the values in a particular field of records that match the criteria in a database.", + "kind": "function" + }, + { + "trigger": "DROP", + "contents": "DROP", + "annotation": "Array", + "details": "Removes rows or columns from the start or end of an array.", + "kind": "function" + }, + { + "trigger": "DSTDEV", + "contents": "DSTDEV", + "annotation": "Database", + "details": "Estimates the standard deviation based on a sample of selected database entries.", + "kind": "function" + }, + { + "trigger": "DSTDEVP", + "contents": "DSTDEVP", + "annotation": "Database", + "details": "Calculates the standard deviation based on the entire population of selected database entries.", + "kind": "function" + }, + { + "trigger": "DSUM", + "contents": "DSUM", + "annotation": "Database", + "details": "Adds the numbers in the field column of records in the database that match the criteria.", + "kind": "function" + }, + { + "trigger": "DURATION", + "contents": "DURATION", + "annotation": "Financial", + "details": "Returns the annual duration of a security with periodic interest payments.", + "kind": "function" + }, + { + "trigger": "DVAR", + "contents": "DVAR", + "annotation": "Database", + "details": "Estimates variance based on a sample from selected database entries.", + "kind": "function" + }, + { + "trigger": "DVARP", + "contents": "DVARP", + "annotation": "Database", + "details": "Calculates variance based on the entire population of selected database entries.", + "kind": "function" + }, + { + "trigger": "EDATE", + "contents": "EDATE", + "annotation": "Date and time", + "details": "Returns the serial number of the date that is the indicated number of months before or after the start date.", + "kind": "function" + }, + { + "trigger": "EFFECT", + "contents": "EFFECT", + "annotation": "Financial", + "details": "Returns the effective annual interest rate.", + "kind": "function" + }, + { + "trigger": "ENCODEURL", + "contents": "ENCODEURL", + "annotation": "Web", + "details": "Returns a URL-encoded string. This function is not available in Excel Online.", + "kind": "function" + }, + { + "trigger": "EOMONTH", + "contents": "EOMONTH", + "annotation": "Date and time", + "details": "Returns the serial number of the last day of the month before or after a specified number of months.", + "kind": "function" + }, + { + "trigger": "ERF", + "contents": "ERF", + "annotation": "Engineering", + "details": "Returns the error function integrated between lower_limit and upper_limit.", + "kind": "function" + }, + { + "trigger": "ERF.PRECISE", + "contents": "ERF.PRECISE", + "annotation": "Engineering", + "details": "Returns the error function integrated between lower_limit and 0.", + "kind": "function" + }, + { + "trigger": "ERFC", + "contents": "ERFC", + "annotation": "Engineering", + "details": "Returns the complementary error function.", + "kind": "function" + }, + { + "trigger": "ERFC.PRECISE", + "contents": "ERFC.PRECISE", + "annotation": "Engineering", + "details": "Returns the complementary ERF function integrated between x and infinity.", + "kind": "function" + }, + { + "trigger": "ERROR.TYPE", + "contents": "ERROR.TYPE", + "annotation": "Information", + "details": "Returns a number corresponding to an error type.", + "kind": "function" + }, + { + "trigger": "EUROCONVERT", + "contents": "EUROCONVERT", + "annotation": "Add-in", + "details": "Converts a number to euros, from euros to euro member currency, or between euro member currencies using euro as intermediary.", + "kind": "function" + }, + { + "trigger": "EVEN", + "contents": "EVEN", + "annotation": "Math and trigonometry", + "details": "Rounds a number up to the nearest even integer.", + "kind": "function" + }, + { + "trigger": "EXACT", + "contents": "EXACT", + "annotation": "Text", + "details": "Checks to see if two text values are identical.", + "kind": "function" + }, + { + "trigger": "EXP", + "contents": "EXP", + "annotation": "Math and trigonometry", + "details": "Returns e raised to the power of a given number.", + "kind": "function" + }, + { + "trigger": "EXPAND", + "contents": "EXPAND", + "annotation": "Array", + "details": "Expands an array to the specified dimensions. ", + "kind": "function" + }, + { + "trigger": "EXPON.DIST", + "contents": "EXPON.DIST", + "annotation": "Statistical", + "details": "Returns the exponential distribution.", + "kind": "function" + }, + { + "trigger": "EXPONDIST", + "contents": "EXPONDIST", + "annotation": "Compatibility", + "details": "Returns the exponential. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "F.DIST", + "contents": "F.DIST", + "annotation": "Statistical", + "details": "Returns the (left-tailed) F probability distribution (degree of diversity) for two data sets.", + "kind": "function" + }, + { + "trigger": "F.DIST.RT", + "contents": "F.DIST.RT", + "annotation": "Statistical", + "details": "Returns the (right-tailed) F probability distribution (degree of diversity) for two data sets.", + "kind": "function" + }, + { + "trigger": "F.INV", + "contents": "F.INV", + "annotation": "Statistical", + "details": "Returns the inverse of the (left-tailed) F probability distribution.", + "kind": "function" + }, + { + "trigger": "F.INV.RT", + "contents": "F.INV.RT", + "annotation": "Statistical", + "details": "Returns the inverse of the (right-tailed) F probability distribution.", + "kind": "function" + }, + { + "trigger": "F.TEST", + "contents": "F.TEST", + "annotation": "Statistical", + "details": "Returns the result of an F-test.", + "kind": "function" + }, + { + "trigger": "FACT", + "contents": "FACT", + "annotation": "Math and trigonometry", + "details": "Returns the factorial of a number.", + "kind": "function" + }, + { + "trigger": "FACTDOUBLE", + "contents": "FACTDOUBLE", + "annotation": "Math and trigonometry", + "details": "Returns the double factorial of a number.", + "kind": "function" + }, + { + "trigger": "FDIST", + "contents": "FDIST", + "annotation": "Compatibility", + "details": "Returns the F probability. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "FILTER", + "contents": "FILTER", + "annotation": "Lookup and reference", + "details": "Filters a range of data based on criteria you define.", + "kind": "function" + }, + { + "trigger": "FILTERXML", + "contents": "FILTERXML", + "annotation": "Web", + "details": "Returns specific data from the XML content by using the specified XPath. This function is not available in Excel Online.", + "kind": "function" + }, + { + "trigger": "FIND", + "contents": "FIND", + "annotation": "Text", + "details": "Returns the position of a substring within a text string, case-sensitive.", + "kind": "function" + }, + { + "trigger": "FINDB", + "contents": "FINDB", + "annotation": "Text", + "details": "Returns the position of the last occurrence of a specified substring within a text string, counting by bytes.", + "kind": "function" + }, + { + "trigger": "FINV", + "contents": "FINV", + "annotation": "Compatibility", + "details": "Returns the inverse of the F probability distribution.", + "kind": "function" + }, + { + "trigger": "FISHER", + "contents": "FISHER", + "annotation": "Statistical", + "details": "Returns the Fisher transformation.", + "kind": "function" + }, + { + "trigger": "FISHERINV", + "contents": "FISHERINV", + "annotation": "Statistical", + "details": "Returns the inverse of the Fisher transformation.", + "kind": "function" + }, + { + "trigger": "FIXED", + "contents": "FIXED", + "annotation": "Text", + "details": "Formats a number as text with a fixed number of decimals.", + "kind": "function" + }, + { + "trigger": "FLOOR", + "contents": "FLOOR", + "annotation": "Compatibility", + "details": "Rounds a number down, toward zero. In Excel 2007 and Excel 2010, this is a Math and trigonometry function.. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "FLOOR.MATH", + "contents": "FLOOR.MATH", + "annotation": "Math and trigonometry", + "details": "Rounds a number down, to the nearest integer or to the nearest multiple of significance.", + "kind": "function" + }, + { + "trigger": "FLOOR.PRECISE", + "contents": "FLOOR.PRECISE", + "annotation": "Math and trigonometry", + "details": "Rounds a number the nearest integer or to the nearest multiple of significance. Regardless of the sign of the number, the number is rounded up.", + "kind": "function" + }, + { + "trigger": "FORECAST", + "contents": "FORECAST", + "annotation": "Statistical", + "details": "Returns a value along a linear trend. In Excel 2016, this function is replaced with FORECAST.LINEAR as part of the new Forecasting functions, but it's still available for compatibility with earlier versions.", + "kind": "function" + }, + { + "trigger": "FORECAST.ETS", + "contents": "FORECAST.ETS", + "annotation": "Statistical", + "details": "Returns a future value based on existing (historical) values by using the AAA version of the Exponential Smoothing (ETS) algorithm. This function isn't available in Excel 2016 for Mac.", + "kind": "function" + }, + { + "trigger": "FORECAST.ETS.CONFINT", + "contents": "FORECAST.ETS.CONFINT", + "annotation": "Statistical", + "details": "Returns a confidence interval for the forecast value at the specified target date. This function isn't available in Excel 2016 for Mac.", + "kind": "function" + }, + { + "trigger": "FORECAST.ETS.SEASONALITY", + "contents": "FORECAST.ETS.SEASONALITY", + "annotation": "Statistical", + "details": "Returns the length of the repetitive pattern Excel detects for the specified time series. This function isn't available in Excel 2016 for Mac.", + "kind": "function" + }, + { + "trigger": "FORECAST.ETS.STAT", + "contents": "FORECAST.ETS.STAT", + "annotation": "Statistical", + "details": "Returns a statistical value as a result of time series forecasting. This function isn't available in Excel 2016 for Mac.", + "kind": "function" + }, + { + "trigger": "FORECAST.LINEAR", + "contents": "FORECAST.LINEAR", + "annotation": "Statistical", + "details": "Returns a future value based on existing values. This function isn't available in Excel 2016 for Mac.", + "kind": "function" + }, + { + "trigger": "FORMULATEXT", + "contents": "FORMULATEXT", + "annotation": "Lookup and reference", + "details": "Returns the formula at the given reference as text.", + "kind": "function" + }, + { + "trigger": "FREQUENCY", + "contents": "FREQUENCY", + "annotation": "Statistical", + "details": "Returns a frequency distribution as a vertical array.", + "kind": "function" + }, + { + "trigger": "FTEST", + "contents": "FTEST", + "annotation": "Compatibility", + "details": "Returns the result of an F-test. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "FV", + "contents": "FV", + "annotation": "Financial", + "details": "Returns the future value of an investment.", + "kind": "function" + }, + { + "trigger": "FVSCHEDULE", + "contents": "FVSCHEDULE", + "annotation": "Financial", + "details": "Returns the future value of an initial principal after applying a series of compound interest rates.", + "kind": "function" + }, + { + "trigger": "GAMMA", + "contents": "GAMMA", + "annotation": "Statistical", + "details": "Returns the Gamma function value.", + "kind": "function" + }, + { + "trigger": "GAMMA.DIST", + "contents": "GAMMA.DIST", + "annotation": "Statistical", + "details": "Returns the gamma distribution.", + "kind": "function" + }, + { + "trigger": "GAMMA.INV", + "contents": "GAMMA.INV", + "annotation": "Statistical", + "details": "Returns the inverse of the gamma cumulative distribution.", + "kind": "function" + }, + { + "trigger": "GAMMADIST", + "contents": "GAMMADIST", + "annotation": "Compatibility", + "details": "Returns the gamma. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "GAMMAINV", + "contents": "GAMMAINV", + "annotation": "Compatibility", + "details": "Returns the inverse of the gamma cumulative. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "GAMMALN", + "contents": "GAMMALN", + "annotation": "Statistical", + "details": "Returns the natural logarithm of the gamma function, \u0393(x).", + "kind": "function" + }, + { + "trigger": "GAMMALN.PRECISE", + "contents": "GAMMALN.PRECISE", + "annotation": "Statistical", + "details": "Returns the natural logarithm of the gamma function, \u0393(x).", + "kind": "function" + }, + { + "trigger": "GAUSS", + "contents": "GAUSS", + "annotation": "Statistical", + "details": "Returns 0.5 less than the standard normal cumulative distribution.", + "kind": "function" + }, + { + "trigger": "GCD", + "contents": "GCD", + "annotation": "Math and trigonometry", + "details": "Returns the greatest common divisor.", + "kind": "function" + }, + { + "trigger": "GEOMEAN", + "contents": "GEOMEAN", + "annotation": "Statistical", + "details": "Returns the geometric mean.", + "kind": "function" + }, + { + "trigger": "GESTEP", + "contents": "GESTEP", + "annotation": "Engineering", + "details": "Tests whether a number is greater than a threshold value.", + "kind": "function" + }, + { + "trigger": "GETPIVOTDATA", + "contents": "GETPIVOTDATA", + "annotation": "Add-in and Automation", + "details": "Returns data stored in a PivotTable report.", + "kind": "function" + }, + { + "trigger": "GROWTH", + "contents": "GROWTH", + "annotation": "Statistical", + "details": "Returns values along an exponential trend.", + "kind": "function" + }, + { + "trigger": "HARMEAN", + "contents": "HARMEAN", + "annotation": "Statistical", + "details": "Returns the harmonic mean.", + "kind": "function" + }, + { + "trigger": "HEX2BIN", + "contents": "HEX2BIN", + "annotation": "Engineering", + "details": "Converts a hexadecimal number to binary.", + "kind": "function" + }, + { + "trigger": "HEX2DEC", + "contents": "HEX2DEC", + "annotation": "Engineering", + "details": "Converts a hexadecimal number to decimal.", + "kind": "function" + }, + { + "trigger": "HEX2OCT", + "contents": "HEX2OCT", + "annotation": "Engineering", + "details": "Converts a hexadecimal number to octal.", + "kind": "function" + }, + { + "trigger": "HLOOKUP", + "contents": "HLOOKUP", + "annotation": "Lookup and reference", + "details": "Looks in the top row of an array and returns the value of the indicated cell.", + "kind": "function" + }, + { + "trigger": "HOUR", + "contents": "HOUR", + "annotation": "Date and time", + "details": "Converts a serial number to an hour.", + "kind": "function" + }, + { + "trigger": "HSTACK", + "contents": "HSTACK", + "annotation": "Array", + "details": "Horizontally combine arrays into one array.", + "kind": "function" + }, + { + "trigger": "HYPERLINK", + "contents": "HYPERLINK", + "annotation": "Lookup and reference", + "details": "Creates a shortcut or jump that opens a document stored on a network server, an intranet, or the Internet.", + "kind": "function" + }, + { + "trigger": "HYPGEOM.DIST", + "contents": "HYPGEOM.DIST", + "annotation": "Statistical", + "details": "Returns the hypergeometric distribution.", + "kind": "function" + }, + { + "trigger": "HYPGEOMDIST", + "contents": "HYPGEOMDIST", + "annotation": "Compatibility", + "details": "Returns the hypergeometric. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "IF", + "contents": "IF", + "annotation": "Logical", + "details": "Specifies a logical test to perform.", + "kind": "function" + }, + { + "trigger": "IFERROR", + "contents": "IFERROR", + "annotation": "Logical", + "details": "Returns a value you specify if a formula evaluates to an error.", + "kind": "function" + }, + { + "trigger": "IFNA", + "contents": "IFNA", + "annotation": "Logical", + "details": "Returns the value you specify if the expression resolves to #N/A, otherwise. Returns the result of the expression.", + "kind": "function" + }, + { + "trigger": "IFS", + "contents": "IFS", + "annotation": "Logical", + "details": "Checks whether one or more conditions are met and returns a value that corresponds to the first TRUE condition. This function isn't available in Excel 2016 for Mac.", + "kind": "function" + }, + { + "trigger": "IMABS", + "contents": "IMABS", + "annotation": "Engineering", + "details": "Returns the absolute value (modulus) of a complex number.", + "kind": "function" + }, + { + "trigger": "IMAGE", + "contents": "IMAGE", + "annotation": "Lookup and reference", + "details": "Returns an image from a given source.", + "kind": "function" + }, + { + "trigger": "IMAGINARY", + "contents": "IMAGINARY", + "annotation": "Engineering", + "details": "Returns the imaginary coefficient of a complex number.", + "kind": "function" + }, + { + "trigger": "IMARGUMENT", + "contents": "IMARGUMENT", + "annotation": "Engineering", + "details": "Returns the argument theta, an angle expressed in radians.", + "kind": "function" + }, + { + "trigger": "IMCONJUGATE", + "contents": "IMCONJUGATE", + "annotation": "Engineering", + "details": "Returns the complex conjugate of a complex number.", + "kind": "function" + }, + { + "trigger": "IMCOS", + "contents": "IMCOS", + "annotation": "Engineering", + "details": "Returns the cosine of a complex number.", + "kind": "function" + }, + { + "trigger": "IMCOSH", + "contents": "IMCOSH", + "annotation": "Engineering", + "details": "Returns the hyperbolic cosine of a complex number.", + "kind": "function" + }, + { + "trigger": "IMCOT", + "contents": "IMCOT", + "annotation": "Engineering", + "details": "Returns the cotangent of a complex number.", + "kind": "function" + }, + { + "trigger": "IMCSC", + "contents": "IMCSC", + "annotation": "Engineering", + "details": "Returns the cosecant of a complex number.", + "kind": "function" + }, + { + "trigger": "IMCSCH", + "contents": "IMCSCH", + "annotation": "Engineering", + "details": "Returns the hyperbolic cosecant of a complex number.", + "kind": "function" + }, + { + "trigger": "IMDIV", + "contents": "IMDIV", + "annotation": "Engineering", + "details": "Returns the quotient of two complex numbers.", + "kind": "function" + }, + { + "trigger": "IMEXP", + "contents": "IMEXP", + "annotation": "Engineering", + "details": "Returns the exponential of a complex number.", + "kind": "function" + }, + { + "trigger": "IMLN", + "contents": "IMLN", + "annotation": "Engineering", + "details": "Returns the natural logarithm of a complex number.", + "kind": "function" + }, + { + "trigger": "IMLOG10", + "contents": "IMLOG10", + "annotation": "Engineering", + "details": "Returns the base-10 logarithm of a complex number.", + "kind": "function" + }, + { + "trigger": "IMLOG2", + "contents": "IMLOG2", + "annotation": "Engineering", + "details": "Returns the base-2 logarithm of a complex number.", + "kind": "function" + }, + { + "trigger": "IMPOWER", + "contents": "IMPOWER", + "annotation": "Engineering", + "details": "Returns a complex number raised to an integer power.", + "kind": "function" + }, + { + "trigger": "IMPRODUCT", + "contents": "IMPRODUCT", + "annotation": "Engineering", + "details": "Returns the product of complex numbers.", + "kind": "function" + }, + { + "trigger": "IMREAL", + "contents": "IMREAL", + "annotation": "Engineering", + "details": "Returns the real coefficient of a complex number.", + "kind": "function" + }, + { + "trigger": "IMSEC", + "contents": "IMSEC", + "annotation": "Engineering", + "details": "Returns the secant of a complex number.", + "kind": "function" + }, + { + "trigger": "IMSECH", + "contents": "IMSECH", + "annotation": "Engineering", + "details": "Returns the hyperbolic secant of a complex number.", + "kind": "function" + }, + { + "trigger": "IMSIN", + "contents": "IMSIN", + "annotation": "Engineering", + "details": "Returns the sine of a complex number.", + "kind": "function" + }, + { + "trigger": "IMSINH", + "contents": "IMSINH", + "annotation": "Engineering", + "details": "Returns the hyperbolic sine of a complex number.", + "kind": "function" + }, + { + "trigger": "IMSQRT", + "contents": "IMSQRT", + "annotation": "Engineering", + "details": "Returns the square root of a complex number.", + "kind": "function" + }, + { + "trigger": "IMSUB", + "contents": "IMSUB", + "annotation": "Engineering", + "details": "Returns the difference between two complex numbers.", + "kind": "function" + }, + { + "trigger": "IMSUM", + "contents": "IMSUM", + "annotation": "Engineering", + "details": "Returns the sum of complex numbers.", + "kind": "function" + }, + { + "trigger": "IMTAN", + "contents": "IMTAN", + "annotation": "Engineering", + "details": "Returns the tangent of a complex number.", + "kind": "function" + }, + { + "trigger": "INDEX", + "contents": "INDEX", + "annotation": "Lookup and reference", + "details": "Uses an index to choose a value from a reference or array.", + "kind": "function" + }, + { + "trigger": "INDIRECT", + "contents": "INDIRECT", + "annotation": "Lookup and reference", + "details": "Returns a reference indicated by a text value.", + "kind": "function" + }, + { + "trigger": "INFO", + "contents": "INFO", + "annotation": "Information", + "details": "Returns information about the current operating environment. This function is not available in Excel Online.", + "kind": "function" + }, + { + "trigger": "INT", + "contents": "INT", + "annotation": "Math and trigonometry", + "details": "Rounds a number down to the nearest integer.", + "kind": "function" + }, + { + "trigger": "INTERCEPT", + "contents": "INTERCEPT", + "annotation": "Statistical", + "details": "Returns the intercept of the linear regression line.", + "kind": "function" + }, + { + "trigger": "INTRATE", + "contents": "INTRATE", + "annotation": "Financial", + "details": "Returns the interest rate for a fully invested security.", + "kind": "function" + }, + { + "trigger": "IPMT", + "contents": "IPMT", + "annotation": "Financial", + "details": "Returns the interest payment for an investment for a given period.", + "kind": "function" + }, + { + "trigger": "IRR", + "contents": "IRR", + "annotation": "Financial", + "details": "Returns the internal rate of return for a series of cash flows.", + "kind": "function" + }, + { + "trigger": "ISBLANK", + "contents": "ISBLANK", + "annotation": "Information", + "details": "Returns TRUE if the value is blank.", + "kind": "function" + }, + { + "trigger": "ISERR", + "contents": "ISERR", + "annotation": "Information", + "details": "Returns TRUE if the value is any error value except #N/A.", + "kind": "function" + }, + { + "trigger": "ISERROR", + "contents": "ISERROR", + "annotation": "Information", + "details": "Returns TRUE if the value is any error value.", + "kind": "function" + }, + { + "trigger": "ISEVEN", + "contents": "ISEVEN", + "annotation": "Information", + "details": "Returns TRUE if the number is even.", + "kind": "function" + }, + { + "trigger": "ISFORMULA", + "contents": "ISFORMULA", + "annotation": "Information", + "details": "Returns TRUE if there is a reference to a cell that contains a formula.", + "kind": "function" + }, + { + "trigger": "ISLOGICAL", + "contents": "ISLOGICAL", + "annotation": "Information", + "details": "Returns TRUE if the value is a logical value.", + "kind": "function" + }, + { + "trigger": "ISNA", + "contents": "ISNA", + "annotation": "Information", + "details": "Returns TRUE if the value is the #N/A error value.", + "kind": "function" + }, + { + "trigger": "ISNONTEXT", + "contents": "ISNONTEXT", + "annotation": "Information", + "details": "Returns TRUE if the value is not text.", + "kind": "function" + }, + { + "trigger": "ISNUMBER", + "contents": "ISNUMBER", + "annotation": "Information", + "details": "Returns TRUE if the value is a number.", + "kind": "function" + }, + { + "trigger": "ISO.CEILING", + "contents": "ISO.CEILING", + "annotation": "Math and trigonometry", + "details": "Returns a number that is rounded up to the nearest integer or to the nearest multiple of significance.", + "kind": "function" + }, + { + "trigger": "ISODD", + "contents": "ISODD", + "annotation": "Information", + "details": "Returns TRUE if the number is odd.", + "kind": "function" + }, + { + "trigger": "ISOMITTED", + "contents": "ISOMITTED", + "annotation": "Information", + "details": "Checks whether the value is omitted, and returns TRUE or FALSE.", + "kind": "function" + }, + { + "trigger": "ISOWEEKNUM", + "contents": "ISOWEEKNUM", + "annotation": "Date and time", + "details": "Returns the number of the ISO week number of the year for a given date.", + "kind": "function" + }, + { + "trigger": "ISPMT", + "contents": "ISPMT", + "annotation": "Financial", + "details": "Calculates the interest paid during a specific period of an investment.", + "kind": "function" + }, + { + "trigger": "ISREF", + "contents": "ISREF", + "annotation": "Information", + "details": "Returns TRUE if the value is a reference.", + "kind": "function" + }, + { + "trigger": "ISTEXT", + "contents": "ISTEXT", + "annotation": "Information", + "details": "Returns TRUE if the value is text.", + "kind": "function" + }, + { + "trigger": "JIS", + "contents": "JIS", + "annotation": "Text", + "details": "Changes half-width characters to full-width characters.", + "kind": "function" + }, + { + "trigger": "KURT", + "contents": "KURT", + "annotation": "Statistical", + "details": "Returns the kurtosis of a data set.", + "kind": "function" + }, + { + "trigger": "LAMBDA", + "contents": "LAMBDA", + "annotation": "Formulas", + "details": "Creates a function value, which can be called within formulas.", + "kind": "function" + }, + { + "trigger": "LARGE", + "contents": "LARGE", + "annotation": "Statistical", + "details": "Returns the k-th largest value in a data set.", + "kind": "function" + }, + { + "trigger": "LCM", + "contents": "LCM", + "annotation": "Math and trigonometry", + "details": "Returns the least common multiple.", + "kind": "function" + }, + { + "trigger": "LEFT", + "contents": "LEFT", + "annotation": "Text", + "details": "Extracts a specified number of characters from the start (left) of a text string.", + "kind": "function" + }, + { + "trigger": "LEFTB", + "contents": "LEFTB", + "annotation": "Text", + "details": "Returns the first character or characters in a text string based on bytes.", + "kind": "function" + }, + { + "trigger": "LEN", + "contents": "LEN", + "annotation": "Text", + "details": "Returns the total number of characters in a text string, including spaces.", + "kind": "function" + }, + { + "trigger": "LENB", + "contents": "LENB", + "annotation": "Text", + "details": "Returns the number of bytes used to represent a string.", + "kind": "function" + }, + { + "trigger": "LET", + "contents": "LET", + "annotation": "Formulas", + "details": "Assigns names to calculation results to allow storing intermediate calculations, values, or defining names inside a formula", + "kind": "function" + }, + { + "trigger": "LINEST", + "contents": "LINEST", + "annotation": "Statistical", + "details": "Returns the parameters of a linear trend.", + "kind": "function" + }, + { + "trigger": "LN", + "contents": "LN", + "annotation": "Math and trigonometry", + "details": "Returns the natural logarithm of a number.", + "kind": "function" + }, + { + "trigger": "LOG", + "contents": "LOG", + "annotation": "Math and trigonometry", + "details": "Returns the logarithm of a number to a specified base.", + "kind": "function" + }, + { + "trigger": "LOG10", + "contents": "LOG10", + "annotation": "Math and trigonometry", + "details": "Returns the base-10 logarithm of a number.", + "kind": "function" + }, + { + "trigger": "LOGEST", + "contents": "LOGEST", + "annotation": "Statistical", + "details": "Returns the parameters of an exponential trend.", + "kind": "function" + }, + { + "trigger": "LOGINV", + "contents": "LOGINV", + "annotation": "Compatibility", + "details": "Returns the inverse of the lognormal cumulative distribution. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "LOGNORM.DIST", + "contents": "LOGNORM.DIST", + "annotation": "Statistical", + "details": "Returns the lognormal distribution of x, where ln(x) is normally distributed with parameters Mean and Standard_dev.", + "kind": "function" + }, + { + "trigger": "LOGNORM.INV", + "contents": "LOGNORM.INV", + "annotation": "Statistical", + "details": "Returns the inverse of the lognormal cumulative distribution function of x, where ln(x) is normally distributed with parameters Mean and Standard_dev.", + "kind": "function" + }, + { + "trigger": "LOGNORMDIST", + "contents": "LOGNORMDIST", + "annotation": "Compatibility", + "details": "Returns the cumulative lognormal distribution. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "LOOKUP", + "contents": "LOOKUP", + "annotation": "Lookup and reference", + "details": "Looks up values in a vector or array.", + "kind": "function" + }, + { + "trigger": "LOWER", + "contents": "LOWER", + "annotation": "Text", + "details": "Converts text to lowercase.", + "kind": "function" + }, + { + "trigger": "MAKEARRAY", + "contents": "MAKEARRAY", + "annotation": "Array", + "details": "Returns a calculated array of a specified row and column size, by applying a LAMBDA function.", + "kind": "function" + }, + { + "trigger": "MAP", + "contents": "MAP", + "annotation": "Array", + "details": "Returns an array formed by 'mapping' each value in the array(s) to a new value by applying a lambda to create a new value.", + "kind": "function" + }, + { + "trigger": "MATCH", + "contents": "MATCH", + "annotation": "Lookup and reference", + "details": "Looks up values in a reference or array.", + "kind": "function" + }, + { + "trigger": "MAX", + "contents": "MAX", + "annotation": "Statistical", + "details": "Returns the maximum value in a list of arguments.", + "kind": "function" + }, + { + "trigger": "MAXA", + "contents": "MAXA", + "annotation": "Statistical", + "details": "Returns the maximum value in a list of arguments, including numbers, text, and logical values.", + "kind": "function" + }, + { + "trigger": "MAXIFS", + "contents": "MAXIFS", + "annotation": "Statistical", + "details": "Returns the maximum value among cells specified by a given set of conditions or criteria. This function isn't available in Excel 2016 for Mac.", + "kind": "function" + }, + { + "trigger": "MDETERM", + "contents": "MDETERM", + "annotation": "Math and trigonometry", + "details": "Returns the matrix determinant of an array.", + "kind": "function" + }, + { + "trigger": "MDURATION", + "contents": "MDURATION", + "annotation": "Financial", + "details": "Returns the Macauley modified duration for a security with an assumed par value of $100.", + "kind": "function" + }, + { + "trigger": "MEDIAN", + "contents": "MEDIAN", + "annotation": "Statistical", + "details": "Returns the median of the given numbers.", + "kind": "function" + }, + { + "trigger": "MID", + "contents": "MID", + "annotation": "Text", + "details": "Extracts a substring from a text string, starting at a specified position for a given length.", + "kind": "function" + }, + { + "trigger": "MIDB", + "contents": "MIDB", + "annotation": "Text", + "details": "Returns a specific number of bytes from a text string, starting at a specified position.", + "kind": "function" + }, + { + "trigger": "MIN", + "contents": "MIN", + "annotation": "Statistical", + "details": "Returns the minimum value in a list of arguments.", + "kind": "function" + }, + { + "trigger": "MINA", + "contents": "MINA", + "annotation": "Statistical", + "details": "Returns the smallest value in a list of arguments, including numbers, text, and logical values.", + "kind": "function" + }, + { + "trigger": "MINIFS", + "contents": "MINIFS", + "annotation": "Statistical", + "details": "Returns the minimum value among cells specified by a given set of conditions or criteria. This function isn't available in Excel 2016 for Mac.", + "kind": "function" + }, + { + "trigger": "MINUTE", + "contents": "MINUTE", + "annotation": "Date and time", + "details": "Converts a serial number to a minute.", + "kind": "function" + }, + { + "trigger": "MINVERSE", + "contents": "MINVERSE", + "annotation": "Math and trigonometry", + "details": "Returns the matrix inverse of an array.", + "kind": "function" + }, + { + "trigger": "MIRR", + "contents": "MIRR", + "annotation": "Financial", + "details": "Returns the internal rate of return where positive and negative cash flows are financed at different rates.", + "kind": "function" + }, + { + "trigger": "MMULT", + "contents": "MMULT", + "annotation": "Math and trigonometry", + "details": "Returns the matrix product of two arrays.", + "kind": "function" + }, + { + "trigger": "MOD", + "contents": "MOD", + "annotation": "Math and trigonometry", + "details": "Returns the remainder from division.", + "kind": "function" + }, + { + "trigger": "MODE", + "contents": "MODE", + "annotation": "Compatibility", + "details": "Returns the most common value in a data set. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "MODE.MULT", + "contents": "MODE.MULT", + "annotation": "Statistical", + "details": "Returns a vertical array of the most frequently occurring, or repetitive values in an array or range of data.", + "kind": "function" + }, + { + "trigger": "MODE.SNGL", + "contents": "MODE.SNGL", + "annotation": "Statistical", + "details": "Returns the most common value in a data set.", + "kind": "function" + }, + { + "trigger": "MONTH", + "contents": "MONTH", + "annotation": "Date and time", + "details": "Converts a serial number to a month.", + "kind": "function" + }, + { + "trigger": "MROUND", + "contents": "MROUND", + "annotation": "Math and trigonometry", + "details": "Returns a number rounded to the desired multiple.", + "kind": "function" + }, + { + "trigger": "MULTINOMIAL", + "contents": "MULTINOMIAL", + "annotation": "Math and trigonometry", + "details": "Returns the multinomial of a set of numbers.", + "kind": "function" + }, + { + "trigger": "MUNIT", + "contents": "MUNIT", + "annotation": "Math and trigonometry", + "details": "Returns the unit matrix or the specified dimension.", + "kind": "function" + }, + { + "trigger": "N", + "contents": "N", + "annotation": "Information", + "details": "Returns a value converted to a number.", + "kind": "function" + }, + { + "trigger": "NA", + "contents": "NA", + "annotation": "Information", + "details": "Returns the error value #N/A.", + "kind": "function" + }, + { + "trigger": "NEGBINOM.DIST", + "contents": "NEGBINOM.DIST", + "annotation": "Statistical", + "details": "Returns the negative binomial distribution.", + "kind": "function" + }, + { + "trigger": "NEGBINOMDIST", + "contents": "NEGBINOMDIST", + "annotation": "Compatibility", + "details": "Returns the negative binomial. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "NETWORKDAYS", + "contents": "NETWORKDAYS", + "annotation": "Date and time", + "details": "Returns the number of whole workdays between two dates.", + "kind": "function" + }, + { + "trigger": "NETWORKDAYS.INTL", + "contents": "NETWORKDAYS.INTL", + "annotation": "Date and time", + "details": "Returns the number of whole workdays between two dates using parameters to indicate which and how many days are weekend days.", + "kind": "function" + }, + { + "trigger": "NOMINAL", + "contents": "NOMINAL", + "annotation": "Financial", + "details": "Returns the annual nominal interest rate.", + "kind": "function" + }, + { + "trigger": "NORM.DIST", + "contents": "NORM.DIST", + "annotation": "Statistical", + "details": "Returns the normal cumulative distribution.", + "kind": "function" + }, + { + "trigger": "NORM.INV", + "contents": "NORM.INV", + "annotation": "Compatibility", + "details": "Returns the inverse of the normal cumulative. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "NORM.S.DIST", + "contents": "NORM.S.DIST", + "annotation": "Statistical", + "details": "Returns the standard normal cumulative distribution.", + "kind": "function" + }, + { + "trigger": "NORM.S.INV", + "contents": "NORM.S.INV", + "annotation": "Statistical", + "details": "Returns the inverse of the standard normal cumulative distribution.", + "kind": "function" + }, + { + "trigger": "NORMDIST", + "contents": "NORMDIST", + "annotation": "Compatibility", + "details": "Returns the normal cumulative. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "NORMINV", + "contents": "NORMINV", + "annotation": "Statistical", + "details": "Returns the inverse of the normal cumulative distribution.", + "kind": "function" + }, + { + "trigger": "NORMSDIST", + "contents": "NORMSDIST", + "annotation": "Compatibility", + "details": "Returns the standard normal cumulative. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "NORMSINV", + "contents": "NORMSINV", + "annotation": "Compatibility", + "details": "Returns the inverse of the standard normal cumulative. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "NOT", + "contents": "NOT", + "annotation": "Logical", + "details": "Reverses the logic of its argument.", + "kind": "function" + }, + { + "trigger": "NOW", + "contents": "NOW", + "annotation": "Date and time", + "details": "Returns the serial number of the current date and time.", + "kind": "function" + }, + { + "trigger": "NPER", + "contents": "NPER", + "annotation": "Financial", + "details": "Returns the number of periods for an investment.", + "kind": "function" + }, + { + "trigger": "NPV", + "contents": "NPV", + "annotation": "Financial", + "details": "Returns the net present value of an investment based on a series of periodic cash flows and a discount rate.", + "kind": "function" + }, + { + "trigger": "NUMBERVALUE", + "contents": "NUMBERVALUE", + "annotation": "Text", + "details": "Converts text to number in a locale-independent manner.", + "kind": "function" + }, + { + "trigger": "OCT2BIN", + "contents": "OCT2BIN", + "annotation": "Engineering", + "details": "Converts an octal number to binary.", + "kind": "function" + }, + { + "trigger": "OCT2DEC", + "contents": "OCT2DEC", + "annotation": "Engineering", + "details": "Converts an octal number to decimal.", + "kind": "function" + }, + { + "trigger": "OCT2HEX", + "contents": "OCT2HEX", + "annotation": "Engineering", + "details": "Converts an octal number to hexadecimal.", + "kind": "function" + }, + { + "trigger": "ODD", + "contents": "ODD", + "annotation": "Math and trigonometry", + "details": "Rounds a number up to the nearest odd integer.", + "kind": "function" + }, + { + "trigger": "ODDFPRICE", + "contents": "ODDFPRICE", + "annotation": "Financial", + "details": "Returns the price per $100 face value of a security with an odd first period.", + "kind": "function" + }, + { + "trigger": "ODDFYIELD", + "contents": "ODDFYIELD", + "annotation": "Financial", + "details": "Returns the yield of a security with an odd first period.", + "kind": "function" + }, + { + "trigger": "ODDLPRICE", + "contents": "ODDLPRICE", + "annotation": "Financial", + "details": "Returns the price per $100 face value of a security with an odd last period.", + "kind": "function" + }, + { + "trigger": "ODDLYIELD", + "contents": "ODDLYIELD", + "annotation": "Financial", + "details": "Returns the yield of a security with an odd last period.", + "kind": "function" + }, + { + "trigger": "OFFSET", + "contents": "OFFSET", + "annotation": "Lookup and reference", + "details": "Returns a reference offset from a given reference.", + "kind": "function" + }, + { + "trigger": "OR", + "contents": "OR", + "annotation": "Logical", + "details": "Returns TRUE if any argument is TRUE.", + "kind": "function" + }, + { + "trigger": "PDURATION", + "contents": "PDURATION", + "annotation": "Financial", + "details": "Returns the number of periods required by an investment to reach a specified value.", + "kind": "function" + }, + { + "trigger": "PEARSON", + "contents": "PEARSON", + "annotation": "Statistical", + "details": "Returns the Pearson product moment correlation coefficient.", + "kind": "function" + }, + { + "trigger": "PERCENTILE", + "contents": "PERCENTILE", + "annotation": "Compatibility", + "details": "Returns the k-th percentile of values in a range. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "PERCENTILE.EXC", + "contents": "PERCENTILE.EXC", + "annotation": "Statistical", + "details": "Returns the k-th percentile of values in a range, where k is in the range 0..1, exclusive.", + "kind": "function" + }, + { + "trigger": "PERCENTILE.INC", + "contents": "PERCENTILE.INC", + "annotation": "Statistical", + "details": "Returns the k-th percentile of values in a range.", + "kind": "function" + }, + { + "trigger": "PERCENTRANK", + "contents": "PERCENTRANK", + "annotation": "Compatibility", + "details": "Returns the percentage rank of a value in a data set. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "PERCENTRANK.EXC", + "contents": "PERCENTRANK.EXC", + "annotation": "Statistical", + "details": "Returns the rank of a value in a data set as a percentage (0..1, exclusive) of the data set.", + "kind": "function" + }, + { + "trigger": "PERCENTRANK.INC", + "contents": "PERCENTRANK.INC", + "annotation": "Statistical", + "details": "Returns the percentage rank of a value in a data set.", + "kind": "function" + }, + { + "trigger": "PERMUT", + "contents": "PERMUT", + "annotation": "Statistical", + "details": "Returns the number of permutations for a given number of objects.", + "kind": "function" + }, + { + "trigger": "PERMUTATIONA", + "contents": "PERMUTATIONA", + "annotation": "Statistical", + "details": "Returns the number of permutations for a given number of objects (with repetitions) that can be selected from the total objects.", + "kind": "function" + }, + { + "trigger": "PHI", + "contents": "PHI", + "annotation": "Statistical", + "details": "Returns the value of the density function for a standard normal distribution.", + "kind": "function" + }, + { + "trigger": "PHONETIC", + "contents": "PHONETIC", + "annotation": "Text", + "details": "Extracts the phonetic (furigana) characters from a text string.", + "kind": "function" + }, + { + "trigger": "PI", + "contents": "PI", + "annotation": "Math and trigonometry", + "details": "Returns the value of pi.", + "kind": "function" + }, + { + "trigger": "PMT", + "contents": "PMT", + "annotation": "Financial", + "details": "Returns the periodic payment for an annuity.", + "kind": "function" + }, + { + "trigger": "POISSON", + "contents": "POISSON", + "annotation": "Compatibility", + "details": "Returns the Poisson. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "POISSON.DIST", + "contents": "POISSON.DIST", + "annotation": "Statistical", + "details": "Returns the Poisson distribution.", + "kind": "function" + }, + { + "trigger": "POWER", + "contents": "POWER", + "annotation": "Math and trigonometry", + "details": "Returns the result of a number raised to a power.", + "kind": "function" + }, + { + "trigger": "PPMT", + "contents": "PPMT", + "annotation": "Financial", + "details": "Returns the payment on the principal for an investment for a given period.", + "kind": "function" + }, + { + "trigger": "PRICE", + "contents": "PRICE", + "annotation": "Financial", + "details": "Returns the price per $100 face value of a security that pays periodic interest.", + "kind": "function" + }, + { + "trigger": "PRICEDISC", + "contents": "PRICEDISC", + "annotation": "Financial", + "details": "Returns the price per $100 face value of a discounted security.", + "kind": "function" + }, + { + "trigger": "PRICEMAT", + "contents": "PRICEMAT", + "annotation": "Financial", + "details": "Returns the price per $100 face value of a security that pays interest at maturity.", + "kind": "function" + }, + { + "trigger": "PROB", + "contents": "PROB", + "annotation": "Statistical", + "details": "Returns the probability that values in a range are between two limits.", + "kind": "function" + }, + { + "trigger": "PRODUCT", + "contents": "PRODUCT", + "annotation": "Math and trigonometry", + "details": "Multiplies its arguments.", + "kind": "function" + }, + { + "trigger": "PROPER", + "contents": "PROPER", + "annotation": "Text", + "details": "Capitalizes the first letter in each word of a text value.", + "kind": "function" + }, + { + "trigger": "PV", + "contents": "PV", + "annotation": "Financial", + "details": "Returns the present value of an investment.", + "kind": "function" + }, + { + "trigger": "QUARTILE", + "contents": "QUARTILE", + "annotation": "Compatibility", + "details": "Returns the quartile of a data set. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "QUARTILE.EXC", + "contents": "QUARTILE.EXC", + "annotation": "Statistical", + "details": "Returns the quartile of the data set, based on percentile values from 0..1, exclusive.", + "kind": "function" + }, + { + "trigger": "QUARTILE.INC", + "contents": "QUARTILE.INC", + "annotation": "Statistical", + "details": "Returns the quartile of a data set.", + "kind": "function" + }, + { + "trigger": "QUOTIENT", + "contents": "QUOTIENT", + "annotation": "Math and trigonometry", + "details": "Returns the integer portion of a division.", + "kind": "function" + }, + { + "trigger": "RADIANS", + "contents": "RADIANS", + "annotation": "Math and trigonometry", + "details": "Converts degrees to radians.", + "kind": "function" + }, + { + "trigger": "RAND", + "contents": "RAND", + "annotation": "Math and trigonometry", + "details": "Returns a random number between 0 and 1.", + "kind": "function" + }, + { + "trigger": "RANDARRAY", + "contents": "RANDARRAY", + "annotation": "Math and trigonometry", + "details": "Returns an array of random numbers between 0 and 1. However, you can specify the number of rows and columns to fill, minimum and maximum values, and whether to return whole numbers or decimal values.", + "kind": "function" + }, + { + "trigger": "RANDBETWEEN", + "contents": "RANDBETWEEN", + "annotation": "Math and trigonometry", + "details": "Returns a random number between the numbers you specify.", + "kind": "function" + }, + { + "trigger": "RANK", + "contents": "RANK", + "annotation": "Compatibility", + "details": "Returns the rank of a number in a list of numbers. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "RANK.AVG", + "contents": "RANK.AVG", + "annotation": "Statistical", + "details": "Returns the rank of a number in a list of numbers. Ties take the average rank.", + "kind": "function" + }, + { + "trigger": "RANK.EQ", + "contents": "RANK.EQ", + "annotation": "Statistical", + "details": "Returns the rank of a number in a list of numbers. Ties take the top rank.", + "kind": "function" + }, + { + "trigger": "RATE", + "contents": "RATE", + "annotation": "Financial", + "details": "Returns the interest rate per period of an annuity.", + "kind": "function" + }, + { + "trigger": "RECEIVED", + "contents": "RECEIVED", + "annotation": "Financial", + "details": "Returns the amount received at maturity for a fully invested security.", + "kind": "function" + }, + { + "trigger": "REDUCE", + "contents": "REDUCE", + "annotation": "Array", + "details": "Reduces an array to an accumulated value by applying a LAMBDA function to each value and returning the total value in the accumulator.", + "kind": "function" + }, + { + "trigger": "REGISTER", + "contents": "REGISTER", + "annotation": "Add-in", + "details": "Returns a reference to the spcified DLL or code resource.", + "kind": "function" + }, + { + "trigger": "REGISTER.ID", + "contents": "REGISTER.ID", + "annotation": "Add-in", + "details": "Returns the register ID of the specified DLL or code resource.", + "kind": "function" + }, + { + "trigger": "REPLACE", + "contents": "REPLACE", + "annotation": "Text", + "details": "Replaces part of a text string with another string, based on a given start position and length.", + "kind": "function" + }, + { + "trigger": "REPLACEB", + "contents": "REPLACEB", + "annotation": "Text", + "details": "Replaces a specified number of bytes in a text string with another text string.", + "kind": "function" + }, + { + "trigger": "REPT", + "contents": "REPT", + "annotation": "Text", + "details": "Repeats text a given number of times.", + "kind": "function" + }, + { + "trigger": "RIGHT", + "contents": "RIGHT", + "annotation": "Text", + "details": "Extracts a specified number of characters from the end (right) of a text string.", + "kind": "function" + }, + { + "trigger": "RIGHTB", + "contents": "RIGHTB", + "annotation": "Text", + "details": "Returns the last character or characters in a text string based on bytes.", + "kind": "function" + }, + { + "trigger": "ROMAN", + "contents": "ROMAN", + "annotation": "Math and trigonometry", + "details": "Converts an arabic numeral to roman, as text.", + "kind": "function" + }, + { + "trigger": "ROUND", + "contents": "ROUND", + "annotation": "Math and trigonometry", + "details": "Rounds a number to a specified number of digits.", + "kind": "function" + }, + { + "trigger": "ROUNDDOWN", + "contents": "ROUNDDOWN", + "annotation": "Math and trigonometry", + "details": "Rounds a number down, toward zero.", + "kind": "function" + }, + { + "trigger": "ROUNDUP", + "contents": "ROUNDUP", + "annotation": "Math and trigonometry", + "details": "Rounds a number up, away from zero.", + "kind": "function" + }, + { + "trigger": "ROW", + "contents": "ROW", + "annotation": "Lookup and reference", + "details": "Returns the row number of a reference.", + "kind": "function" + }, + { + "trigger": "ROWS", + "contents": "ROWS", + "annotation": "Lookup and reference", + "details": "Returns the number of rows in a reference.", + "kind": "function" + }, + { + "trigger": "RRI", + "contents": "RRI", + "annotation": "Financial", + "details": "Returns an equivalent interest rate for the growth of an investment.", + "kind": "function" + }, + { + "trigger": "RSQ", + "contents": "RSQ", + "annotation": "Statistical", + "details": "Returns the square of the Pearson product moment correlation coefficient.", + "kind": "function" + }, + { + "trigger": "RTD", + "contents": "RTD", + "annotation": "Lookup and reference", + "details": "Retrieves real-time data from a program that supports COM automation.", + "kind": "function" + }, + { + "trigger": "SCAN", + "contents": "SCAN", + "annotation": "Array", + "details": "Scans an array by applying a LAMBDA to each value and returns an array that has each intermediate value.", + "kind": "function" + }, + { + "trigger": "SEARCH", + "contents": "SEARCH", + "annotation": "Text", + "details": "Finds the position of a substring within a text string, case-insensitive.", + "kind": "function" + }, + { + "trigger": "SEARCHB", + "contents": "SEARCHB", + "annotation": "Text", + "details": "Returns the position of a specified substring within a text string, counting by bytes.", + "kind": "function" + }, + { + "trigger": "SEC", + "contents": "SEC", + "annotation": "Math and trigonometry", + "details": "Returns the secant of an angle.", + "kind": "function" + }, + { + "trigger": "SECH", + "contents": "SECH", + "annotation": "Math and trigonometry", + "details": "Returns the hyperbolic secant of an angle.", + "kind": "function" + }, + { + "trigger": "SECOND", + "contents": "SECOND", + "annotation": "Date and time", + "details": "Converts a serial number to a second.", + "kind": "function" + }, + { + "trigger": "SEQUENCE", + "contents": "SEQUENCE", + "annotation": "Math and trigonometry", + "details": "Generates a list of sequential numbers in an array, such as 1, 2, 3, 4", + "kind": "function" + }, + { + "trigger": "SERIESSUM", + "contents": "SERIESSUM", + "annotation": "Math and trigonometry", + "details": "Returns the sum of a power series based on the formula.", + "kind": "function" + }, + { + "trigger": "SHEET", + "contents": "SHEET", + "annotation": "Information", + "details": "Returns the sheet number of the referenced sheet.", + "kind": "function" + }, + { + "trigger": "SHEETS", + "contents": "SHEETS", + "annotation": "Information", + "details": "Returns the number of sheets in a reference.", + "kind": "function" + }, + { + "trigger": "SIGN", + "contents": "SIGN", + "annotation": "Math and trigonometry", + "details": "Returns the sign of a number.", + "kind": "function" + }, + { + "trigger": "SIN", + "contents": "SIN", + "annotation": "Math and trigonometry", + "details": "Returns the sine of the given angle.", + "kind": "function" + }, + { + "trigger": "SINH", + "contents": "SINH", + "annotation": "Math and trigonometry", + "details": "Returns the hyperbolic sine of a number.", + "kind": "function" + }, + { + "trigger": "SKEW", + "contents": "SKEW", + "annotation": "Statistical", + "details": "Returns the skewness of a distribution.", + "kind": "function" + }, + { + "trigger": "SKEW.P", + "contents": "SKEW.P", + "annotation": "Statistical", + "details": "Returns the skewness of a distribution based on a population.", + "kind": "function" + }, + { + "trigger": "SLN", + "contents": "SLN", + "annotation": "Financial", + "details": "Returns the straight-line depreciation of an asset for one period.", + "kind": "function" + }, + { + "trigger": "SLOPE", + "contents": "SLOPE", + "annotation": "Statistical", + "details": "Returns the slope of the linear regression line.", + "kind": "function" + }, + { + "trigger": "SMALL", + "contents": "SMALL", + "annotation": "Statistical", + "details": "Returns the k-th smallest value in a data set.", + "kind": "function" + }, + { + "trigger": "SORT", + "contents": "SORT", + "annotation": "Lookup and reference", + "details": "Sorts the contents of a range or array", + "kind": "function" + }, + { + "trigger": "SORTBY", + "contents": "SORTBY", + "annotation": "Lookup and reference", + "details": "Sorts the contents of a range or array based on the values in a corresponding range or array", + "kind": "function" + }, + { + "trigger": "SQRT", + "contents": "SQRT", + "annotation": "Math and trigonometry", + "details": "Returns a positive square root.", + "kind": "function" + }, + { + "trigger": "SQRTPI", + "contents": "SQRTPI", + "annotation": "Math and trigonometry", + "details": "Returns the square root of (number * pi).", + "kind": "function" + }, + { + "trigger": "STANDARDIZE", + "contents": "STANDARDIZE", + "annotation": "Statistical", + "details": "Returns a normalized value.", + "kind": "function" + }, + { + "trigger": "STDEV", + "contents": "STDEV", + "annotation": "Compatibility", + "details": "Estimates standard deviation based on a sample. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "STDEV.P", + "contents": "STDEV.P", + "annotation": "Statistical", + "details": "Calculates standard deviation based on the entire population.", + "kind": "function" + }, + { + "trigger": "STDEV.S", + "contents": "STDEV.S", + "annotation": "Statistical", + "details": "Estimates standard deviation based on a sample.", + "kind": "function" + }, + { + "trigger": "STDEVA", + "contents": "STDEVA", + "annotation": "Statistical", + "details": "Estimates standard deviation based on a sample, including numbers, text, and logical values.", + "kind": "function" + }, + { + "trigger": "STDEVP", + "contents": "STDEVP", + "annotation": "Compatibility", + "details": "Calculates standard deviation based on the entire population. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "STDEVPA", + "contents": "STDEVPA", + "annotation": "Statistical", + "details": "Calculates standard deviation based on the entire population, including numbers, text, and logical values.", + "kind": "function" + }, + { + "trigger": "STEYX", + "contents": "STEYX", + "annotation": "Statistical", + "details": "Returns the standard error of the predicted y-value for each x in the regression.", + "kind": "function" + }, + { + "trigger": "STOCKHISTORY", + "contents": "STOCKHISTORY", + "annotation": "Financial", + "details": "Retrieves historical data about a financial instrument.", + "kind": "function" + }, + { + "trigger": "SUBSTITUTE", + "contents": "SUBSTITUTE", + "annotation": "Text", + "details": "Substitutes new text for old text in a text string.", + "kind": "function" + }, + { + "trigger": "SUBTOTAL", + "contents": "SUBTOTAL", + "annotation": "Math and trigonometry", + "details": "Returns a subtotal in a list or database.", + "kind": "function" + }, + { + "trigger": "SUM", + "contents": "SUM", + "annotation": "Math and trigonometry", + "details": "Adds its arguments.", + "kind": "function" + }, + { + "trigger": "SUMIF", + "contents": "SUMIF", + "annotation": "Math and trigonometry", + "details": "Adds the cells specified by a given criteria.", + "kind": "function" + }, + { + "trigger": "SUMIFS", + "contents": "SUMIFS", + "annotation": "Math and trigonometry", + "details": "Adds the cells in a range that meet multiple criteria.", + "kind": "function" + }, + { + "trigger": "SUMPRODUCT", + "contents": "SUMPRODUCT", + "annotation": "Math and trigonometry", + "details": "Returns the sum of the products of corresponding array components.", + "kind": "function" + }, + { + "trigger": "SUMSQ", + "contents": "SUMSQ", + "annotation": "Math and trigonometry", + "details": "Returns the sum of the squares of the arguments.", + "kind": "function" + }, + { + "trigger": "SUMX2MY2", + "contents": "SUMX2MY2", + "annotation": "Math and trigonometry", + "details": "Returns the sum of the difference of squares of corresponding values in two arrays.", + "kind": "function" + }, + { + "trigger": "SUMX2PY2", + "contents": "SUMX2PY2", + "annotation": "Math and trigonometry", + "details": "Returns the sum of the sum of squares of corresponding values in two arrays.", + "kind": "function" + }, + { + "trigger": "SUMXMY2", + "contents": "SUMXMY2", + "annotation": "Math and trigonometry", + "details": "Returns the sum of squares of differences of corresponding values in two arrays.", + "kind": "function" + }, + { + "trigger": "SWITCH", + "contents": "SWITCH", + "annotation": "Logical", + "details": "Evaluates an expression against a list of values and returns the result corresponding to the first matching value. If there is no match, an optional default value may be returned. This function isn't available in Excel 2016 for Mac.", + "kind": "function" + }, + { + "trigger": "SYD", + "contents": "SYD", + "annotation": "Financial", + "details": "Returns the sum-of-years' digits depreciation of an asset for a specified period.", + "kind": "function" + }, + { + "trigger": "T", + "contents": "T", + "annotation": "Text", + "details": "Converts its arguments to text.", + "kind": "function" + }, + { + "trigger": "T.DIST", + "contents": "T.DIST", + "annotation": "Statistical", + "details": "Returns the left-tailed Student t-distribution.", + "kind": "function" + }, + { + "trigger": "T.DIST.2T", + "contents": "T.DIST.2T", + "annotation": "Statistical", + "details": "Returns the two-tailed Student t-distribution.", + "kind": "function" + }, + { + "trigger": "T.DIST.RT", + "contents": "T.DIST.RT", + "annotation": "Statistical", + "details": "Returns the right-tailed Student's t-distribution.", + "kind": "function" + }, + { + "trigger": "T.INV", + "contents": "T.INV", + "annotation": "Statistical", + "details": "Returns the left-tailed inverse of the Student's t-distribution.", + "kind": "function" + }, + { + "trigger": "T.INV.2T", + "contents": "T.INV.2T", + "annotation": "Statistical", + "details": "Returns the two-tailed inverse of the Student's t-distribution.", + "kind": "function" + }, + { + "trigger": "T.TEST", + "contents": "T.TEST", + "annotation": "Statistical", + "details": "Returns the probability associated with a Student's t-test.", + "kind": "function" + }, + { + "trigger": "TAKE", + "contents": "TAKE", + "annotation": "Array", + "details": "Returns rows or columns from the start or end of an array.", + "kind": "function" + }, + { + "trigger": "TAN", + "contents": "TAN", + "annotation": "Math and trigonometry", + "details": "Returns the tangent of a number.", + "kind": "function" + }, + { + "trigger": "TANH", + "contents": "TANH", + "annotation": "Math and trigonometry", + "details": "Returns the hyperbolic tangent of a number.", + "kind": "function" + }, + { + "trigger": "TBILLEQ", + "contents": "TBILLEQ", + "annotation": "Financial", + "details": "Returns the bond-equivalent yield for a Treasury bill.", + "kind": "function" + }, + { + "trigger": "TBILLPRICE", + "contents": "TBILLPRICE", + "annotation": "Financial", + "details": "Returns the price per $100 face value for a Treasury bill.", + "kind": "function" + }, + { + "trigger": "TBILLYIELD", + "contents": "TBILLYIELD", + "annotation": "Financial", + "details": "Returns the yield for a Treasury bill.", + "kind": "function" + }, + { + "trigger": "TDIST", + "contents": "TDIST", + "annotation": "Compatibility", + "details": "Returns the Student's t-distribution. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "TEXT", + "contents": "TEXT", + "annotation": "Text", + "details": "Formats a number and converts it to text.", + "kind": "function" + }, + { + "trigger": "TEXTAFTER", + "contents": "TEXTAFTER", + "annotation": "Text", + "details": "Returns text that's after delimiting characters.", + "kind": "function" + }, + { + "trigger": "TEXTBEFORE", + "contents": "TEXTBEFORE", + "annotation": "Text", + "details": "Returns text that's before delimiting characters.", + "kind": "function" + }, + { + "trigger": "TEXTJOIN", + "contents": "TEXTJOIN", + "annotation": "Text", + "details": "Combines the text from multiple ranges and/or strings, and includes a delimiter you specify between each text value that will be combined. If the delimiter is an empty text string, this function will effectively concatenate the ranges. This function isn't available in Excel 2016 for Mac.", + "kind": "function" + }, + { + "trigger": "TEXTSPLIT", + "contents": "TEXTSPLIT", + "annotation": "Text", + "details": "Splits text into rows or columns using delimiters.", + "kind": "function" + }, + { + "trigger": "TIME", + "contents": "TIME", + "annotation": "Date and time", + "details": "Returns the serial number of a particular time.", + "kind": "function" + }, + { + "trigger": "TIMEVALUE", + "contents": "TIMEVALUE", + "annotation": "Date and time", + "details": "Converts a time in the form of text to a serial number.", + "kind": "function" + }, + { + "trigger": "TINV", + "contents": "TINV", + "annotation": "Compatibility", + "details": "Returns the inverse of the Student's t-distribution. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "TOCOL", + "contents": "TOCOL", + "annotation": "Array", + "details": "Returns the array as a column.", + "kind": "function" + }, + { + "trigger": "TODAY", + "contents": "TODAY", + "annotation": "Date and time", + "details": "Returns the serial number of today's date.", + "kind": "function" + }, + { + "trigger": "TOROW", + "contents": "TOROW", + "annotation": "Array", + "details": "Returns the array as a row.", + "kind": "function" + }, + { + "trigger": "TRANSPOSE", + "contents": "TRANSPOSE", + "annotation": "Lookup and reference", + "details": "Returns the transpose of an array.", + "kind": "function" + }, + { + "trigger": "TREND", + "contents": "TREND", + "annotation": "Statistical", + "details": "Returns values along a linear trend.", + "kind": "function" + }, + { + "trigger": "TRIM", + "contents": "TRIM", + "annotation": "Text", + "details": "Removes spaces from text.", + "kind": "function" + }, + { + "trigger": "TRIMMEAN", + "contents": "TRIMMEAN", + "annotation": "Statistical", + "details": "Returns the mean of the interior of a data set.", + "kind": "function" + }, + { + "trigger": "TRUNC", + "contents": "TRUNC", + "annotation": "Math and trigonometry", + "details": "Truncates a number to an integer.", + "kind": "function" + }, + { + "trigger": "TTEST", + "contents": "TTEST", + "annotation": "Compatibility", + "details": "Returns the probability associated with a Student's t-test. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "TYPE", + "contents": "TYPE", + "annotation": "Information", + "details": "Returns a number indicating the data type of a value.", + "kind": "function" + }, + { + "trigger": "UNICHAR", + "contents": "UNICHAR", + "annotation": "Text", + "details": "Returns the Unicode character that is references by the given numeric value.", + "kind": "function" + }, + { + "trigger": "UNICODE", + "contents": "UNICODE", + "annotation": "Text", + "details": "Returns the number (code point) that corresponds to the first character of the text.", + "kind": "function" + }, + { + "trigger": "UNIQUE", + "contents": "UNIQUE", + "annotation": "Lookup and reference", + "details": "Returns a list of unique values in a list or range", + "kind": "function" + }, + { + "trigger": "UNREGISTER", + "contents": "UNREGISTER", + "annotation": "Add-in", + "details": "Removes the registration of a DLL or code resource.", + "kind": "function" + }, + { + "trigger": "UPPER", + "contents": "UPPER", + "annotation": "Text", + "details": "Converts text to uppercase.", + "kind": "function" + }, + { + "trigger": "VALUE", + "contents": "VALUE", + "annotation": "Text", + "details": "Converts a text argument to a number.", + "kind": "function" + }, + { + "trigger": "VALUETOTEXT", + "contents": "VALUETOTEXT", + "annotation": "Text", + "details": "Returns text from any specified value", + "kind": "function" + }, + { + "trigger": "VAR", + "contents": "VAR", + "annotation": "Compatibility", + "details": "Estimates variance based on a sample. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "VAR.P", + "contents": "VAR.P", + "annotation": "Statistical", + "details": "Calculates variance based on the entire population.", + "kind": "function" + }, + { + "trigger": "VAR.S", + "contents": "VAR.S", + "annotation": "Statistical", + "details": "Estimates variance based on a sample.", + "kind": "function" + }, + { + "trigger": "VARA", + "contents": "VARA", + "annotation": "Statistical", + "details": "Estimates variance based on a sample, including numbers, text, and logical values.", + "kind": "function" + }, + { + "trigger": "VARP", + "contents": "VARP", + "annotation": "Compatibility", + "details": "Calculates variance based on the entire population. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "VARPA", + "contents": "VARPA", + "annotation": "Statistical", + "details": "Calculates variance based on the entire population, including numbers, text, and logical values.", + "kind": "function" + }, + { + "trigger": "VDB", + "contents": "VDB", + "annotation": "Financial", + "details": "Returns the depreciation of an asset for a specified or partial period by using a declining balance method.", + "kind": "function" + }, + { + "trigger": "VLOOKUP", + "contents": "VLOOKUP", + "annotation": "Lookup and reference", + "details": "Looks in the first column of an array and moves across the row to return the value of a cell.", + "kind": "function" + }, + { + "trigger": "VSTACK", + "contents": "VSTACK", + "annotation": "Array", + "details": "Vertically combine arrays into one array.", + "kind": "function" + }, + { + "trigger": "WEBSERVICE", + "contents": "WEBSERVICE", + "annotation": "Web", + "details": "Returns data from a web service. This function is not available in Excel Online.", + "kind": "function" + }, + { + "trigger": "WEEKDAY", + "contents": "WEEKDAY", + "annotation": "Date and time", + "details": "Converts a serial number to a day of the week.", + "kind": "function" + }, + { + "trigger": "WEEKNUM", + "contents": "WEEKNUM", + "annotation": "Date and time", + "details": "Converts a serial number to a number representing where the week falls numerically with a year.", + "kind": "function" + }, + { + "trigger": "WEIBULL", + "contents": "WEIBULL", + "annotation": "Compatibility", + "details": "Calculates variance based on the entire population, including numbers, text, and logical values. In Excel 2007, this is a Statistical function.", + "kind": "function" + }, + { + "trigger": "WEIBULL.DIST", + "contents": "WEIBULL.DIST", + "annotation": "Statistical", + "details": "Returns the Weibull distribution.", + "kind": "function" + }, + { + "trigger": "WORKDAY", + "contents": "WORKDAY", + "annotation": "Date and time", + "details": "Returns the serial number of the date before or after a specified number of workdays.", + "kind": "function" + }, + { + "trigger": "WORKDAY.INTL", + "contents": "WORKDAY.INTL", + "annotation": "Date and time", + "details": "Returns the serial number of the date before or after a specified number of workdays using parameters to indicate which and how many days are weekend days.", + "kind": "function" + }, + { + "trigger": "WRAPCOLS", + "contents": "WRAPCOLS", + "annotation": "Array", + "details": "Wraps a row or column to a specified height.", + "kind": "function" + }, + { + "trigger": "WRAPROWS", + "contents": "WRAPROWS", + "annotation": "Array", + "details": "Wraps a row or column to a specified width.", + "kind": "function" + }, + { + "trigger": "XIRR", + "contents": "XIRR", + "annotation": "Financial", + "details": "Returns the internal rate of return for a schedule of cash flows that is not necessarily periodic.", + "kind": "function" + }, + { + "trigger": "XLOOKUP", + "contents": "XLOOKUP", + "annotation": "Lookup and reference", + "details": "Searches a range or an array, and returns an item corresponding to the first match it finds. If a match doesn't exist,then XLOOKUP can return the closest (approximate) match.", + "kind": "function" + }, + { + "trigger": "XMATCH", + "contents": "XMATCH", + "annotation": "Lookup and reference", + "details": "Returns the relative position of an item in an array or range of cells.", + "kind": "function" + }, + { + "trigger": "XNPV", + "contents": "XNPV", + "annotation": "Financial", + "details": "Returns the net present value for a schedule of cash flows that is not necessarily periodic.", + "kind": "function" + }, + { + "trigger": "XOR", + "contents": "XOR", + "annotation": "Logical", + "details": "Returns a logical exclusive OR of all arguments.", + "kind": "function" + }, + { + "trigger": "YEAR", + "contents": "YEAR", + "annotation": "Date and time", + "details": "Converts a serial number to a year.", + "kind": "function" + }, + { + "trigger": "YEARFRAC", + "contents": "YEARFRAC", + "annotation": "Date and time", + "details": "Returns the year fraction representing the number of whole days between start_date and end_date.", + "kind": "function" + }, + { + "trigger": "YIELD", + "contents": "YIELD", + "annotation": "Financial", + "details": "Returns the yield on a security that pays periodic interest.", + "kind": "function" + }, + { + "trigger": "YIELDDISC", + "contents": "YIELDDISC", + "annotation": "Financial", + "details": "Returns the annual yield for a discounted security.", + "kind": "function" + }, + { + "trigger": "YIELDMAT", + "contents": "YIELDMAT", + "annotation": "Financial", + "details": "Returns the annual yield of a security that pays interest at maturity.", + "kind": "function" + }, + { + "trigger": "Z.TEST", + "contents": "Z.TEST", + "annotation": "Statistical", + "details": "Returns the one-tailed probability-value of a z-test.", + "kind": "function" + }, + { + "trigger": "ZTEST", + "contents": "ZTEST", + "annotation": "Compatibility", + "details": "Returns the one-tailed probability-value of a z-test. In Excel 2007, this is a Statistical function.", + "kind": "function" } ] } \ No newline at end of file diff --git a/resources/completion_builder/main.py b/resources/completion_builder/main.py index b620237..2e54632 100755 --- a/resources/completion_builder/main.py +++ b/resources/completion_builder/main.py @@ -17,7 +17,8 @@ def main(sheet_app: str, write_intermediate_json: bool): completions = { "scope": f'source.sheet.{sheet_app} - string - comment', - "completions": [f.to_sublime_snippet_completion() for f in functions], + "completions": [f.to_sublime_snippet_completion() for f in functions] + + [f.to_sublime_word_completion() for f in functions], } with open('.sublime-completions', 'w') as o: From 79b266d22ac4aeca33371db34118839cf3e926b7 Mon Sep 17 00:00:00 2001 From: Michael Lyons Date: Sun, 9 Feb 2025 18:03:07 -0500 Subject: [PATCH 12/12] Add the intermediate json file changes --- resources/completion_builder/excel_funcs.json | 1014 ++++++ .../excel_funcs_master.json | 3046 ++++++++++++++++- 2 files changed, 4055 insertions(+), 5 deletions(-) diff --git a/resources/completion_builder/excel_funcs.json b/resources/completion_builder/excel_funcs.json index 4cabaed..41d0fa5 100644 --- a/resources/completion_builder/excel_funcs.json +++ b/resources/completion_builder/excel_funcs.json @@ -1,6 +1,8 @@ [ { "func_name": "ABS", + "is_nullary": false, + "comp_str": "ABS(${1:number})", "req_param": [ "number" ], @@ -9,6 +11,8 @@ }, { "func_name": "ACCRINT", + "is_nullary": false, + "comp_str": "ACCRINT(${1:issue},${2: first_interest},${3: settlement},${4: rate},${5: par},${6: frequency}${7:,${8: [basis]},${9: [calc_method]}})", "req_param": [ "issue", "first_interest", @@ -25,6 +29,8 @@ }, { "func_name": "ACCRINTM", + "is_nullary": false, + "comp_str": "ACCRINTM(${1:issue},${2: settlement},${3: rate},${4: par}${5:,${6: [basis]}})", "req_param": [ "issue", "settlement", @@ -38,6 +44,8 @@ }, { "func_name": "ACOS", + "is_nullary": false, + "comp_str": "ACOS(${1:number})", "req_param": [ "number" ], @@ -46,6 +54,8 @@ }, { "func_name": "ACOSH", + "is_nullary": false, + "comp_str": "ACOSH(${1:number})", "req_param": [ "number" ], @@ -54,6 +64,8 @@ }, { "func_name": "ACOT", + "is_nullary": false, + "comp_str": "ACOT(${1:number})", "req_param": [ "number" ], @@ -62,6 +74,8 @@ }, { "func_name": "ACOTH", + "is_nullary": false, + "comp_str": "ACOTH(${1:number})", "req_param": [ "number" ], @@ -70,6 +84,8 @@ }, { "func_name": "ADDRESS", + "is_nullary": false, + "comp_str": "ADDRESS(${1:row_num},${2: column_num}${3:,${4: [abs_num]},${5: [a1]},${6: [sheet_text]}})", "req_param": [ "row_num", "column_num" @@ -83,6 +99,8 @@ }, { "func_name": "AGGREGATE", + "is_nullary": false, + "comp_str": "AGGREGATE(${1:function_num},${2: options},${3: array}${4:,${5: [k]}})", "req_param": [ "function_num", "options", @@ -95,6 +113,8 @@ }, { "func_name": "AMORDEGRC", + "is_nullary": false, + "comp_str": "AMORDEGRC(${1:cost},${2: date_purchased},${3: first_period},${4: salvage},${5: period},${6: rate}${7:,${8: [basis]}})", "req_param": [ "cost", "date_purchased", @@ -110,6 +130,8 @@ }, { "func_name": "AMORLINC", + "is_nullary": false, + "comp_str": "AMORLINC(${1:cost},${2: date_purchased},${3: first_period},${4: salvage},${5: period},${6: rate}${7:,${8: [basis]}})", "req_param": [ "cost", "date_purchased", @@ -125,6 +147,8 @@ }, { "func_name": "AND", + "is_nullary": false, + "comp_str": "AND(${1:logical1}${2:,${3: [logical2], ...}})", "req_param": [ "logical1" ], @@ -135,6 +159,8 @@ }, { "func_name": "ARABIC", + "is_nullary": false, + "comp_str": "ARABIC(${1:text})", "req_param": [ "text" ], @@ -143,6 +169,8 @@ }, { "func_name": "AREAS", + "is_nullary": false, + "comp_str": "AREAS(${1:reference})", "req_param": [ "reference" ], @@ -151,6 +179,8 @@ }, { "func_name": "ARRAYTOTEXT", + "is_nullary": false, + "comp_str": "ARRAYTOTEXT(${1:array}${2:,${3: [format]}})", "req_param": [ "array" ], @@ -161,6 +191,8 @@ }, { "func_name": "ASC", + "is_nullary": false, + "comp_str": "ASC(${1:text})", "req_param": [ "text" ], @@ -169,6 +201,8 @@ }, { "func_name": "ASIN", + "is_nullary": false, + "comp_str": "ASIN(${1:number})", "req_param": [ "number" ], @@ -177,6 +211,8 @@ }, { "func_name": "ASINH", + "is_nullary": false, + "comp_str": "ASINH(${1:number})", "req_param": [ "number" ], @@ -185,6 +221,8 @@ }, { "func_name": "ATAN", + "is_nullary": false, + "comp_str": "ATAN(${1:number})", "req_param": [ "number" ], @@ -193,6 +231,8 @@ }, { "func_name": "ATAN2", + "is_nullary": false, + "comp_str": "ATAN2(${1:x_num},${2: y_num})", "req_param": [ "x_num", "y_num" @@ -202,6 +242,8 @@ }, { "func_name": "ATANH", + "is_nullary": false, + "comp_str": "ATANH(${1:number})", "req_param": [ "number" ], @@ -210,6 +252,8 @@ }, { "func_name": "AVEDEV", + "is_nullary": false, + "comp_str": "AVEDEV(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -220,6 +264,8 @@ }, { "func_name": "AVERAGE", + "is_nullary": false, + "comp_str": "AVERAGE(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -230,6 +276,8 @@ }, { "func_name": "AVERAGEA", + "is_nullary": false, + "comp_str": "AVERAGEA(${1:value1}${2:,${3: [value2], ...}})", "req_param": [ "value1" ], @@ -240,6 +288,8 @@ }, { "func_name": "AVERAGEIF", + "is_nullary": false, + "comp_str": "AVERAGEIF(${1:range},${2: criteria}${3:,${4: [average_range]}})", "req_param": [ "range", "criteria" @@ -251,6 +301,8 @@ }, { "func_name": "AVERAGEIFS", + "is_nullary": false, + "comp_str": "AVERAGEIFS(${1:average_range},${2: criteria_range1},${3: criteria1}${4:,${5: [criteria_range2]},${6: [criteria2], ...}})", "req_param": [ "average_range", "criteria_range1", @@ -264,6 +316,8 @@ }, { "func_name": "BAHTTEXT", + "is_nullary": false, + "comp_str": "BAHTTEXT(${1:number})", "req_param": [ "number" ], @@ -272,6 +326,8 @@ }, { "func_name": "BASE", + "is_nullary": false, + "comp_str": "BASE(${1:number},${2: radix}${3:,${4: [min_length]}})", "req_param": [ "number", "radix" @@ -283,6 +339,8 @@ }, { "func_name": "BESSELI", + "is_nullary": false, + "comp_str": "BESSELI(${1:x},${2: n})", "req_param": [ "x", "n" @@ -292,6 +350,8 @@ }, { "func_name": "BESSELJ", + "is_nullary": false, + "comp_str": "BESSELJ(${1:x},${2: n})", "req_param": [ "x", "n" @@ -301,6 +361,8 @@ }, { "func_name": "BESSELK", + "is_nullary": false, + "comp_str": "BESSELK(${1:x},${2: n})", "req_param": [ "x", "n" @@ -310,6 +372,8 @@ }, { "func_name": "BESSELY", + "is_nullary": false, + "comp_str": "BESSELY(${1:x},${2: n})", "req_param": [ "x", "n" @@ -319,6 +383,8 @@ }, { "func_name": "BETA.DIST", + "is_nullary": false, + "comp_str": "BETA.DIST(${1:x},${2: alpha},${3: beta},${4: cumulative}${5:,${6: [A]},${7: [B]}})", "req_param": [ "x", "alpha", @@ -333,6 +399,8 @@ }, { "func_name": "BETA.INV", + "is_nullary": false, + "comp_str": "BETA.INV(${1:probability},${2: alpha},${3: beta}${4:,${5: [A]},${6: [B]}})", "req_param": [ "probability", "alpha", @@ -346,6 +414,8 @@ }, { "func_name": "BETADIST", + "is_nullary": false, + "comp_str": "BETADIST(${1:x},${2: alpha},${3: beta}${4:,${5: [A]},${6: [B]}})", "req_param": [ "x", "alpha", @@ -359,6 +429,8 @@ }, { "func_name": "BETAINV", + "is_nullary": false, + "comp_str": "BETAINV(${1:probability},${2: alpha},${3: beta}${4:,${5: [A]},${6: [B]}})", "req_param": [ "probability", "alpha", @@ -372,6 +444,8 @@ }, { "func_name": "BIN2DEC", + "is_nullary": false, + "comp_str": "BIN2DEC(${1:number})", "req_param": [ "number" ], @@ -380,6 +454,8 @@ }, { "func_name": "BIN2HEX", + "is_nullary": false, + "comp_str": "BIN2HEX(${1:number}${2:,${3: [places]}})", "req_param": [ "number" ], @@ -390,6 +466,8 @@ }, { "func_name": "BIN2OCT", + "is_nullary": false, + "comp_str": "BIN2OCT(${1:number}${2:,${3: [places]}})", "req_param": [ "number" ], @@ -400,6 +478,8 @@ }, { "func_name": "BINOM.DIST", + "is_nullary": false, + "comp_str": "BINOM.DIST(${1:number_s},${2: trials},${3: probability_s},${4: cumulative})", "req_param": [ "number_s", "trials", @@ -411,6 +491,8 @@ }, { "func_name": "BINOM.DIST.RANGE", + "is_nullary": false, + "comp_str": "BINOM.DIST.RANGE(${1:trials},${2: probability_s},${3: number_s}${4:,${5: [number_s2]}})", "req_param": [ "trials", "probability_s", @@ -423,6 +505,8 @@ }, { "func_name": "BINOM.INV", + "is_nullary": false, + "comp_str": "BINOM.INV(${1:trials},${2: probability_s},${3: alpha})", "req_param": [ "trials", "probability_s", @@ -433,6 +517,8 @@ }, { "func_name": "BINOMDIST", + "is_nullary": false, + "comp_str": "BINOMDIST(${1:number_s},${2: trials},${3: probability_s},${4: cumulative})", "req_param": [ "number_s", "trials", @@ -444,6 +530,8 @@ }, { "func_name": "BITAND", + "is_nullary": false, + "comp_str": "BITAND(${1:number1},${2: number2})", "req_param": [ "number1", "number2" @@ -453,6 +541,8 @@ }, { "func_name": "BITLSHIFT", + "is_nullary": false, + "comp_str": "BITLSHIFT(${1:number},${2: shift_amount})", "req_param": [ "number", "shift_amount" @@ -462,6 +552,8 @@ }, { "func_name": "BITOR", + "is_nullary": false, + "comp_str": "BITOR(${1:number1},${2: number2})", "req_param": [ "number1", "number2" @@ -471,6 +563,8 @@ }, { "func_name": "BITRSHIFT", + "is_nullary": false, + "comp_str": "BITRSHIFT(${1:number},${2: shift_amount})", "req_param": [ "number", "shift_amount" @@ -480,6 +574,8 @@ }, { "func_name": "BITXOR", + "is_nullary": false, + "comp_str": "BITXOR(${1:number1},${2: number2})", "req_param": [ "number1", "number2" @@ -489,6 +585,8 @@ }, { "func_name": "BYCOL", + "is_nullary": false, + "comp_str": "BYCOL(${1:array}${2:,${3: [function]}})", "req_param": [ "array" ], @@ -499,6 +597,8 @@ }, { "func_name": "BYROW", + "is_nullary": false, + "comp_str": "BYROW(${1:array}${2:,${3: [function]}})", "req_param": [ "array" ], @@ -509,6 +609,8 @@ }, { "func_name": "CALL", + "is_nullary": false, + "comp_str": "CALL(${1:register_id}${2:,${3: [argument1], ...}})", "req_param": [ "register_id" ], @@ -519,6 +621,8 @@ }, { "func_name": "CEILING", + "is_nullary": false, + "comp_str": "CEILING(${1:number},${2: significance})", "req_param": [ "number", "significance" @@ -528,6 +632,8 @@ }, { "func_name": "CEILING.MATH", + "is_nullary": false, + "comp_str": "CEILING.MATH(${1:number}${2:,${3: [significance]},${4: [mode]}})", "req_param": [ "number" ], @@ -539,6 +645,8 @@ }, { "func_name": "CEILING.PRECISE", + "is_nullary": false, + "comp_str": "CEILING.PRECISE(${1:number}${2:,${3: [significance]}})", "req_param": [ "number" ], @@ -549,6 +657,8 @@ }, { "func_name": "CELL", + "is_nullary": false, + "comp_str": "CELL(${1:info_type}${2:,${3: [reference]}})", "req_param": [ "info_type" ], @@ -559,6 +669,8 @@ }, { "func_name": "CHAR", + "is_nullary": false, + "comp_str": "CHAR(${1:number})", "req_param": [ "number" ], @@ -567,6 +679,8 @@ }, { "func_name": "CHIDIST", + "is_nullary": false, + "comp_str": "CHIDIST(${1:x},${2: deg_freedom})", "req_param": [ "x", "deg_freedom" @@ -576,6 +690,8 @@ }, { "func_name": "CHIINV", + "is_nullary": false, + "comp_str": "CHIINV(${1:probability},${2: deg_freedom})", "req_param": [ "probability", "deg_freedom" @@ -585,6 +701,8 @@ }, { "func_name": "CHISQ.DIST", + "is_nullary": false, + "comp_str": "CHISQ.DIST(${1:x},${2: deg_freedom},${3: cumulative})", "req_param": [ "x", "deg_freedom", @@ -595,6 +713,8 @@ }, { "func_name": "CHISQ.DIST.RT", + "is_nullary": false, + "comp_str": "CHISQ.DIST.RT(${1:x},${2: deg_freedom})", "req_param": [ "x", "deg_freedom" @@ -604,6 +724,8 @@ }, { "func_name": "CHISQ.INV", + "is_nullary": false, + "comp_str": "CHISQ.INV(${1:probability},${2: deg_freedom})", "req_param": [ "probability", "deg_freedom" @@ -613,6 +735,8 @@ }, { "func_name": "CHISQ.INV.RT", + "is_nullary": false, + "comp_str": "CHISQ.INV.RT(${1:probability},${2: deg_freedom})", "req_param": [ "probability", "deg_freedom" @@ -622,6 +746,8 @@ }, { "func_name": "CHISQ.TEST", + "is_nullary": false, + "comp_str": "CHISQ.TEST(${1:actual_range},${2: expected_range})", "req_param": [ "actual_range", "expected_range" @@ -631,6 +757,8 @@ }, { "func_name": "CHITEST", + "is_nullary": false, + "comp_str": "CHITEST(${1:actual_range},${2: expected_range})", "req_param": [ "actual_range", "expected_range" @@ -640,6 +768,8 @@ }, { "func_name": "CHOOSE", + "is_nullary": false, + "comp_str": "CHOOSE(${1:index_num},${2: value1}${3:,${4: [value2], ...}})", "req_param": [ "index_num", "value1" @@ -651,6 +781,8 @@ }, { "func_name": "CHOOSECOLS", + "is_nullary": false, + "comp_str": "CHOOSECOLS(${1:array},${2: col_num1}${3:,${4: [col_num2], ...}})", "req_param": [ "array", "col_num1" @@ -662,6 +794,8 @@ }, { "func_name": "CHOOSEROWS", + "is_nullary": false, + "comp_str": "CHOOSEROWS(${1:array},${2: row_num1}${3:,${4: [row_num2], ...}})", "req_param": [ "array", "row_num1" @@ -673,6 +807,8 @@ }, { "func_name": "CLEAN", + "is_nullary": false, + "comp_str": "CLEAN(${1:text})", "req_param": [ "text" ], @@ -681,6 +817,8 @@ }, { "func_name": "CODE", + "is_nullary": false, + "comp_str": "CODE(${1:text})", "req_param": [ "text" ], @@ -689,6 +827,8 @@ }, { "func_name": "COLUMN", + "is_nullary": false, + "comp_str": "COLUMN(${1:,${2: [reference]}})", "req_param": [], "opt_param": [ "reference" @@ -697,6 +837,8 @@ }, { "func_name": "COLUMNS", + "is_nullary": false, + "comp_str": "COLUMNS(${1:array})", "req_param": [ "array" ], @@ -705,6 +847,8 @@ }, { "func_name": "COMBIN", + "is_nullary": false, + "comp_str": "COMBIN(${1:number},${2: number_chosen})", "req_param": [ "number", "number_chosen" @@ -714,6 +858,8 @@ }, { "func_name": "COMBINA", + "is_nullary": false, + "comp_str": "COMBINA(${1:number},${2: number_chosen})", "req_param": [ "number", "number_chosen" @@ -723,6 +869,8 @@ }, { "func_name": "COMPLEX", + "is_nullary": false, + "comp_str": "COMPLEX(${1:real_num},${2: i_num}${3:,${4: [suffix]}})", "req_param": [ "real_num", "i_num" @@ -734,6 +882,8 @@ }, { "func_name": "CONCAT", + "is_nullary": false, + "comp_str": "CONCAT(${1:text1}${2:,${3: [text2], ...}})", "req_param": [ "text1" ], @@ -744,6 +894,8 @@ }, { "func_name": "CONCATENATE", + "is_nullary": false, + "comp_str": "CONCATENATE(${1:text1}${2:,${3: [text2], ...}})", "req_param": [ "text1" ], @@ -754,6 +906,8 @@ }, { "func_name": "CONFIDENCE", + "is_nullary": false, + "comp_str": "CONFIDENCE(${1:alpha},${2: standard_dev},${3: size})", "req_param": [ "alpha", "standard_dev", @@ -764,6 +918,8 @@ }, { "func_name": "CONFIDENCE.NORM", + "is_nullary": false, + "comp_str": "CONFIDENCE.NORM(${1:alpha},${2: standard_dev},${3: size})", "req_param": [ "alpha", "standard_dev", @@ -774,6 +930,8 @@ }, { "func_name": "CONFIDENCE.T", + "is_nullary": false, + "comp_str": "CONFIDENCE.T(${1:alpha},${2: standard_dev},${3: size})", "req_param": [ "alpha", "standard_dev", @@ -784,6 +942,8 @@ }, { "func_name": "CONVERT", + "is_nullary": false, + "comp_str": "CONVERT(${1:number},${2: from_unit},${3: to_unit})", "req_param": [ "number", "from_unit", @@ -794,6 +954,8 @@ }, { "func_name": "CORREL", + "is_nullary": false, + "comp_str": "CORREL(${1:array1},${2: array2})", "req_param": [ "array1", "array2" @@ -803,6 +965,8 @@ }, { "func_name": "COS", + "is_nullary": false, + "comp_str": "COS(${1:number})", "req_param": [ "number" ], @@ -811,6 +975,8 @@ }, { "func_name": "COSH", + "is_nullary": false, + "comp_str": "COSH(${1:number})", "req_param": [ "number" ], @@ -819,6 +985,8 @@ }, { "func_name": "COT", + "is_nullary": false, + "comp_str": "COT(${1:number})", "req_param": [ "number" ], @@ -827,6 +995,8 @@ }, { "func_name": "COTH", + "is_nullary": false, + "comp_str": "COTH(${1:number})", "req_param": [ "number" ], @@ -835,6 +1005,8 @@ }, { "func_name": "COUNT", + "is_nullary": false, + "comp_str": "COUNT(${1:value1}${2:,${3: [value2], ...}})", "req_param": [ "value1" ], @@ -845,6 +1017,8 @@ }, { "func_name": "COUNTA", + "is_nullary": false, + "comp_str": "COUNTA(${1:value1}${2:,${3: [value2], ...}})", "req_param": [ "value1" ], @@ -855,6 +1029,8 @@ }, { "func_name": "COUNTBLANK", + "is_nullary": false, + "comp_str": "COUNTBLANK(${1:range})", "req_param": [ "range" ], @@ -863,6 +1039,8 @@ }, { "func_name": "COUNTIF", + "is_nullary": false, + "comp_str": "COUNTIF(${1:range},${2: criteria})", "req_param": [ "range", "criteria" @@ -872,6 +1050,8 @@ }, { "func_name": "COUNTIFS", + "is_nullary": false, + "comp_str": "COUNTIFS(${1:criteria_range1},${2: criteria1}${3:,${4: [criteria_range2]},${5: [criteria2], ...}})", "req_param": [ "criteria_range1", "criteria1" @@ -884,6 +1064,8 @@ }, { "func_name": "COUPDAYBS", + "is_nullary": false, + "comp_str": "COUPDAYBS(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})", "req_param": [ "settlement", "maturity", @@ -896,6 +1078,8 @@ }, { "func_name": "COUPDAYS", + "is_nullary": false, + "comp_str": "COUPDAYS(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})", "req_param": [ "settlement", "maturity", @@ -908,6 +1092,8 @@ }, { "func_name": "COUPDAYSNC", + "is_nullary": false, + "comp_str": "COUPDAYSNC(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})", "req_param": [ "settlement", "maturity", @@ -920,6 +1106,8 @@ }, { "func_name": "COUPNCD", + "is_nullary": false, + "comp_str": "COUPNCD(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})", "req_param": [ "settlement", "maturity", @@ -932,6 +1120,8 @@ }, { "func_name": "COUPNUM", + "is_nullary": false, + "comp_str": "COUPNUM(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})", "req_param": [ "settlement", "maturity", @@ -944,6 +1134,8 @@ }, { "func_name": "COUPPCD", + "is_nullary": false, + "comp_str": "COUPPCD(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})", "req_param": [ "settlement", "maturity", @@ -956,6 +1148,8 @@ }, { "func_name": "COVAR", + "is_nullary": false, + "comp_str": "COVAR(${1:array1},${2: array2})", "req_param": [ "array1", "array2" @@ -965,6 +1159,8 @@ }, { "func_name": "COVARIANCE.P", + "is_nullary": false, + "comp_str": "COVARIANCE.P(${1:array1},${2: array2})", "req_param": [ "array1", "array2" @@ -974,6 +1170,8 @@ }, { "func_name": "COVARIANCE.S", + "is_nullary": false, + "comp_str": "COVARIANCE.S(${1:array1},${2: array2})", "req_param": [ "array1", "array2" @@ -983,6 +1181,8 @@ }, { "func_name": "CRITBINOM", + "is_nullary": false, + "comp_str": "CRITBINOM(${1:trials},${2: probability_s},${3: alpha})", "req_param": [ "trials", "probability_s", @@ -993,6 +1193,8 @@ }, { "func_name": "CSC", + "is_nullary": false, + "comp_str": "CSC(${1:number})", "req_param": [ "number" ], @@ -1001,6 +1203,8 @@ }, { "func_name": "CSCH", + "is_nullary": false, + "comp_str": "CSCH(${1:number})", "req_param": [ "number" ], @@ -1009,6 +1213,8 @@ }, { "func_name": "CUBEKPIMEMBER", + "is_nullary": false, + "comp_str": "CUBEKPIMEMBER(${1:connection},${2: kpi_name},${3: kpi_property}${4:,${5: [caption]}})", "req_param": [ "connection", "kpi_name", @@ -1021,6 +1227,8 @@ }, { "func_name": "CUBEMEMBER", + "is_nullary": false, + "comp_str": "CUBEMEMBER(${1:connection},${2: member_expression}${3:,${4: [caption]}})", "req_param": [ "connection", "member_expression" @@ -1032,6 +1240,8 @@ }, { "func_name": "CUBEMEMBERPROPERTY", + "is_nullary": false, + "comp_str": "CUBEMEMBERPROPERTY(${1:connection},${2: member_expression},${3: property})", "req_param": [ "connection", "member_expression", @@ -1042,6 +1252,8 @@ }, { "func_name": "CUBERANKEDMEMBER", + "is_nullary": false, + "comp_str": "CUBERANKEDMEMBER(${1:connection},${2: set_expression},${3: rank}${4:,${5: [caption]}})", "req_param": [ "connection", "set_expression", @@ -1054,6 +1266,8 @@ }, { "func_name": "CUBESET", + "is_nullary": false, + "comp_str": "CUBESET(${1:connection},${2: set_expression}${3:,${4: [caption]},${5: [sort_order]},${6: [sort_by]}})", "req_param": [ "connection", "set_expression" @@ -1067,6 +1281,8 @@ }, { "func_name": "CUBESETCOUNT", + "is_nullary": false, + "comp_str": "CUBESETCOUNT(${1:set})", "req_param": [ "set" ], @@ -1075,6 +1291,8 @@ }, { "func_name": "CUBEVALUE", + "is_nullary": false, + "comp_str": "CUBEVALUE(${1:connection}${2:,${3: [member_expression1], ...}})", "req_param": [ "connection" ], @@ -1085,6 +1303,8 @@ }, { "func_name": "CUMIPMT", + "is_nullary": false, + "comp_str": "CUMIPMT(${1:rate},${2: nper},${3: pv},${4: start_period},${5: end_period},${6: type})", "req_param": [ "rate", "nper", @@ -1098,6 +1318,8 @@ }, { "func_name": "CUMPRINC", + "is_nullary": false, + "comp_str": "CUMPRINC(${1:rate},${2: nper},${3: pv},${4: start_period},${5: end_period},${6: type})", "req_param": [ "rate", "nper", @@ -1111,6 +1333,8 @@ }, { "func_name": "DATE", + "is_nullary": false, + "comp_str": "DATE(${1:year},${2: month},${3: day})", "req_param": [ "year", "month", @@ -1121,6 +1345,8 @@ }, { "func_name": "DATEDIF", + "is_nullary": false, + "comp_str": "DATEDIF(${1:start_date},${2: end_date},${3: unit})", "req_param": [ "start_date", "end_date", @@ -1131,6 +1357,8 @@ }, { "func_name": "DATEVALUE", + "is_nullary": false, + "comp_str": "DATEVALUE(${1:date_text})", "req_param": [ "date_text" ], @@ -1139,6 +1367,8 @@ }, { "func_name": "DAVERAGE", + "is_nullary": false, + "comp_str": "DAVERAGE(${1:database},${2: field},${3: criteria})", "req_param": [ "database", "field", @@ -1149,6 +1379,8 @@ }, { "func_name": "DAY", + "is_nullary": false, + "comp_str": "DAY(${1:serial_number})", "req_param": [ "serial_number" ], @@ -1157,6 +1389,8 @@ }, { "func_name": "DAYS", + "is_nullary": false, + "comp_str": "DAYS(${1:end_date},${2: start_date})", "req_param": [ "end_date", "start_date" @@ -1166,6 +1400,8 @@ }, { "func_name": "DAYS360", + "is_nullary": false, + "comp_str": "DAYS360(${1:start_date},${2: end_date}${3:,${4: [method]}})", "req_param": [ "start_date", "end_date" @@ -1177,6 +1413,8 @@ }, { "func_name": "DB", + "is_nullary": false, + "comp_str": "DB(${1:cost},${2: salvage},${3: life},${4: period}${5:,${6: [month]}})", "req_param": [ "cost", "salvage", @@ -1190,6 +1428,8 @@ }, { "func_name": "DBCS", + "is_nullary": false, + "comp_str": "DBCS(${1:text})", "req_param": [ "text" ], @@ -1198,6 +1438,8 @@ }, { "func_name": "DCOUNT", + "is_nullary": false, + "comp_str": "DCOUNT(${1:database},${2: field},${3: criteria})", "req_param": [ "database", "field", @@ -1208,6 +1450,8 @@ }, { "func_name": "DCOUNTA", + "is_nullary": false, + "comp_str": "DCOUNTA(${1:database},${2: field},${3: criteria})", "req_param": [ "database", "field", @@ -1218,6 +1462,8 @@ }, { "func_name": "DDB", + "is_nullary": false, + "comp_str": "DDB(${1:cost},${2: salvage},${3: life},${4: period}${5:,${6: [factor]}})", "req_param": [ "cost", "salvage", @@ -1231,6 +1477,8 @@ }, { "func_name": "DEC2BIN", + "is_nullary": false, + "comp_str": "DEC2BIN(${1:number}${2:,${3: [places]}})", "req_param": [ "number" ], @@ -1241,6 +1489,8 @@ }, { "func_name": "DEC2HEX", + "is_nullary": false, + "comp_str": "DEC2HEX(${1:number}${2:,${3: [places]}})", "req_param": [ "number" ], @@ -1251,6 +1501,8 @@ }, { "func_name": "DEC2OCT", + "is_nullary": false, + "comp_str": "DEC2OCT(${1:number}${2:,${3: [places]}})", "req_param": [ "number" ], @@ -1261,6 +1513,8 @@ }, { "func_name": "DECIMAL", + "is_nullary": false, + "comp_str": "DECIMAL(${1:number},${2: radix})", "req_param": [ "number", "radix" @@ -1270,6 +1524,8 @@ }, { "func_name": "DEGREES", + "is_nullary": false, + "comp_str": "DEGREES(${1:angle})", "req_param": [ "angle" ], @@ -1278,6 +1534,8 @@ }, { "func_name": "DELTA", + "is_nullary": false, + "comp_str": "DELTA(${1:number1}${2:,${3: [number2]}})", "req_param": [ "number1" ], @@ -1288,6 +1546,8 @@ }, { "func_name": "DEVSQ", + "is_nullary": false, + "comp_str": "DEVSQ(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -1298,6 +1558,8 @@ }, { "func_name": "DGET", + "is_nullary": false, + "comp_str": "DGET(${1:database},${2: field},${3: criteria})", "req_param": [ "database", "field", @@ -1308,6 +1570,8 @@ }, { "func_name": "DISC", + "is_nullary": false, + "comp_str": "DISC(${1:settlement},${2: maturity},${3: pr},${4: redemption}${5:,${6: [basis]}})", "req_param": [ "settlement", "maturity", @@ -1321,6 +1585,8 @@ }, { "func_name": "DMAX", + "is_nullary": false, + "comp_str": "DMAX(${1:database},${2: field},${3: criteria})", "req_param": [ "database", "field", @@ -1331,6 +1597,8 @@ }, { "func_name": "DMIN", + "is_nullary": false, + "comp_str": "DMIN(${1:database},${2: field},${3: criteria})", "req_param": [ "database", "field", @@ -1341,6 +1609,8 @@ }, { "func_name": "DOLLAR", + "is_nullary": false, + "comp_str": "DOLLAR(${1:number}${2:,${3: [decimals]}})", "req_param": [ "number" ], @@ -1351,6 +1621,8 @@ }, { "func_name": "DOLLARDE", + "is_nullary": false, + "comp_str": "DOLLARDE(${1:fractional_dollar},${2: fraction})", "req_param": [ "fractional_dollar", "fraction" @@ -1360,6 +1632,8 @@ }, { "func_name": "DOLLARFR", + "is_nullary": false, + "comp_str": "DOLLARFR(${1:decimal_dollar},${2: fraction})", "req_param": [ "decimal_dollar", "fraction" @@ -1369,6 +1643,8 @@ }, { "func_name": "DPRODUCT", + "is_nullary": false, + "comp_str": "DPRODUCT(${1:database},${2: field},${3: criteria})", "req_param": [ "database", "field", @@ -1379,6 +1655,8 @@ }, { "func_name": "DROP", + "is_nullary": false, + "comp_str": "DROP(${1:array},${2: rows}${3:,${4: [columns]}})", "req_param": [ "array", "rows" @@ -1390,6 +1668,8 @@ }, { "func_name": "DSTDEV", + "is_nullary": false, + "comp_str": "DSTDEV(${1:database},${2: field},${3: criteria})", "req_param": [ "database", "field", @@ -1400,6 +1680,8 @@ }, { "func_name": "DSTDEVP", + "is_nullary": false, + "comp_str": "DSTDEVP(${1:database},${2: field},${3: criteria})", "req_param": [ "database", "field", @@ -1410,6 +1692,8 @@ }, { "func_name": "DSUM", + "is_nullary": false, + "comp_str": "DSUM(${1:database},${2: field},${3: criteria})", "req_param": [ "database", "field", @@ -1420,6 +1704,8 @@ }, { "func_name": "DURATION", + "is_nullary": false, + "comp_str": "DURATION(${1:settlement},${2: maturity},${3: coupon},${4: yld},${5: frequency}${6:,${7: [basis]}})", "req_param": [ "settlement", "maturity", @@ -1434,6 +1720,8 @@ }, { "func_name": "DVAR", + "is_nullary": false, + "comp_str": "DVAR(${1:database},${2: field},${3: criteria})", "req_param": [ "database", "field", @@ -1444,6 +1732,8 @@ }, { "func_name": "DVARP", + "is_nullary": false, + "comp_str": "DVARP(${1:database},${2: field},${3: criteria})", "req_param": [ "database", "field", @@ -1454,6 +1744,8 @@ }, { "func_name": "EDATE", + "is_nullary": false, + "comp_str": "EDATE(${1:start_date},${2: months})", "req_param": [ "start_date", "months" @@ -1463,6 +1755,8 @@ }, { "func_name": "EFFECT", + "is_nullary": false, + "comp_str": "EFFECT(${1:nominal_rate},${2: npery})", "req_param": [ "nominal_rate", "npery" @@ -1472,6 +1766,8 @@ }, { "func_name": "ENCODEURL", + "is_nullary": false, + "comp_str": "ENCODEURL(${1:text})", "req_param": [ "text" ], @@ -1480,6 +1776,8 @@ }, { "func_name": "EOMONTH", + "is_nullary": false, + "comp_str": "EOMONTH(${1:start_date},${2: months})", "req_param": [ "start_date", "months" @@ -1489,6 +1787,8 @@ }, { "func_name": "ERF", + "is_nullary": false, + "comp_str": "ERF(${1:lower_limit}${2:,${3: [upper_limit]}})", "req_param": [ "lower_limit" ], @@ -1499,6 +1799,8 @@ }, { "func_name": "ERF.PRECISE", + "is_nullary": false, + "comp_str": "ERF.PRECISE(${1:x})", "req_param": [ "x" ], @@ -1507,6 +1809,8 @@ }, { "func_name": "ERFC", + "is_nullary": false, + "comp_str": "ERFC(${1:x})", "req_param": [ "x" ], @@ -1515,6 +1819,8 @@ }, { "func_name": "ERFC.PRECISE", + "is_nullary": false, + "comp_str": "ERFC.PRECISE(${1:x})", "req_param": [ "x" ], @@ -1523,6 +1829,8 @@ }, { "func_name": "ERROR.TYPE", + "is_nullary": false, + "comp_str": "ERROR.TYPE(${1:error_val})", "req_param": [ "error_val" ], @@ -1531,6 +1839,8 @@ }, { "func_name": "EUROCONVERT", + "is_nullary": false, + "comp_str": "EUROCONVERT(${1:number},${2: source},${3: target},${4: full_precision},${5: triangulation_precision})", "req_param": [ "number", "source", @@ -1543,6 +1853,8 @@ }, { "func_name": "EVEN", + "is_nullary": false, + "comp_str": "EVEN(${1:number})", "req_param": [ "number" ], @@ -1551,6 +1863,8 @@ }, { "func_name": "EXACT", + "is_nullary": false, + "comp_str": "EXACT(${1:text1},${2: text2})", "req_param": [ "text1", "text2" @@ -1560,6 +1874,8 @@ }, { "func_name": "EXP", + "is_nullary": false, + "comp_str": "EXP(${1:number})", "req_param": [ "number" ], @@ -1568,6 +1884,8 @@ }, { "func_name": "EXPAND", + "is_nullary": false, + "comp_str": "EXPAND(${1:array},${2: rows}${3:,${4: [columns]},${5: [pad_with]}})", "req_param": [ "array", "rows" @@ -1580,6 +1898,8 @@ }, { "func_name": "EXPON.DIST", + "is_nullary": false, + "comp_str": "EXPON.DIST(${1:x},${2: lambda},${3: cumulative})", "req_param": [ "x", "lambda", @@ -1590,6 +1910,8 @@ }, { "func_name": "EXPONDIST", + "is_nullary": false, + "comp_str": "EXPONDIST(${1:x},${2: lambda},${3: cumulative})", "req_param": [ "x", "lambda", @@ -1600,6 +1922,8 @@ }, { "func_name": "F.DIST", + "is_nullary": false, + "comp_str": "F.DIST(${1:x},${2: deg_freedom1},${3: deg_freedom2},${4: cumulative})", "req_param": [ "x", "deg_freedom1", @@ -1611,6 +1935,8 @@ }, { "func_name": "F.DIST.RT", + "is_nullary": false, + "comp_str": "F.DIST.RT(${1:x},${2: deg_freedom1},${3: deg_freedom2})", "req_param": [ "x", "deg_freedom1", @@ -1621,6 +1947,8 @@ }, { "func_name": "F.INV", + "is_nullary": false, + "comp_str": "F.INV(${1:probability},${2: deg_freedom1},${3: deg_freedom2})", "req_param": [ "probability", "deg_freedom1", @@ -1631,6 +1959,8 @@ }, { "func_name": "F.INV.RT", + "is_nullary": false, + "comp_str": "F.INV.RT(${1:probability},${2: deg_freedom1},${3: deg_freedom2})", "req_param": [ "probability", "deg_freedom1", @@ -1641,6 +1971,8 @@ }, { "func_name": "F.TEST", + "is_nullary": false, + "comp_str": "F.TEST(${1:array1},${2: array2})", "req_param": [ "array1", "array2" @@ -1650,6 +1982,8 @@ }, { "func_name": "FACT", + "is_nullary": false, + "comp_str": "FACT(${1:number})", "req_param": [ "number" ], @@ -1658,6 +1992,8 @@ }, { "func_name": "FACTDOUBLE", + "is_nullary": false, + "comp_str": "FACTDOUBLE(${1:number})", "req_param": [ "number" ], @@ -1666,6 +2002,8 @@ }, { "func_name": "FDIST", + "is_nullary": false, + "comp_str": "FDIST(${1:x},${2: deg_freedom1},${3: deg_freedom2})", "req_param": [ "x", "deg_freedom1", @@ -1676,6 +2014,8 @@ }, { "func_name": "FILTER", + "is_nullary": false, + "comp_str": "FILTER(${1:array},${2: include}${3:,${4: [if_empty]}})", "req_param": [ "array", "include" @@ -1687,6 +2027,8 @@ }, { "func_name": "FILTERXML", + "is_nullary": false, + "comp_str": "FILTERXML(${1:xml},${2: xpath})", "req_param": [ "xml", "xpath" @@ -1696,6 +2038,8 @@ }, { "func_name": "FIND", + "is_nullary": false, + "comp_str": "FIND(${1:find_text},${2: within_text}${3:,${4: [start_num]}})", "req_param": [ "find_text", "within_text" @@ -1707,6 +2051,8 @@ }, { "func_name": "FINDB", + "is_nullary": false, + "comp_str": "FINDB(${1:find_text},${2: within_text}${3:,${4: [start_num]}})", "req_param": [ "find_text", "within_text" @@ -1718,6 +2064,8 @@ }, { "func_name": "FINV", + "is_nullary": false, + "comp_str": "FINV(${1:probability},${2: deg_freedom1},${3: deg_freedom2})", "req_param": [ "probability", "deg_freedom1", @@ -1728,6 +2076,8 @@ }, { "func_name": "FISHER", + "is_nullary": false, + "comp_str": "FISHER(${1:x})", "req_param": [ "x" ], @@ -1736,6 +2086,8 @@ }, { "func_name": "FISHERINV", + "is_nullary": false, + "comp_str": "FISHERINV(${1:y})", "req_param": [ "y" ], @@ -1744,6 +2096,8 @@ }, { "func_name": "FIXED", + "is_nullary": false, + "comp_str": "FIXED(${1:number}${2:,${3: [decimals]},${4: [no_commas]}})", "req_param": [ "number" ], @@ -1755,6 +2109,8 @@ }, { "func_name": "FLOOR", + "is_nullary": false, + "comp_str": "FLOOR(${1:number},${2: significance})", "req_param": [ "number", "significance" @@ -1764,6 +2120,8 @@ }, { "func_name": "FLOOR.MATH", + "is_nullary": false, + "comp_str": "FLOOR.MATH(${1:number}${2:,${3: [significance]},${4: [mode]}})", "req_param": [ "number" ], @@ -1775,6 +2133,8 @@ }, { "func_name": "FLOOR.PRECISE", + "is_nullary": false, + "comp_str": "FLOOR.PRECISE(${1:number}${2:,${3: [significance]}})", "req_param": [ "number" ], @@ -1785,6 +2145,8 @@ }, { "func_name": "FORECAST", + "is_nullary": false, + "comp_str": "FORECAST(${1:x},${2: known_ys},${3: known_xs})", "req_param": [ "x", "known_ys", @@ -1795,6 +2157,8 @@ }, { "func_name": "FORECAST.ETS", + "is_nullary": false, + "comp_str": "FORECAST.ETS(${1:target_date},${2: values},${3: timeline}${4:,${5: [seasonality]},${6: [data_completion]},${7: [aggregation]}})", "req_param": [ "target_date", "values", @@ -1809,6 +2173,8 @@ }, { "func_name": "FORECAST.ETS.CONFINT", + "is_nullary": false, + "comp_str": "FORECAST.ETS.CONFINT(${1:target_date},${2: values},${3: timeline}${4:,${5: [confidence_level]},${6: [seasonality]},${7: [data_completion]},${8: [aggregation]}})", "req_param": [ "target_date", "values", @@ -1824,6 +2190,8 @@ }, { "func_name": "FORECAST.ETS.SEASONALITY", + "is_nullary": false, + "comp_str": "FORECAST.ETS.SEASONALITY(${1:values},${2: timeline}${3:,${4: [data_completion]},${5: [aggregation]}})", "req_param": [ "values", "timeline" @@ -1836,6 +2204,8 @@ }, { "func_name": "FORECAST.ETS.STAT", + "is_nullary": false, + "comp_str": "FORECAST.ETS.STAT(${1:values},${2: timeline},${3: statistic_type}${4:,${5: [seasonality]},${6: [data_completion]},${7: [aggregation]}})", "req_param": [ "values", "timeline", @@ -1850,6 +2220,8 @@ }, { "func_name": "FORECAST.LINEAR", + "is_nullary": false, + "comp_str": "FORECAST.LINEAR(${1:x},${2: known_ys},${3: known_xs})", "req_param": [ "x", "known_ys", @@ -1860,6 +2232,8 @@ }, { "func_name": "FORMULATEXT", + "is_nullary": false, + "comp_str": "FORMULATEXT(${1:reference})", "req_param": [ "reference" ], @@ -1868,6 +2242,8 @@ }, { "func_name": "FREQUENCY", + "is_nullary": false, + "comp_str": "FREQUENCY(${1:data_array},${2: bins_array})", "req_param": [ "data_array", "bins_array" @@ -1877,6 +2253,8 @@ }, { "func_name": "FTEST", + "is_nullary": false, + "comp_str": "FTEST(${1:array1},${2: array2})", "req_param": [ "array1", "array2" @@ -1886,6 +2264,8 @@ }, { "func_name": "FV", + "is_nullary": false, + "comp_str": "FV(${1:rate},${2: nper},${3: pmt}${4:,${5: [pv]},${6: [type]}})", "req_param": [ "rate", "nper", @@ -1899,6 +2279,8 @@ }, { "func_name": "FVSCHEDULE", + "is_nullary": false, + "comp_str": "FVSCHEDULE(${1:principal},${2: schedule})", "req_param": [ "principal", "schedule" @@ -1908,6 +2290,8 @@ }, { "func_name": "GAMMA", + "is_nullary": false, + "comp_str": "GAMMA(${1:x})", "req_param": [ "x" ], @@ -1916,6 +2300,8 @@ }, { "func_name": "GAMMA.DIST", + "is_nullary": false, + "comp_str": "GAMMA.DIST(${1:x},${2: alpha},${3: beta},${4: cumulative})", "req_param": [ "x", "alpha", @@ -1927,6 +2313,8 @@ }, { "func_name": "GAMMA.INV", + "is_nullary": false, + "comp_str": "GAMMA.INV(${1:probability},${2: alpha},${3: beta})", "req_param": [ "probability", "alpha", @@ -1937,6 +2325,8 @@ }, { "func_name": "GAMMADIST", + "is_nullary": false, + "comp_str": "GAMMADIST(${1:x},${2: alpha},${3: beta},${4: cumulative})", "req_param": [ "x", "alpha", @@ -1948,6 +2338,8 @@ }, { "func_name": "GAMMAINV", + "is_nullary": false, + "comp_str": "GAMMAINV(${1:probability},${2: alpha},${3: beta})", "req_param": [ "probability", "alpha", @@ -1958,6 +2350,8 @@ }, { "func_name": "GAMMALN", + "is_nullary": false, + "comp_str": "GAMMALN(${1:x})", "req_param": [ "x" ], @@ -1966,6 +2360,8 @@ }, { "func_name": "GAMMALN.PRECISE", + "is_nullary": false, + "comp_str": "GAMMALN.PRECISE(${1:x})", "req_param": [ "x" ], @@ -1974,6 +2370,8 @@ }, { "func_name": "GAUSS", + "is_nullary": false, + "comp_str": "GAUSS(${1:x})", "req_param": [ "x" ], @@ -1982,6 +2380,8 @@ }, { "func_name": "GCD", + "is_nullary": false, + "comp_str": "GCD(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -1992,6 +2392,8 @@ }, { "func_name": "GEOMEAN", + "is_nullary": false, + "comp_str": "GEOMEAN(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -2002,6 +2404,8 @@ }, { "func_name": "GESTEP", + "is_nullary": false, + "comp_str": "GESTEP(${1:number}${2:,${3: [step]}})", "req_param": [ "number" ], @@ -2012,6 +2416,8 @@ }, { "func_name": "GETPIVOTDATA", + "is_nullary": false, + "comp_str": "GETPIVOTDATA(${1:data_field},${2: pivot_table}${3:,${4: [field1]},${5: [item1], ...}})", "req_param": [ "data_field", "pivot_table" @@ -2024,6 +2430,8 @@ }, { "func_name": "GROWTH", + "is_nullary": false, + "comp_str": "GROWTH(${1:known_ys}${2:,${3: [known_xs]},${4: [new_xs]},${5: [const]}})", "req_param": [ "known_ys" ], @@ -2036,6 +2444,8 @@ }, { "func_name": "HARMEAN", + "is_nullary": false, + "comp_str": "HARMEAN(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -2046,6 +2456,8 @@ }, { "func_name": "HEX2BIN", + "is_nullary": false, + "comp_str": "HEX2BIN(${1:number}${2:,${3: [places]}})", "req_param": [ "number" ], @@ -2056,6 +2468,8 @@ }, { "func_name": "HEX2DEC", + "is_nullary": false, + "comp_str": "HEX2DEC(${1:number})", "req_param": [ "number" ], @@ -2064,6 +2478,8 @@ }, { "func_name": "HEX2OCT", + "is_nullary": false, + "comp_str": "HEX2OCT(${1:number}${2:,${3: [places]}})", "req_param": [ "number" ], @@ -2074,6 +2490,8 @@ }, { "func_name": "HLOOKUP", + "is_nullary": false, + "comp_str": "HLOOKUP(${1:lookup_value},${2: table_array},${3: row_index_num}${4:,${5: [range_lookup]}})", "req_param": [ "lookup_value", "table_array", @@ -2086,6 +2504,8 @@ }, { "func_name": "HOUR", + "is_nullary": false, + "comp_str": "HOUR(${1:serial_number})", "req_param": [ "serial_number" ], @@ -2094,6 +2514,8 @@ }, { "func_name": "HSTACK", + "is_nullary": false, + "comp_str": "HSTACK(${1:array1}${2:,${3: [array2], ...}})", "req_param": [ "array1" ], @@ -2104,6 +2526,8 @@ }, { "func_name": "HYPERLINK", + "is_nullary": false, + "comp_str": "HYPERLINK(${1:link_location}${2:,${3: [friendly_name]}})", "req_param": [ "link_location" ], @@ -2114,6 +2538,8 @@ }, { "func_name": "HYPGEOM.DIST", + "is_nullary": false, + "comp_str": "HYPGEOM.DIST(${1:sample_s},${2: number_sample},${3: population_s},${4: number_pop},${5: cumulative})", "req_param": [ "sample_s", "number_sample", @@ -2126,6 +2552,8 @@ }, { "func_name": "HYPGEOMDIST", + "is_nullary": false, + "comp_str": "HYPGEOMDIST(${1:sample_s},${2: number_sample},${3: population_s},${4: number_pop})", "req_param": [ "sample_s", "number_sample", @@ -2137,6 +2565,8 @@ }, { "func_name": "IF", + "is_nullary": false, + "comp_str": "IF(${1:logical_test}${2:,${3: [value_if_true]},${4: [value_if_false]}})", "req_param": [ "logical_test" ], @@ -2148,6 +2578,8 @@ }, { "func_name": "IFERROR", + "is_nullary": false, + "comp_str": "IFERROR(${1:value},${2: value_if_error})", "req_param": [ "value", "value_if_error" @@ -2157,6 +2589,8 @@ }, { "func_name": "IFNA", + "is_nullary": false, + "comp_str": "IFNA(${1:value},${2: value_if_na})", "req_param": [ "value", "value_if_na" @@ -2166,6 +2600,8 @@ }, { "func_name": "IFS", + "is_nullary": false, + "comp_str": "IFS(${1:logical_test1},${2: value_if_true1}${3:,${4: [logical_test2]},${5: [value_if_true2], ...}})", "req_param": [ "logical_test1", "value_if_true1" @@ -2178,6 +2614,8 @@ }, { "func_name": "IMABS", + "is_nullary": false, + "comp_str": "IMABS(${1:inumber})", "req_param": [ "inumber" ], @@ -2186,6 +2624,8 @@ }, { "func_name": "IMAGE", + "is_nullary": false, + "comp_str": "IMAGE(${1:source}${2:,${3: [alt_text]},${4: [sizing]},${5: [height]},${6: [width]}})", "req_param": [ "source" ], @@ -2199,6 +2639,8 @@ }, { "func_name": "IMAGINARY", + "is_nullary": false, + "comp_str": "IMAGINARY(${1:inumber})", "req_param": [ "inumber" ], @@ -2207,6 +2649,8 @@ }, { "func_name": "IMARGUMENT", + "is_nullary": false, + "comp_str": "IMARGUMENT(${1:inumber})", "req_param": [ "inumber" ], @@ -2215,6 +2659,8 @@ }, { "func_name": "IMCONJUGATE", + "is_nullary": false, + "comp_str": "IMCONJUGATE(${1:inumber})", "req_param": [ "inumber" ], @@ -2223,6 +2669,8 @@ }, { "func_name": "IMCOS", + "is_nullary": false, + "comp_str": "IMCOS(${1:inumber})", "req_param": [ "inumber" ], @@ -2231,6 +2679,8 @@ }, { "func_name": "IMCOSH", + "is_nullary": false, + "comp_str": "IMCOSH(${1:inumber})", "req_param": [ "inumber" ], @@ -2239,6 +2689,8 @@ }, { "func_name": "IMCOT", + "is_nullary": false, + "comp_str": "IMCOT(${1:inumber})", "req_param": [ "inumber" ], @@ -2247,6 +2699,8 @@ }, { "func_name": "IMCSC", + "is_nullary": false, + "comp_str": "IMCSC(${1:inumber})", "req_param": [ "inumber" ], @@ -2255,6 +2709,8 @@ }, { "func_name": "IMCSCH", + "is_nullary": false, + "comp_str": "IMCSCH(${1:inumber})", "req_param": [ "inumber" ], @@ -2263,6 +2719,8 @@ }, { "func_name": "IMDIV", + "is_nullary": false, + "comp_str": "IMDIV(${1:inumber1},${2: inumber2})", "req_param": [ "inumber1", "inumber2" @@ -2272,6 +2730,8 @@ }, { "func_name": "IMEXP", + "is_nullary": false, + "comp_str": "IMEXP(${1:inumber})", "req_param": [ "inumber" ], @@ -2280,6 +2740,8 @@ }, { "func_name": "IMLN", + "is_nullary": false, + "comp_str": "IMLN(${1:inumber})", "req_param": [ "inumber" ], @@ -2288,6 +2750,8 @@ }, { "func_name": "IMLOG10", + "is_nullary": false, + "comp_str": "IMLOG10(${1:inumber})", "req_param": [ "inumber" ], @@ -2296,6 +2760,8 @@ }, { "func_name": "IMLOG2", + "is_nullary": false, + "comp_str": "IMLOG2(${1:inumber})", "req_param": [ "inumber" ], @@ -2304,6 +2770,8 @@ }, { "func_name": "IMPOWER", + "is_nullary": false, + "comp_str": "IMPOWER(${1:inumber},${2: number})", "req_param": [ "inumber", "number" @@ -2313,6 +2781,8 @@ }, { "func_name": "IMPRODUCT", + "is_nullary": false, + "comp_str": "IMPRODUCT(${1:inumber1}${2:,${3: [inumber2], ...}})", "req_param": [ "inumber1" ], @@ -2323,6 +2793,8 @@ }, { "func_name": "IMREAL", + "is_nullary": false, + "comp_str": "IMREAL(${1:inumber})", "req_param": [ "inumber" ], @@ -2331,6 +2803,8 @@ }, { "func_name": "IMSEC", + "is_nullary": false, + "comp_str": "IMSEC(${1:inumber})", "req_param": [ "inumber" ], @@ -2339,6 +2813,8 @@ }, { "func_name": "IMSECH", + "is_nullary": false, + "comp_str": "IMSECH(${1:inumber})", "req_param": [ "inumber" ], @@ -2347,6 +2823,8 @@ }, { "func_name": "IMSIN", + "is_nullary": false, + "comp_str": "IMSIN(${1:inumber})", "req_param": [ "inumber" ], @@ -2355,6 +2833,8 @@ }, { "func_name": "IMSINH", + "is_nullary": false, + "comp_str": "IMSINH(${1:inumber})", "req_param": [ "inumber" ], @@ -2363,6 +2843,8 @@ }, { "func_name": "IMSQRT", + "is_nullary": false, + "comp_str": "IMSQRT(${1:inumber})", "req_param": [ "inumber" ], @@ -2371,6 +2853,8 @@ }, { "func_name": "IMSUB", + "is_nullary": false, + "comp_str": "IMSUB(${1:inumber1},${2: inumber2})", "req_param": [ "inumber1", "inumber2" @@ -2380,6 +2864,8 @@ }, { "func_name": "IMSUM", + "is_nullary": false, + "comp_str": "IMSUM(${1:inumber1}${2:,${3: [inumber2], ...}})", "req_param": [ "inumber1" ], @@ -2390,6 +2876,8 @@ }, { "func_name": "IMTAN", + "is_nullary": false, + "comp_str": "IMTAN(${1:inumber})", "req_param": [ "inumber" ], @@ -2398,6 +2886,8 @@ }, { "func_name": "INDEX", + "is_nullary": false, + "comp_str": "INDEX(${1:array},${2: row_num}${3:,${4: [column_num]}})", "req_param": [ "array", "row_num" @@ -2409,6 +2899,8 @@ }, { "func_name": "INDIRECT", + "is_nullary": false, + "comp_str": "INDIRECT(${1:ref_text}${2:,${3: [a1]}})", "req_param": [ "ref_text" ], @@ -2419,6 +2911,8 @@ }, { "func_name": "INFO", + "is_nullary": false, + "comp_str": "INFO(${1:type_text})", "req_param": [ "type_text" ], @@ -2427,6 +2921,8 @@ }, { "func_name": "INT", + "is_nullary": false, + "comp_str": "INT(${1:number})", "req_param": [ "number" ], @@ -2435,6 +2931,8 @@ }, { "func_name": "INTERCEPT", + "is_nullary": false, + "comp_str": "INTERCEPT(${1:known_ys},${2: known_xs})", "req_param": [ "known_ys", "known_xs" @@ -2444,6 +2942,8 @@ }, { "func_name": "INTRATE", + "is_nullary": false, + "comp_str": "INTRATE(${1:settlement},${2: maturity},${3: investment},${4: redemption}${5:,${6: [basis]}})", "req_param": [ "settlement", "maturity", @@ -2457,6 +2957,8 @@ }, { "func_name": "IPMT", + "is_nullary": false, + "comp_str": "IPMT(${1:rate},${2: per},${3: nper},${4: pv}${5:,${6: [fv]},${7: [type]}})", "req_param": [ "rate", "per", @@ -2471,6 +2973,8 @@ }, { "func_name": "IRR", + "is_nullary": false, + "comp_str": "IRR(${1:values}${2:,${3: [guess]}})", "req_param": [ "values" ], @@ -2481,6 +2985,8 @@ }, { "func_name": "ISBLANK", + "is_nullary": false, + "comp_str": "ISBLANK(${1:value})", "req_param": [ "value" ], @@ -2489,6 +2995,8 @@ }, { "func_name": "ISERR", + "is_nullary": false, + "comp_str": "ISERR(${1:value})", "req_param": [ "value" ], @@ -2497,6 +3005,8 @@ }, { "func_name": "ISERROR", + "is_nullary": false, + "comp_str": "ISERROR(${1:value})", "req_param": [ "value" ], @@ -2505,6 +3015,8 @@ }, { "func_name": "ISEVEN", + "is_nullary": false, + "comp_str": "ISEVEN(${1:number})", "req_param": [ "number" ], @@ -2513,6 +3025,8 @@ }, { "func_name": "ISFORMULA", + "is_nullary": false, + "comp_str": "ISFORMULA(${1:reference})", "req_param": [ "reference" ], @@ -2521,6 +3035,8 @@ }, { "func_name": "ISLOGICAL", + "is_nullary": false, + "comp_str": "ISLOGICAL(${1:value})", "req_param": [ "value" ], @@ -2529,6 +3045,8 @@ }, { "func_name": "ISNA", + "is_nullary": false, + "comp_str": "ISNA(${1:value})", "req_param": [ "value" ], @@ -2537,6 +3055,8 @@ }, { "func_name": "ISNONTEXT", + "is_nullary": false, + "comp_str": "ISNONTEXT(${1:value})", "req_param": [ "value" ], @@ -2545,6 +3065,8 @@ }, { "func_name": "ISNUMBER", + "is_nullary": false, + "comp_str": "ISNUMBER(${1:value})", "req_param": [ "value" ], @@ -2553,6 +3075,8 @@ }, { "func_name": "ISO.CEILING", + "is_nullary": false, + "comp_str": "ISO.CEILING(${1:number}${2:,${3: [significance]}})", "req_param": [ "number" ], @@ -2563,6 +3087,8 @@ }, { "func_name": "ISODD", + "is_nullary": false, + "comp_str": "ISODD(${1:number})", "req_param": [ "number" ], @@ -2571,6 +3097,8 @@ }, { "func_name": "ISOMITTED", + "is_nullary": false, + "comp_str": "ISOMITTED(${1:argument})", "req_param": [ "argument" ], @@ -2579,6 +3107,8 @@ }, { "func_name": "ISOWEEKNUM", + "is_nullary": false, + "comp_str": "ISOWEEKNUM(${1:date})", "req_param": [ "date" ], @@ -2587,6 +3117,8 @@ }, { "func_name": "ISPMT", + "is_nullary": false, + "comp_str": "ISPMT(${1:rate},${2: per},${3: nper},${4: pv})", "req_param": [ "rate", "per", @@ -2598,6 +3130,8 @@ }, { "func_name": "ISREF", + "is_nullary": false, + "comp_str": "ISREF(${1:value})", "req_param": [ "value" ], @@ -2606,6 +3140,8 @@ }, { "func_name": "ISTEXT", + "is_nullary": false, + "comp_str": "ISTEXT(${1:value})", "req_param": [ "value" ], @@ -2614,6 +3150,8 @@ }, { "func_name": "JIS", + "is_nullary": false, + "comp_str": "JIS(${1:text})", "req_param": [ "text" ], @@ -2622,6 +3160,8 @@ }, { "func_name": "KURT", + "is_nullary": false, + "comp_str": "KURT(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -2632,6 +3172,8 @@ }, { "func_name": "LAMBDA", + "is_nullary": false, + "comp_str": "LAMBDA(${1:parameter_or_calculation1}${2:,${3: [parameter_or_calculation2], ...}})", "req_param": [ "parameter_or_calculation1" ], @@ -2642,6 +3184,8 @@ }, { "func_name": "LARGE", + "is_nullary": false, + "comp_str": "LARGE(${1:array},${2: k})", "req_param": [ "array", "k" @@ -2651,6 +3195,8 @@ }, { "func_name": "LCM", + "is_nullary": false, + "comp_str": "LCM(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -2661,6 +3207,8 @@ }, { "func_name": "LEFT", + "is_nullary": false, + "comp_str": "LEFT(${1:text}${2:,${3: [num_chars]}})", "req_param": [ "text" ], @@ -2671,6 +3219,8 @@ }, { "func_name": "LEFTB", + "is_nullary": false, + "comp_str": "LEFTB(${1:text}${2:,${3: [num_bytes]}})", "req_param": [ "text" ], @@ -2681,6 +3231,8 @@ }, { "func_name": "LEN", + "is_nullary": false, + "comp_str": "LEN(${1:text})", "req_param": [ "text" ], @@ -2689,6 +3241,8 @@ }, { "func_name": "LENB", + "is_nullary": false, + "comp_str": "LENB(${1:text})", "req_param": [ "text" ], @@ -2697,6 +3251,8 @@ }, { "func_name": "LET", + "is_nullary": false, + "comp_str": "LET(${1:name1},${2: name_value1},${3: calculation_or_name2}${4:,${5: [name_value2], ...}})", "req_param": [ "name1", "name_value1", @@ -2709,6 +3265,8 @@ }, { "func_name": "LINEST", + "is_nullary": false, + "comp_str": "LINEST(${1:known_ys}${2:,${3: [known_xs]},${4: [const]},${5: [stats]}})", "req_param": [ "known_ys" ], @@ -2721,6 +3279,8 @@ }, { "func_name": "LN", + "is_nullary": false, + "comp_str": "LN(${1:number})", "req_param": [ "number" ], @@ -2729,6 +3289,8 @@ }, { "func_name": "LOG", + "is_nullary": false, + "comp_str": "LOG(${1:number}${2:,${3: [base]}})", "req_param": [ "number" ], @@ -2739,6 +3301,8 @@ }, { "func_name": "LOG10", + "is_nullary": false, + "comp_str": "LOG10(${1:number})", "req_param": [ "number" ], @@ -2747,6 +3311,8 @@ }, { "func_name": "LOGEST", + "is_nullary": false, + "comp_str": "LOGEST(${1:known_ys}${2:,${3: [known_xs]},${4: [const]},${5: [stats]}})", "req_param": [ "known_ys" ], @@ -2759,6 +3325,8 @@ }, { "func_name": "LOGINV", + "is_nullary": false, + "comp_str": "LOGINV(${1:probability},${2: mean},${3: standard_dev})", "req_param": [ "probability", "mean", @@ -2769,6 +3337,8 @@ }, { "func_name": "LOGNORM.DIST", + "is_nullary": false, + "comp_str": "LOGNORM.DIST(${1:x},${2: mean},${3: standard_dev},${4: cumulative})", "req_param": [ "x", "mean", @@ -2780,6 +3350,8 @@ }, { "func_name": "LOGNORM.INV", + "is_nullary": false, + "comp_str": "LOGNORM.INV(${1:probability},${2: mean},${3: standard_dev})", "req_param": [ "probability", "mean", @@ -2790,6 +3362,8 @@ }, { "func_name": "LOGNORMDIST", + "is_nullary": false, + "comp_str": "LOGNORMDIST(${1:x},${2: mean},${3: standard_dev})", "req_param": [ "x", "mean", @@ -2800,6 +3374,8 @@ }, { "func_name": "LOOKUP", + "is_nullary": false, + "comp_str": "LOOKUP(${1:lookup_value},${2: lookup_vector}${3:,${4: [result_vector]}})", "req_param": [ "lookup_value", "lookup_vector" @@ -2811,6 +3387,8 @@ }, { "func_name": "LOWER", + "is_nullary": false, + "comp_str": "LOWER(${1:text})", "req_param": [ "text" ], @@ -2819,6 +3397,8 @@ }, { "func_name": "MAKEARRAY", + "is_nullary": false, + "comp_str": "MAKEARRAY(${1:rows},${2: columns},${3: function})", "req_param": [ "rows", "columns", @@ -2829,6 +3409,8 @@ }, { "func_name": "MAP", + "is_nullary": false, + "comp_str": "MAP(${1:array},${2: lambda_or_array2}${3:,${4: [lambda_or_array3], ...}})", "req_param": [ "array", "lambda_or_array2" @@ -2840,6 +3422,8 @@ }, { "func_name": "MATCH", + "is_nullary": false, + "comp_str": "MATCH(${1:lookup_value},${2: lookup_array}${3:,${4: [match_type]}})", "req_param": [ "lookup_value", "lookup_array" @@ -2851,6 +3435,8 @@ }, { "func_name": "MAX", + "is_nullary": false, + "comp_str": "MAX(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -2861,6 +3447,8 @@ }, { "func_name": "MAXA", + "is_nullary": false, + "comp_str": "MAXA(${1:value1}${2:,${3: [value2], ...}})", "req_param": [ "value1" ], @@ -2871,6 +3459,8 @@ }, { "func_name": "MAXIFS", + "is_nullary": false, + "comp_str": "MAXIFS(${1:max_range},${2: criteria_range1},${3: criteria1}${4:,${5: [criteria_range2]},${6: [criteria2], ...}})", "req_param": [ "max_range", "criteria_range1", @@ -2884,6 +3474,8 @@ }, { "func_name": "MDETERM", + "is_nullary": false, + "comp_str": "MDETERM(${1:array})", "req_param": [ "array" ], @@ -2892,6 +3484,8 @@ }, { "func_name": "MDURATION", + "is_nullary": false, + "comp_str": "MDURATION(${1:settlement},${2: maturity},${3: coupon},${4: yld},${5: frequency}${6:,${7: [basis]}})", "req_param": [ "settlement", "maturity", @@ -2906,6 +3500,8 @@ }, { "func_name": "MEDIAN", + "is_nullary": false, + "comp_str": "MEDIAN(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -2916,6 +3512,8 @@ }, { "func_name": "MID", + "is_nullary": false, + "comp_str": "MID(${1:text},${2: start_num},${3: num_chars})", "req_param": [ "text", "start_num", @@ -2926,6 +3524,8 @@ }, { "func_name": "MIDB", + "is_nullary": false, + "comp_str": "MIDB(${1:text},${2: start_num},${3: num_bytes})", "req_param": [ "text", "start_num", @@ -2936,6 +3536,8 @@ }, { "func_name": "MIN", + "is_nullary": false, + "comp_str": "MIN(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -2946,6 +3548,8 @@ }, { "func_name": "MINA", + "is_nullary": false, + "comp_str": "MINA(${1:value1}${2:,${3: [value2], ...}})", "req_param": [ "value1" ], @@ -2956,6 +3560,8 @@ }, { "func_name": "MINIFS", + "is_nullary": false, + "comp_str": "MINIFS(${1:min_range},${2: criteria_range1},${3: criteria1}${4:,${5: [criteria_range2]},${6: [criteria2], ...}})", "req_param": [ "min_range", "criteria_range1", @@ -2969,6 +3575,8 @@ }, { "func_name": "MINUTE", + "is_nullary": false, + "comp_str": "MINUTE(${1:serial_number})", "req_param": [ "serial_number" ], @@ -2977,6 +3585,8 @@ }, { "func_name": "MINVERSE", + "is_nullary": false, + "comp_str": "MINVERSE(${1:array})", "req_param": [ "array" ], @@ -2985,6 +3595,8 @@ }, { "func_name": "MIRR", + "is_nullary": false, + "comp_str": "MIRR(${1:values},${2: finance_rate},${3: reinvest_rate})", "req_param": [ "values", "finance_rate", @@ -2995,6 +3607,8 @@ }, { "func_name": "MMULT", + "is_nullary": false, + "comp_str": "MMULT(${1:array1},${2: array2})", "req_param": [ "array1", "array2" @@ -3004,6 +3618,8 @@ }, { "func_name": "MOD", + "is_nullary": false, + "comp_str": "MOD(${1:number},${2: divisor})", "req_param": [ "number", "divisor" @@ -3013,6 +3629,8 @@ }, { "func_name": "MODE", + "is_nullary": false, + "comp_str": "MODE(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -3023,6 +3641,8 @@ }, { "func_name": "MODE.MULT", + "is_nullary": false, + "comp_str": "MODE.MULT(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -3033,6 +3653,8 @@ }, { "func_name": "MODE.SNGL", + "is_nullary": false, + "comp_str": "MODE.SNGL(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -3043,6 +3665,8 @@ }, { "func_name": "MONTH", + "is_nullary": false, + "comp_str": "MONTH(${1:serial_number})", "req_param": [ "serial_number" ], @@ -3051,6 +3675,8 @@ }, { "func_name": "MROUND", + "is_nullary": false, + "comp_str": "MROUND(${1:number},${2: multiple})", "req_param": [ "number", "multiple" @@ -3060,6 +3686,8 @@ }, { "func_name": "MULTINOMIAL", + "is_nullary": false, + "comp_str": "MULTINOMIAL(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -3070,6 +3698,8 @@ }, { "func_name": "MUNIT", + "is_nullary": false, + "comp_str": "MUNIT(${1:dimension})", "req_param": [ "dimension" ], @@ -3078,6 +3708,8 @@ }, { "func_name": "N", + "is_nullary": false, + "comp_str": "N(${1:value})", "req_param": [ "value" ], @@ -3086,6 +3718,8 @@ }, { "func_name": "NEGBINOM.DIST", + "is_nullary": false, + "comp_str": "NEGBINOM.DIST(${1:number_f},${2: number_s},${3: probability_s},${4: cumulative})", "req_param": [ "number_f", "number_s", @@ -3097,6 +3731,8 @@ }, { "func_name": "NEGBINOMDIST", + "is_nullary": false, + "comp_str": "NEGBINOMDIST(${1:number_f},${2: number_s},${3: probability_s})", "req_param": [ "number_f", "number_s", @@ -3107,6 +3743,8 @@ }, { "func_name": "NETWORKDAYS", + "is_nullary": false, + "comp_str": "NETWORKDAYS(${1:start_date},${2: end_date}${3:,${4: [holidays]}})", "req_param": [ "start_date", "end_date" @@ -3118,6 +3756,8 @@ }, { "func_name": "NETWORKDAYS.INTL", + "is_nullary": false, + "comp_str": "NETWORKDAYS.INTL(${1:start_date},${2: end_date}${3:,${4: [weekend]},${5: [holidays]}})", "req_param": [ "start_date", "end_date" @@ -3130,6 +3770,8 @@ }, { "func_name": "NOMINAL", + "is_nullary": false, + "comp_str": "NOMINAL(${1:effect_rate},${2: npery})", "req_param": [ "effect_rate", "npery" @@ -3139,6 +3781,8 @@ }, { "func_name": "NORM.DIST", + "is_nullary": false, + "comp_str": "NORM.DIST(${1:x},${2: mean},${3: standard_dev},${4: cumulative})", "req_param": [ "x", "mean", @@ -3150,6 +3794,8 @@ }, { "func_name": "NORM.INV", + "is_nullary": false, + "comp_str": "NORM.INV(${1:probability},${2: mean},${3: standard_dev})", "req_param": [ "probability", "mean", @@ -3160,6 +3806,8 @@ }, { "func_name": "NORM.S.DIST", + "is_nullary": false, + "comp_str": "NORM.S.DIST(${1:z},${2: cumulative})", "req_param": [ "z", "cumulative" @@ -3169,6 +3817,8 @@ }, { "func_name": "NORM.S.INV", + "is_nullary": false, + "comp_str": "NORM.S.INV(${1:probability})", "req_param": [ "probability" ], @@ -3177,6 +3827,8 @@ }, { "func_name": "NORMDIST", + "is_nullary": false, + "comp_str": "NORMDIST(${1:x},${2: mean},${3: standard_dev},${4: cumulative})", "req_param": [ "x", "mean", @@ -3188,6 +3840,8 @@ }, { "func_name": "NORMINV", + "is_nullary": false, + "comp_str": "NORMINV(${1:probability},${2: mean},${3: standard_dev})", "req_param": [ "probability", "mean", @@ -3198,6 +3852,8 @@ }, { "func_name": "NORMSDIST", + "is_nullary": false, + "comp_str": "NORMSDIST(${1:z})", "req_param": [ "z" ], @@ -3206,6 +3862,8 @@ }, { "func_name": "NORMSINV", + "is_nullary": false, + "comp_str": "NORMSINV(${1:probability})", "req_param": [ "probability" ], @@ -3214,6 +3872,8 @@ }, { "func_name": "NOT", + "is_nullary": false, + "comp_str": "NOT(${1:logical})", "req_param": [ "logical" ], @@ -3222,6 +3882,8 @@ }, { "func_name": "NPER", + "is_nullary": false, + "comp_str": "NPER(${1:rate},${2: pmt},${3: pv}${4:,${5: [fv]},${6: [type]}})", "req_param": [ "rate", "pmt", @@ -3235,6 +3897,8 @@ }, { "func_name": "NPV", + "is_nullary": false, + "comp_str": "NPV(${1:rate},${2: value1}${3:,${4: [value2], ...}})", "req_param": [ "rate", "value1" @@ -3246,6 +3910,8 @@ }, { "func_name": "NUMBERVALUE", + "is_nullary": false, + "comp_str": "NUMBERVALUE(${1:text}${2:,${3: [decimal_separator]},${4: [group_separator]}})", "req_param": [ "text" ], @@ -3257,6 +3923,8 @@ }, { "func_name": "OCT2BIN", + "is_nullary": false, + "comp_str": "OCT2BIN(${1:number}${2:,${3: [places]}})", "req_param": [ "number" ], @@ -3267,6 +3935,8 @@ }, { "func_name": "OCT2DEC", + "is_nullary": false, + "comp_str": "OCT2DEC(${1:number})", "req_param": [ "number" ], @@ -3275,6 +3945,8 @@ }, { "func_name": "OCT2HEX", + "is_nullary": false, + "comp_str": "OCT2HEX(${1:number}${2:,${3: [places]}})", "req_param": [ "number" ], @@ -3285,6 +3957,8 @@ }, { "func_name": "ODD", + "is_nullary": false, + "comp_str": "ODD(${1:number})", "req_param": [ "number" ], @@ -3293,6 +3967,8 @@ }, { "func_name": "ODDFPRICE", + "is_nullary": false, + "comp_str": "ODDFPRICE(${1:settlement},${2: maturity},${3: issue},${4: first_coupon},${5: rate},${6: yld},${7: redemption},${8: frequency}${9:,${10: [basis]}})", "req_param": [ "settlement", "maturity", @@ -3310,6 +3986,8 @@ }, { "func_name": "ODDFYIELD", + "is_nullary": false, + "comp_str": "ODDFYIELD(${1:settlement},${2: maturity},${3: issue},${4: first_coupon},${5: rate},${6: pr},${7: redemption},${8: frequency}${9:,${10: [basis]}})", "req_param": [ "settlement", "maturity", @@ -3327,6 +4005,8 @@ }, { "func_name": "ODDLPRICE", + "is_nullary": false, + "comp_str": "ODDLPRICE(${1:settlement},${2: maturity},${3: last_interest},${4: rate},${5: yld},${6: redemption},${7: frequency}${8:,${9: [basis]}})", "req_param": [ "settlement", "maturity", @@ -3343,6 +4023,8 @@ }, { "func_name": "ODDLYIELD", + "is_nullary": false, + "comp_str": "ODDLYIELD(${1:settlement},${2: maturity},${3: last_interest},${4: rate},${5: pr},${6: redemption},${7: frequency}${8:,${9: [basis]}})", "req_param": [ "settlement", "maturity", @@ -3359,6 +4041,8 @@ }, { "func_name": "OFFSET", + "is_nullary": false, + "comp_str": "OFFSET(${1:reference},${2: rows},${3: cols}${4:,${5: [height]},${6: [width]}})", "req_param": [ "reference", "rows", @@ -3372,6 +4056,8 @@ }, { "func_name": "OR", + "is_nullary": false, + "comp_str": "OR(${1:logical1}${2:,${3: [logical2], ...}})", "req_param": [ "logical1" ], @@ -3382,6 +4068,8 @@ }, { "func_name": "PDURATION", + "is_nullary": false, + "comp_str": "PDURATION(${1:rate},${2: py},${3: fv})", "req_param": [ "rate", "py", @@ -3392,6 +4080,8 @@ }, { "func_name": "PEARSON", + "is_nullary": false, + "comp_str": "PEARSON(${1:array1},${2: array2})", "req_param": [ "array1", "array2" @@ -3401,6 +4091,8 @@ }, { "func_name": "PERCENTILE", + "is_nullary": false, + "comp_str": "PERCENTILE(${1:array},${2: k})", "req_param": [ "array", "k" @@ -3410,6 +4102,8 @@ }, { "func_name": "PERCENTILE.EXC", + "is_nullary": false, + "comp_str": "PERCENTILE.EXC(${1:array},${2: k})", "req_param": [ "array", "k" @@ -3419,6 +4113,8 @@ }, { "func_name": "PERCENTILE.INC", + "is_nullary": false, + "comp_str": "PERCENTILE.INC(${1:array},${2: k})", "req_param": [ "array", "k" @@ -3428,6 +4124,8 @@ }, { "func_name": "PERCENTRANK", + "is_nullary": false, + "comp_str": "PERCENTRANK(${1:array},${2: x}${3:,${4: [significance]}})", "req_param": [ "array", "x" @@ -3439,6 +4137,8 @@ }, { "func_name": "PERCENTRANK.EXC", + "is_nullary": false, + "comp_str": "PERCENTRANK.EXC(${1:array},${2: x}${3:,${4: [significance]}})", "req_param": [ "array", "x" @@ -3450,6 +4150,8 @@ }, { "func_name": "PERCENTRANK.INC", + "is_nullary": false, + "comp_str": "PERCENTRANK.INC(${1:array},${2: x}${3:,${4: [significance]}})", "req_param": [ "array", "x" @@ -3461,6 +4163,8 @@ }, { "func_name": "PERMUT", + "is_nullary": false, + "comp_str": "PERMUT(${1:number},${2: number_chosen})", "req_param": [ "number", "number_chosen" @@ -3470,6 +4174,8 @@ }, { "func_name": "PERMUTATIONA", + "is_nullary": false, + "comp_str": "PERMUTATIONA(${1:number},${2: number_chosen})", "req_param": [ "number", "number_chosen" @@ -3479,6 +4185,8 @@ }, { "func_name": "PHI", + "is_nullary": false, + "comp_str": "PHI(${1:x})", "req_param": [ "x" ], @@ -3487,6 +4195,8 @@ }, { "func_name": "PHONETIC", + "is_nullary": false, + "comp_str": "PHONETIC(${1:reference})", "req_param": [ "reference" ], @@ -3495,6 +4205,8 @@ }, { "func_name": "PMT", + "is_nullary": false, + "comp_str": "PMT(${1:rate},${2: nper},${3: pv}${4:,${5: [fv]},${6: [type]}})", "req_param": [ "rate", "nper", @@ -3508,6 +4220,8 @@ }, { "func_name": "POISSON", + "is_nullary": false, + "comp_str": "POISSON(${1:x},${2: mean},${3: cumulative})", "req_param": [ "x", "mean", @@ -3518,6 +4232,8 @@ }, { "func_name": "POISSON.DIST", + "is_nullary": false, + "comp_str": "POISSON.DIST(${1:x},${2: mean},${3: cumulative})", "req_param": [ "x", "mean", @@ -3528,6 +4244,8 @@ }, { "func_name": "POWER", + "is_nullary": false, + "comp_str": "POWER(${1:number},${2: power})", "req_param": [ "number", "power" @@ -3537,6 +4255,8 @@ }, { "func_name": "PPMT", + "is_nullary": false, + "comp_str": "PPMT(${1:rate},${2: per},${3: nper},${4: pv}${5:,${6: [fv]},${7: [type]}})", "req_param": [ "rate", "per", @@ -3551,6 +4271,8 @@ }, { "func_name": "PRICE", + "is_nullary": false, + "comp_str": "PRICE(${1:settlement},${2: maturity},${3: rate},${4: yld},${5: redemption},${6: frequency}${7:,${8: [basis]}})", "req_param": [ "settlement", "maturity", @@ -3566,6 +4288,8 @@ }, { "func_name": "PRICEDISC", + "is_nullary": false, + "comp_str": "PRICEDISC(${1:settlement},${2: maturity},${3: discount},${4: redemption}${5:,${6: [basis]}})", "req_param": [ "settlement", "maturity", @@ -3579,6 +4303,8 @@ }, { "func_name": "PRICEMAT", + "is_nullary": false, + "comp_str": "PRICEMAT(${1:settlement},${2: maturity},${3: issue},${4: rate},${5: yld}${6:,${7: [basis]}})", "req_param": [ "settlement", "maturity", @@ -3593,6 +4319,8 @@ }, { "func_name": "PROB", + "is_nullary": false, + "comp_str": "PROB(${1:x_range},${2: prob_range},${3: lower_limit}${4:,${5: [upper_limit]}})", "req_param": [ "x_range", "prob_range", @@ -3605,6 +4333,8 @@ }, { "func_name": "PRODUCT", + "is_nullary": false, + "comp_str": "PRODUCT(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -3615,6 +4345,8 @@ }, { "func_name": "PROPER", + "is_nullary": false, + "comp_str": "PROPER(${1:text})", "req_param": [ "text" ], @@ -3623,6 +4355,8 @@ }, { "func_name": "PV", + "is_nullary": false, + "comp_str": "PV(${1:rate},${2: nper},${3: pmt}${4:,${5: [fv]},${6: [typel]}})", "req_param": [ "rate", "nper", @@ -3636,6 +4370,8 @@ }, { "func_name": "QUARTILE", + "is_nullary": false, + "comp_str": "QUARTILE(${1:array},${2: quart})", "req_param": [ "array", "quart" @@ -3645,6 +4381,8 @@ }, { "func_name": "QUARTILE.EXC", + "is_nullary": false, + "comp_str": "QUARTILE.EXC(${1:array},${2: quart})", "req_param": [ "array", "quart" @@ -3654,6 +4392,8 @@ }, { "func_name": "QUARTILE.INC", + "is_nullary": false, + "comp_str": "QUARTILE.INC(${1:array},${2: quart})", "req_param": [ "array", "quart" @@ -3663,6 +4403,8 @@ }, { "func_name": "QUOTIENT", + "is_nullary": false, + "comp_str": "QUOTIENT(${1:numerator},${2: denominator})", "req_param": [ "numerator", "denominator" @@ -3672,6 +4414,8 @@ }, { "func_name": "RADIANS", + "is_nullary": false, + "comp_str": "RADIANS(${1:angle})", "req_param": [ "angle" ], @@ -3680,6 +4424,8 @@ }, { "func_name": "RANDARRAY", + "is_nullary": false, + "comp_str": "RANDARRAY(${1:,${2: [rows]},${3: [columns]},${4: [min]},${5: [max]},${6: [integer]}})", "req_param": [], "opt_param": [ "rows", @@ -3692,6 +4438,8 @@ }, { "func_name": "RANDBETWEEN", + "is_nullary": false, + "comp_str": "RANDBETWEEN(${1:bottom},${2: top})", "req_param": [ "bottom", "top" @@ -3701,6 +4449,8 @@ }, { "func_name": "RANK", + "is_nullary": false, + "comp_str": "RANK(${1:number},${2: ref}${3:,${4: [order]}})", "req_param": [ "number", "ref" @@ -3712,6 +4462,8 @@ }, { "func_name": "RANK.AVG", + "is_nullary": false, + "comp_str": "RANK.AVG(${1:number},${2: ref}${3:,${4: [order]}})", "req_param": [ "number", "ref" @@ -3723,6 +4475,8 @@ }, { "func_name": "RANK.EQ", + "is_nullary": false, + "comp_str": "RANK.EQ(${1:number},${2: ref}${3:,${4: [order]}})", "req_param": [ "number", "ref" @@ -3734,6 +4488,8 @@ }, { "func_name": "RATE", + "is_nullary": false, + "comp_str": "RATE(${1:nper},${2: pmt},${3: pv}${4:,${5: [fv]},${6: [type]},${7: [guess]}})", "req_param": [ "nper", "pmt", @@ -3748,6 +4504,8 @@ }, { "func_name": "RECEIVED", + "is_nullary": false, + "comp_str": "RECEIVED(${1:settlement},${2: maturity},${3: investment},${4: discount}${5:,${6: [basis]}})", "req_param": [ "settlement", "maturity", @@ -3761,6 +4519,8 @@ }, { "func_name": "REDUCE", + "is_nullary": false, + "comp_str": "REDUCE(${1:initial_value},${2: array},${3: function})", "req_param": [ "initial_value", "array", @@ -3771,6 +4531,8 @@ }, { "func_name": "REGISTER", + "is_nullary": false, + "comp_str": "REGISTER(${1:module_text},${2: procedure},${3: type_text}${4:,${5: [argument1], ...}})", "req_param": [ "module_text", "procedure", @@ -3783,6 +4545,8 @@ }, { "func_name": "REGISTER.ID", + "is_nullary": false, + "comp_str": "REGISTER.ID(${1:module_text},${2: procedure}${3:,${4: [type_text]}})", "req_param": [ "module_text", "procedure" @@ -3794,6 +4558,8 @@ }, { "func_name": "REPLACE", + "is_nullary": false, + "comp_str": "REPLACE(${1:old_text},${2: start_num},${3: num_chars},${4: new_text})", "req_param": [ "old_text", "start_num", @@ -3805,6 +4571,8 @@ }, { "func_name": "REPLACEB", + "is_nullary": false, + "comp_str": "REPLACEB(${1:old_text},${2: start_num},${3: num_bytes},${4: new_text})", "req_param": [ "old_text", "start_num", @@ -3816,6 +4584,8 @@ }, { "func_name": "REPT", + "is_nullary": false, + "comp_str": "REPT(${1:text},${2: number_times})", "req_param": [ "text", "number_times" @@ -3825,6 +4595,8 @@ }, { "func_name": "RIGHT", + "is_nullary": false, + "comp_str": "RIGHT(${1:text}${2:,${3: [num_chars]}})", "req_param": [ "text" ], @@ -3835,6 +4607,8 @@ }, { "func_name": "RIGHTB", + "is_nullary": false, + "comp_str": "RIGHTB(${1:text}${2:,${3: [num_bytes]}})", "req_param": [ "text" ], @@ -3845,6 +4619,8 @@ }, { "func_name": "ROMAN", + "is_nullary": false, + "comp_str": "ROMAN(${1:number}${2:,${3: [form]}})", "req_param": [ "number" ], @@ -3855,6 +4631,8 @@ }, { "func_name": "ROUND", + "is_nullary": false, + "comp_str": "ROUND(${1:number},${2: num_digits})", "req_param": [ "number", "num_digits" @@ -3864,6 +4642,8 @@ }, { "func_name": "ROUNDDOWN", + "is_nullary": false, + "comp_str": "ROUNDDOWN(${1:number},${2: num_digits})", "req_param": [ "number", "num_digits" @@ -3873,6 +4653,8 @@ }, { "func_name": "ROUNDUP", + "is_nullary": false, + "comp_str": "ROUNDUP(${1:number},${2: num_digits})", "req_param": [ "number", "num_digits" @@ -3882,6 +4664,8 @@ }, { "func_name": "ROW", + "is_nullary": false, + "comp_str": "ROW(${1:,${2: [reference]}})", "req_param": [], "opt_param": [ "reference" @@ -3890,6 +4674,8 @@ }, { "func_name": "ROWS", + "is_nullary": false, + "comp_str": "ROWS(${1:array})", "req_param": [ "array" ], @@ -3898,6 +4684,8 @@ }, { "func_name": "RRI", + "is_nullary": false, + "comp_str": "RRI(${1:nper},${2: pv},${3: fv})", "req_param": [ "nper", "pv", @@ -3908,6 +4696,8 @@ }, { "func_name": "RSQ", + "is_nullary": false, + "comp_str": "RSQ(${1:known_ys},${2: known_xs})", "req_param": [ "known_ys", "known_xs" @@ -3917,6 +4707,8 @@ }, { "func_name": "RTD", + "is_nullary": false, + "comp_str": "RTD(${1:progID},${2: server},${3: topic1}${4:,${5: [topic2], ...}})", "req_param": [ "progID", "server", @@ -3929,6 +4721,8 @@ }, { "func_name": "SCAN", + "is_nullary": false, + "comp_str": "SCAN(${1:initial_value},${2: array},${3: function})", "req_param": [ "initial_value", "array", @@ -3939,6 +4733,8 @@ }, { "func_name": "SEARCH", + "is_nullary": false, + "comp_str": "SEARCH(${1:find_text},${2: within_text}${3:,${4: [start_num]}})", "req_param": [ "find_text", "within_text" @@ -3950,6 +4746,8 @@ }, { "func_name": "SEARCHB", + "is_nullary": false, + "comp_str": "SEARCHB(${1:find_text},${2: within_text}${3:,${4: [start_num]}})", "req_param": [ "find_text", "within_text" @@ -3961,6 +4759,8 @@ }, { "func_name": "SEC", + "is_nullary": false, + "comp_str": "SEC(${1:number})", "req_param": [ "number" ], @@ -3969,6 +4769,8 @@ }, { "func_name": "SECH", + "is_nullary": false, + "comp_str": "SECH(${1:number})", "req_param": [ "number" ], @@ -3977,6 +4779,8 @@ }, { "func_name": "SECOND", + "is_nullary": false, + "comp_str": "SECOND(${1:serial_number})", "req_param": [ "serial_number" ], @@ -3985,6 +4789,8 @@ }, { "func_name": "SEQUENCE", + "is_nullary": false, + "comp_str": "SEQUENCE(${1:rows}${2:,${3: [columns]},${4: [start]},${5: [step]}})", "req_param": [ "rows" ], @@ -3997,6 +4803,8 @@ }, { "func_name": "SERIESSUM", + "is_nullary": false, + "comp_str": "SERIESSUM(${1:x},${2: n},${3: m},${4: coefficients})", "req_param": [ "x", "n", @@ -4008,6 +4816,8 @@ }, { "func_name": "SHEET", + "is_nullary": false, + "comp_str": "SHEET(${1:,${2: [value]}})", "req_param": [], "opt_param": [ "value" @@ -4016,6 +4826,8 @@ }, { "func_name": "SHEETS", + "is_nullary": false, + "comp_str": "SHEETS(${1:,${2: [reference]}})", "req_param": [], "opt_param": [ "reference" @@ -4024,6 +4836,8 @@ }, { "func_name": "SIGN", + "is_nullary": false, + "comp_str": "SIGN(${1:number})", "req_param": [ "number" ], @@ -4032,6 +4846,8 @@ }, { "func_name": "SIN", + "is_nullary": false, + "comp_str": "SIN(${1:number})", "req_param": [ "number" ], @@ -4040,6 +4856,8 @@ }, { "func_name": "SINH", + "is_nullary": false, + "comp_str": "SINH(${1:number})", "req_param": [ "number" ], @@ -4048,6 +4866,8 @@ }, { "func_name": "SKEW", + "is_nullary": false, + "comp_str": "SKEW(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -4058,6 +4878,8 @@ }, { "func_name": "SKEW.P", + "is_nullary": false, + "comp_str": "SKEW.P(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -4068,6 +4890,8 @@ }, { "func_name": "SLN", + "is_nullary": false, + "comp_str": "SLN(${1:cost},${2: salvage},${3: life})", "req_param": [ "cost", "salvage", @@ -4078,6 +4902,8 @@ }, { "func_name": "SLOPE", + "is_nullary": false, + "comp_str": "SLOPE(${1:known_ys},${2: known_xs})", "req_param": [ "known_ys", "known_xs" @@ -4087,6 +4913,8 @@ }, { "func_name": "SMALL", + "is_nullary": false, + "comp_str": "SMALL(${1:array},${2: k})", "req_param": [ "array", "k" @@ -4096,6 +4924,8 @@ }, { "func_name": "SORT", + "is_nullary": false, + "comp_str": "SORT(${1:array}${2:,${3: [sort_index]},${4: [sort_order]},${5: [by_col]}})", "req_param": [ "array" ], @@ -4108,6 +4938,8 @@ }, { "func_name": "SORTBY", + "is_nullary": false, + "comp_str": "SORTBY(${1:array},${2: by_array1}${3:,${4: [sort_order1], ...}})", "req_param": [ "array", "by_array1" @@ -4119,6 +4951,8 @@ }, { "func_name": "SQRT", + "is_nullary": false, + "comp_str": "SQRT(${1:number})", "req_param": [ "number" ], @@ -4127,6 +4961,8 @@ }, { "func_name": "SQRTPI", + "is_nullary": false, + "comp_str": "SQRTPI(${1:number})", "req_param": [ "number" ], @@ -4135,6 +4971,8 @@ }, { "func_name": "STANDARDIZE", + "is_nullary": false, + "comp_str": "STANDARDIZE(${1:x},${2: mean},${3: standard_dev})", "req_param": [ "x", "mean", @@ -4145,6 +4983,8 @@ }, { "func_name": "STDEV", + "is_nullary": false, + "comp_str": "STDEV(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -4155,6 +4995,8 @@ }, { "func_name": "STDEV.P", + "is_nullary": false, + "comp_str": "STDEV.P(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -4165,6 +5007,8 @@ }, { "func_name": "STDEV.S", + "is_nullary": false, + "comp_str": "STDEV.S(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -4175,6 +5019,8 @@ }, { "func_name": "STDEVA", + "is_nullary": false, + "comp_str": "STDEVA(${1:value1}${2:,${3: [value2], ...}})", "req_param": [ "value1" ], @@ -4185,6 +5031,8 @@ }, { "func_name": "STDEVP", + "is_nullary": false, + "comp_str": "STDEVP(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -4195,6 +5043,8 @@ }, { "func_name": "STDEVPA", + "is_nullary": false, + "comp_str": "STDEVPA(${1:value1}${2:,${3: [value2], ...}})", "req_param": [ "value1" ], @@ -4205,6 +5055,8 @@ }, { "func_name": "STEYX", + "is_nullary": false, + "comp_str": "STEYX(${1:known_ys},${2: known_xs})", "req_param": [ "known_ys", "known_xs" @@ -4214,6 +5066,8 @@ }, { "func_name": "STOCKHISTORY", + "is_nullary": false, + "comp_str": "STOCKHISTORY(${1:stock},${2: start_date}${3:,${4: [end_date]},${5: [interval]},${6: [headers]},${7: [properties], ...}})", "req_param": [ "stock", "start_date" @@ -4228,6 +5082,8 @@ }, { "func_name": "SUBSTITUTE", + "is_nullary": false, + "comp_str": "SUBSTITUTE(${1:text},${2: old_text},${3: new_text}${4:,${5: [instance_num]}})", "req_param": [ "text", "old_text", @@ -4240,6 +5096,8 @@ }, { "func_name": "SUBTOTAL", + "is_nullary": false, + "comp_str": "SUBTOTAL(${1:function_num},${2: ref1}${3:,${4: [ref2], ...}})", "req_param": [ "function_num", "ref1" @@ -4251,6 +5109,8 @@ }, { "func_name": "SUM", + "is_nullary": false, + "comp_str": "SUM(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -4261,6 +5121,8 @@ }, { "func_name": "SUMIF", + "is_nullary": false, + "comp_str": "SUMIF(${1:range},${2: criteria}${3:,${4: [sum_range]}})", "req_param": [ "range", "criteria" @@ -4272,6 +5134,8 @@ }, { "func_name": "SUMIFS", + "is_nullary": false, + "comp_str": "SUMIFS(${1:sum_range},${2: criteria_range1},${3: criteria1}${4:,${5: [criteria_range2]},${6: [criteria2], ...}})", "req_param": [ "sum_range", "criteria_range1", @@ -4285,6 +5149,8 @@ }, { "func_name": "SUMPRODUCT", + "is_nullary": false, + "comp_str": "SUMPRODUCT(${1:array1}${2:,${3: [array2]},${4: [array3], ...}})", "req_param": [ "array1" ], @@ -4296,6 +5162,8 @@ }, { "func_name": "SUMSQ", + "is_nullary": false, + "comp_str": "SUMSQ(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -4306,6 +5174,8 @@ }, { "func_name": "SUMX2MY2", + "is_nullary": false, + "comp_str": "SUMX2MY2(${1:array_x},${2: array_y})", "req_param": [ "array_x", "array_y" @@ -4315,6 +5185,8 @@ }, { "func_name": "SUMX2PY2", + "is_nullary": false, + "comp_str": "SUMX2PY2(${1:array_x},${2: array_y})", "req_param": [ "array_x", "array_y" @@ -4324,6 +5196,8 @@ }, { "func_name": "SUMXMY2", + "is_nullary": false, + "comp_str": "SUMXMY2(${1:array_x},${2: array_y})", "req_param": [ "array_x", "array_y" @@ -4333,6 +5207,8 @@ }, { "func_name": "SWITCH", + "is_nullary": false, + "comp_str": "SWITCH(${1:expression},${2: value1},${3: result1}${4:,${5: [default_or_value2]},${6: [result2], ...}})", "req_param": [ "expression", "value1", @@ -4346,6 +5222,8 @@ }, { "func_name": "SYD", + "is_nullary": false, + "comp_str": "SYD(${1:cost},${2: salvage},${3: life},${4: per})", "req_param": [ "cost", "salvage", @@ -4357,6 +5235,8 @@ }, { "func_name": "T", + "is_nullary": false, + "comp_str": "T(${1:value})", "req_param": [ "value" ], @@ -4365,6 +5245,8 @@ }, { "func_name": "T.DIST", + "is_nullary": false, + "comp_str": "T.DIST(${1:x},${2: deg_freedom},${3: cumulative})", "req_param": [ "x", "deg_freedom", @@ -4375,6 +5257,8 @@ }, { "func_name": "T.DIST.2T", + "is_nullary": false, + "comp_str": "T.DIST.2T(${1:x},${2: deg_freedom})", "req_param": [ "x", "deg_freedom" @@ -4384,6 +5268,8 @@ }, { "func_name": "T.DIST.RT", + "is_nullary": false, + "comp_str": "T.DIST.RT(${1:x},${2: deg_freedom})", "req_param": [ "x", "deg_freedom" @@ -4393,6 +5279,8 @@ }, { "func_name": "T.INV", + "is_nullary": false, + "comp_str": "T.INV(${1:probability},${2: deg_freedom})", "req_param": [ "probability", "deg_freedom" @@ -4402,6 +5290,8 @@ }, { "func_name": "T.INV.2T", + "is_nullary": false, + "comp_str": "T.INV.2T(${1:probability},${2: deg_freedom})", "req_param": [ "probability", "deg_freedom" @@ -4411,6 +5301,8 @@ }, { "func_name": "T.TEST", + "is_nullary": false, + "comp_str": "T.TEST(${1:array1},${2: array2},${3: tails},${4: type})", "req_param": [ "array1", "array2", @@ -4422,6 +5314,8 @@ }, { "func_name": "TAKE", + "is_nullary": false, + "comp_str": "TAKE(${1:array},${2: rows}${3:,${4: [columns]}})", "req_param": [ "array", "rows" @@ -4433,6 +5327,8 @@ }, { "func_name": "TAN", + "is_nullary": false, + "comp_str": "TAN(${1:number})", "req_param": [ "number" ], @@ -4441,6 +5337,8 @@ }, { "func_name": "TANH", + "is_nullary": false, + "comp_str": "TANH(${1:number})", "req_param": [ "number" ], @@ -4449,6 +5347,8 @@ }, { "func_name": "TBILLEQ", + "is_nullary": false, + "comp_str": "TBILLEQ(${1:settlement},${2: maturity},${3: discount})", "req_param": [ "settlement", "maturity", @@ -4459,6 +5359,8 @@ }, { "func_name": "TBILLPRICE", + "is_nullary": false, + "comp_str": "TBILLPRICE(${1:settlement},${2: maturity},${3: discount})", "req_param": [ "settlement", "maturity", @@ -4469,6 +5371,8 @@ }, { "func_name": "TBILLYIELD", + "is_nullary": false, + "comp_str": "TBILLYIELD(${1:settlement},${2: maturity},${3: pr})", "req_param": [ "settlement", "maturity", @@ -4479,6 +5383,8 @@ }, { "func_name": "TDIST", + "is_nullary": false, + "comp_str": "TDIST(${1:x},${2: deg_freedom},${3: tails})", "req_param": [ "x", "deg_freedom", @@ -4489,6 +5395,8 @@ }, { "func_name": "TEXT", + "is_nullary": false, + "comp_str": "TEXT(${1:value},${2: format_text})", "req_param": [ "value", "format_text" @@ -4498,6 +5406,8 @@ }, { "func_name": "TEXTAFTER", + "is_nullary": false, + "comp_str": "TEXTAFTER(${1:text},${2: delimiter}${3:,${4: [instance_num]},${5: [match_mode]},${6: [match_end]},${7: [if_not_found]}})", "req_param": [ "text", "delimiter" @@ -4512,6 +5422,8 @@ }, { "func_name": "TEXTBEFORE", + "is_nullary": false, + "comp_str": "TEXTBEFORE(${1:text},${2: delimiter}${3:,${4: [instance_num]},${5: [match_mode]},${6: [match_end]},${7: [if_not_found]}})", "req_param": [ "text", "delimiter" @@ -4526,6 +5438,8 @@ }, { "func_name": "TEXTJOIN", + "is_nullary": false, + "comp_str": "TEXTJOIN(${1:delimiter},${2: ignore_empty},${3: text1}${4:,${5: [text2], ...}})", "req_param": [ "delimiter", "ignore_empty", @@ -4538,6 +5452,8 @@ }, { "func_name": "TEXTSPLIT", + "is_nullary": false, + "comp_str": "TEXTSPLIT(${1:text},${2: col_delimiter}${3:,${4: [row_delimiter]},${5: [ignore_empty]},${6: [match_mode]},${7: [pad_with]}})", "req_param": [ "text", "col_delimiter" @@ -4552,6 +5468,8 @@ }, { "func_name": "TIME", + "is_nullary": false, + "comp_str": "TIME(${1:hour},${2: minute},${3: second})", "req_param": [ "hour", "minute", @@ -4562,6 +5480,8 @@ }, { "func_name": "TIMEVALUE", + "is_nullary": false, + "comp_str": "TIMEVALUE(${1:time_text})", "req_param": [ "time_text" ], @@ -4570,6 +5490,8 @@ }, { "func_name": "TINV", + "is_nullary": false, + "comp_str": "TINV(${1:probability},${2: deg_freedom})", "req_param": [ "probability", "deg_freedom" @@ -4579,6 +5501,8 @@ }, { "func_name": "TOCOL", + "is_nullary": false, + "comp_str": "TOCOL(${1:array}${2:,${3: [ignore]},${4: [scan_by_column]}})", "req_param": [ "array" ], @@ -4590,6 +5514,8 @@ }, { "func_name": "TOROW", + "is_nullary": false, + "comp_str": "TOROW(${1:array}${2:,${3: [ignore]},${4: [scan_by_column]}})", "req_param": [ "array" ], @@ -4601,6 +5527,8 @@ }, { "func_name": "TRANSPOSE", + "is_nullary": false, + "comp_str": "TRANSPOSE(${1:array})", "req_param": [ "array" ], @@ -4609,6 +5537,8 @@ }, { "func_name": "TREND", + "is_nullary": false, + "comp_str": "TREND(${1:known_ys}${2:,${3: [known_xs]},${4: [new_xs]},${5: [const]}})", "req_param": [ "known_ys" ], @@ -4621,6 +5551,8 @@ }, { "func_name": "TRIM", + "is_nullary": false, + "comp_str": "TRIM(${1:text})", "req_param": [ "text" ], @@ -4629,6 +5561,8 @@ }, { "func_name": "TRIMMEAN", + "is_nullary": false, + "comp_str": "TRIMMEAN(${1:array},${2: percent})", "req_param": [ "array", "percent" @@ -4638,6 +5572,8 @@ }, { "func_name": "TRUNC", + "is_nullary": false, + "comp_str": "TRUNC(${1:number}${2:,${3: [num_digits]}})", "req_param": [ "number" ], @@ -4648,6 +5584,8 @@ }, { "func_name": "TTEST", + "is_nullary": false, + "comp_str": "TTEST(${1:array1},${2: array2},${3: tails},${4: type})", "req_param": [ "array1", "array2", @@ -4659,6 +5597,8 @@ }, { "func_name": "TYPE", + "is_nullary": false, + "comp_str": "TYPE(${1:value})", "req_param": [ "value" ], @@ -4667,6 +5607,8 @@ }, { "func_name": "UNICHAR", + "is_nullary": false, + "comp_str": "UNICHAR(${1:number})", "req_param": [ "number" ], @@ -4675,6 +5617,8 @@ }, { "func_name": "UNICODE", + "is_nullary": false, + "comp_str": "UNICODE(${1:text})", "req_param": [ "text" ], @@ -4683,6 +5627,8 @@ }, { "func_name": "UNIQUE", + "is_nullary": false, + "comp_str": "UNIQUE(${1:array}${2:,${3: [by_col]},${4: [exactly_once]}})", "req_param": [ "array" ], @@ -4694,6 +5640,8 @@ }, { "func_name": "UNREGISTER", + "is_nullary": false, + "comp_str": "UNREGISTER(${1:register_id})", "req_param": [ "register_id" ], @@ -4702,6 +5650,8 @@ }, { "func_name": "UPPER", + "is_nullary": false, + "comp_str": "UPPER(${1:text})", "req_param": [ "text" ], @@ -4710,6 +5660,8 @@ }, { "func_name": "VALUE", + "is_nullary": false, + "comp_str": "VALUE(${1:text})", "req_param": [ "text" ], @@ -4718,6 +5670,8 @@ }, { "func_name": "VALUETOTEXT", + "is_nullary": false, + "comp_str": "VALUETOTEXT(${1:value}${2:,${3: [format]}})", "req_param": [ "value" ], @@ -4728,6 +5682,8 @@ }, { "func_name": "VAR", + "is_nullary": false, + "comp_str": "VAR(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -4738,6 +5694,8 @@ }, { "func_name": "VAR.P", + "is_nullary": false, + "comp_str": "VAR.P(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -4748,6 +5706,8 @@ }, { "func_name": "VAR.S", + "is_nullary": false, + "comp_str": "VAR.S(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -4758,6 +5718,8 @@ }, { "func_name": "VARA", + "is_nullary": false, + "comp_str": "VARA(${1:value1}${2:,${3: [value2], ...}})", "req_param": [ "value1" ], @@ -4768,6 +5730,8 @@ }, { "func_name": "VARP", + "is_nullary": false, + "comp_str": "VARP(${1:number1}${2:,${3: [number2], ...}})", "req_param": [ "number1" ], @@ -4778,6 +5742,8 @@ }, { "func_name": "VARPA", + "is_nullary": false, + "comp_str": "VARPA(${1:value1}${2:,${3: [value2], ...}})", "req_param": [ "value1" ], @@ -4788,6 +5754,8 @@ }, { "func_name": "VDB", + "is_nullary": false, + "comp_str": "VDB(${1:cost},${2: salvage},${3: life},${4: start_period},${5: end_period}${6:,${7: [factor]},${8: [no_switch]}})", "req_param": [ "cost", "salvage", @@ -4803,6 +5771,8 @@ }, { "func_name": "VLOOKUP", + "is_nullary": false, + "comp_str": "VLOOKUP(${1:lookup_value},${2: table_array},${3: col_index_num}${4:,${5: [range_lookup]}})", "req_param": [ "lookup_value", "table_array", @@ -4815,6 +5785,8 @@ }, { "func_name": "VSTACK", + "is_nullary": false, + "comp_str": "VSTACK(${1:array1}${2:,${3: [array2], ...}})", "req_param": [ "array1" ], @@ -4825,6 +5797,8 @@ }, { "func_name": "WEBSERVICE", + "is_nullary": false, + "comp_str": "WEBSERVICE(${1:url})", "req_param": [ "url" ], @@ -4833,6 +5807,8 @@ }, { "func_name": "WEEKDAY", + "is_nullary": false, + "comp_str": "WEEKDAY(${1:serial_number}${2:,${3: [return_type]}})", "req_param": [ "serial_number" ], @@ -4843,6 +5819,8 @@ }, { "func_name": "WEEKNUM", + "is_nullary": false, + "comp_str": "WEEKNUM(${1:serial_number}${2:,${3: [return_type]}})", "req_param": [ "serial_number" ], @@ -4853,6 +5831,8 @@ }, { "func_name": "WEIBULL", + "is_nullary": false, + "comp_str": "WEIBULL(${1:x},${2: alpha},${3: beta},${4: cumulative})", "req_param": [ "x", "alpha", @@ -4864,6 +5844,8 @@ }, { "func_name": "WEIBULL.DIST", + "is_nullary": false, + "comp_str": "WEIBULL.DIST(${1:x},${2: alpha},${3: beta},${4: cumulative})", "req_param": [ "x", "alpha", @@ -4875,6 +5857,8 @@ }, { "func_name": "WORKDAY", + "is_nullary": false, + "comp_str": "WORKDAY(${1:start_date},${2: days}${3:,${4: [holidays]}})", "req_param": [ "start_date", "days" @@ -4886,6 +5870,8 @@ }, { "func_name": "WORKDAY.INTL", + "is_nullary": false, + "comp_str": "WORKDAY.INTL(${1:start_date},${2: days}${3:,${4: [weekend]},${5: [holidays]}})", "req_param": [ "start_date", "days" @@ -4898,6 +5884,8 @@ }, { "func_name": "WRAPCOLS", + "is_nullary": false, + "comp_str": "WRAPCOLS(${1:vector},${2: wrap_count}${3:,${4: [pad_with]}})", "req_param": [ "vector", "wrap_count" @@ -4909,6 +5897,8 @@ }, { "func_name": "WRAPROWS", + "is_nullary": false, + "comp_str": "WRAPROWS(${1:vector},${2: wrap_count}${3:,${4: [pad_with]}})", "req_param": [ "vector", "wrap_count" @@ -4920,6 +5910,8 @@ }, { "func_name": "XIRR", + "is_nullary": false, + "comp_str": "XIRR(${1:values},${2: dates}${3:,${4: [guess]}})", "req_param": [ "values", "dates" @@ -4931,6 +5923,8 @@ }, { "func_name": "XLOOKUP", + "is_nullary": false, + "comp_str": "XLOOKUP(${1:lookup_value},${2: lookup_array},${3: return_array}${4:,${5: [if_not_found]},${6: [match_mode]},${7: [search_mode]}})", "req_param": [ "lookup_value", "lookup_array", @@ -4945,6 +5939,8 @@ }, { "func_name": "XMATCH", + "is_nullary": false, + "comp_str": "XMATCH(${1:lookup_value},${2: lookup_array}${3:,${4: [match_mode]},${5: [search_mode]}})", "req_param": [ "lookup_value", "lookup_array" @@ -4957,6 +5953,8 @@ }, { "func_name": "XNPV", + "is_nullary": false, + "comp_str": "XNPV(${1:rate},${2: values},${3: dates})", "req_param": [ "rate", "values", @@ -4967,6 +5965,8 @@ }, { "func_name": "XOR", + "is_nullary": false, + "comp_str": "XOR(${1:logical1}${2:,${3: [logical2], ...}})", "req_param": [ "logical1" ], @@ -4977,6 +5977,8 @@ }, { "func_name": "YEAR", + "is_nullary": false, + "comp_str": "YEAR(${1:serial_number})", "req_param": [ "serial_number" ], @@ -4985,6 +5987,8 @@ }, { "func_name": "YEARFRAC", + "is_nullary": false, + "comp_str": "YEARFRAC(${1:start_date},${2: end_date}${3:,${4: [basis]}})", "req_param": [ "start_date", "end_date" @@ -4996,6 +6000,8 @@ }, { "func_name": "YIELD", + "is_nullary": false, + "comp_str": "YIELD(${1:settlement},${2: maturity},${3: rate},${4: pr},${5: redemption},${6: frequency}${7:,${8: [basis]}})", "req_param": [ "settlement", "maturity", @@ -5011,6 +6017,8 @@ }, { "func_name": "YIELDDISC", + "is_nullary": false, + "comp_str": "YIELDDISC(${1:settlement},${2: maturity},${3: pr},${4: redemption}${5:,${6: [basis]}})", "req_param": [ "settlement", "maturity", @@ -5024,6 +6032,8 @@ }, { "func_name": "YIELDMAT", + "is_nullary": false, + "comp_str": "YIELDMAT(${1:settlement},${2: maturity},${3: issue},${4: rate},${5: pr}${6:,${7: [basis]}})", "req_param": [ "settlement", "maturity", @@ -5038,6 +6048,8 @@ }, { "func_name": "Z.TEST", + "is_nullary": false, + "comp_str": "Z.TEST(${1:array},${2: x}${3:,${4: [sigma]}})", "req_param": [ "array", "x" @@ -5049,6 +6061,8 @@ }, { "func_name": "ZTEST", + "is_nullary": false, + "comp_str": "ZTEST(${1:array},${2: x}${3:,${4: [sigma]}})", "req_param": [ "array", "x" diff --git a/resources/completion_builder/excel_funcs_master.json b/resources/completion_builder/excel_funcs_master.json index deacc30..544df89 100644 --- a/resources/completion_builder/excel_funcs_master.json +++ b/resources/completion_builder/excel_funcs_master.json @@ -5,6 +5,10 @@ "func_desc": "Returns the absolute value of a number.", "is_nullary": false, "comp_str": "ABS(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -13,6 +17,18 @@ "func_desc": "Returns the accrued interest for a security that pays periodic interest.", "is_nullary": false, "comp_str": "ACCRINT(${1:issue},${2: first_interest},${3: settlement},${4: rate},${5: par},${6: frequency}${7:,${8: [basis]},${9: [calc_method]}})", + "req_param": [ + "issue", + "first_interest", + "settlement", + "rate", + "par", + "frequency" + ], + "opt_param": [ + "basis", + "calc_method" + ], "ellipsis": false }, { @@ -21,6 +37,15 @@ "func_desc": "Returns the accrued interest for a security that pays interest at maturity.", "is_nullary": false, "comp_str": "ACCRINTM(${1:issue},${2: settlement},${3: rate},${4: par}${5:,${6: [basis]}})", + "req_param": [ + "issue", + "settlement", + "rate", + "par" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -29,6 +54,10 @@ "func_desc": "Returns the arccosine of a number.", "is_nullary": false, "comp_str": "ACOS(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -37,6 +66,10 @@ "func_desc": "Returns the inverse hyperbolic cosine of a number.", "is_nullary": false, "comp_str": "ACOSH(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -45,6 +78,10 @@ "func_desc": "Returns the arccotangent of a number.", "is_nullary": false, "comp_str": "ACOT(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -53,6 +90,10 @@ "func_desc": "Returns the hyperbolic arccotangent of a number.", "is_nullary": false, "comp_str": "ACOTH(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -61,6 +102,15 @@ "func_desc": "Returns a reference as text to a single cell in a worksheet.", "is_nullary": false, "comp_str": "ADDRESS(${1:row_num},${2: column_num}${3:,${4: [abs_num]},${5: [a1]},${6: [sheet_text]}})", + "req_param": [ + "row_num", + "column_num" + ], + "opt_param": [ + "abs_num", + "a1", + "sheet_text" + ], "ellipsis": false }, { @@ -69,6 +119,14 @@ "func_desc": "Returns an aggregate in a list or database.", "is_nullary": false, "comp_str": "AGGREGATE(${1:function_num},${2: options},${3: array}${4:,${5: [k]}})", + "req_param": [ + "function_num", + "options", + "array" + ], + "opt_param": [ + "k" + ], "ellipsis": false }, { @@ -77,6 +135,17 @@ "func_desc": "Returns the depreciation for each accounting period by using a depreciation coefficient.", "is_nullary": false, "comp_str": "AMORDEGRC(${1:cost},${2: date_purchased},${3: first_period},${4: salvage},${5: period},${6: rate}${7:,${8: [basis]}})", + "req_param": [ + "cost", + "date_purchased", + "first_period", + "salvage", + "period", + "rate" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -85,6 +154,17 @@ "func_desc": "Returns the depreciation for each accounting period.", "is_nullary": false, "comp_str": "AMORLINC(${1:cost},${2: date_purchased},${3: first_period},${4: salvage},${5: period},${6: rate}${7:,${8: [basis]}})", + "req_param": [ + "cost", + "date_purchased", + "first_period", + "salvage", + "period", + "rate" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -93,6 +173,12 @@ "func_desc": "Returns TRUE if all of its arguments are TRUE.", "is_nullary": false, "comp_str": "AND(${1:logical1}${2:,${3: [logical2], ...}})", + "req_param": [ + "logical1" + ], + "opt_param": [ + "logical2" + ], "ellipsis": true }, { @@ -101,6 +187,10 @@ "func_desc": "Converts a Roman number to Arabic, as a number.", "is_nullary": false, "comp_str": "ARABIC(${1:text})", + "req_param": [ + "text" + ], + "opt_param": [], "ellipsis": false }, { @@ -109,6 +199,10 @@ "func_desc": "Returns the number of areas in a reference.", "is_nullary": false, "comp_str": "AREAS(${1:reference})", + "req_param": [ + "reference" + ], + "opt_param": [], "ellipsis": false }, { @@ -117,6 +211,12 @@ "func_desc": "Returns an array of text values from any specified range.", "is_nullary": false, "comp_str": "ARRAYTOTEXT(${1:array}${2:,${3: [format]}})", + "req_param": [ + "array" + ], + "opt_param": [ + "format" + ], "ellipsis": false }, { @@ -125,6 +225,10 @@ "func_desc": "Changes full-width (double-byte) English letters or katakana within a character string to half-width (single-byte) characters.", "is_nullary": false, "comp_str": "ASC(${1:text})", + "req_param": [ + "text" + ], + "opt_param": [], "ellipsis": false }, { @@ -133,6 +237,10 @@ "func_desc": "Returns the arcsine of a number.", "is_nullary": false, "comp_str": "ASIN(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -141,6 +249,10 @@ "func_desc": "Returns the inverse hyperbolic sine of a number.", "is_nullary": false, "comp_str": "ASINH(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -149,6 +261,10 @@ "func_desc": "Returns the arctangent of a number.", "is_nullary": false, "comp_str": "ATAN(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -157,6 +273,11 @@ "func_desc": "Returns the arctangent from x- and y-coordinates.", "is_nullary": false, "comp_str": "ATAN2(${1:x_num},${2: y_num})", + "req_param": [ + "x_num", + "y_num" + ], + "opt_param": [], "ellipsis": false }, { @@ -165,6 +286,10 @@ "func_desc": "Returns the inverse hyperbolic tangent of a number.", "is_nullary": false, "comp_str": "ATANH(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -173,6 +298,12 @@ "func_desc": "Returns the average of the absolute deviations of data points from their mean.", "is_nullary": false, "comp_str": "AVEDEV(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -181,6 +312,12 @@ "func_desc": "Returns the average of its arguments.", "is_nullary": false, "comp_str": "AVERAGE(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -189,6 +326,12 @@ "func_desc": "Returns the average of its arguments, including numbers, text, and logical values.", "is_nullary": false, "comp_str": "AVERAGEA(${1:value1}${2:,${3: [value2], ...}})", + "req_param": [ + "value1" + ], + "opt_param": [ + "value2" + ], "ellipsis": true }, { @@ -197,6 +340,13 @@ "func_desc": "Returns the average (arithmetic mean) of all the cells in a range that meet a given criteria.", "is_nullary": false, "comp_str": "AVERAGEIF(${1:range},${2: criteria}${3:,${4: [average_range]}})", + "req_param": [ + "range", + "criteria" + ], + "opt_param": [ + "average_range" + ], "ellipsis": false }, { @@ -205,6 +355,15 @@ "func_desc": "Returns the average (arithmetic mean) of all cells that meet multiple criteria.", "is_nullary": false, "comp_str": "AVERAGEIFS(${1:average_range},${2: criteria_range1},${3: criteria1}${4:,${5: [criteria_range2]},${6: [criteria2], ...}})", + "req_param": [ + "average_range", + "criteria_range1", + "criteria1" + ], + "opt_param": [ + "criteria_range2", + "criteria2" + ], "ellipsis": true }, { @@ -213,6 +372,10 @@ "func_desc": "Converts a number to text, using the \u00df (baht) currency format.", "is_nullary": false, "comp_str": "BAHTTEXT(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -221,6 +384,13 @@ "func_desc": "Converts a number into a text representation with the given radix (base).", "is_nullary": false, "comp_str": "BASE(${1:number},${2: radix}${3:,${4: [min_length]}})", + "req_param": [ + "number", + "radix" + ], + "opt_param": [ + "min_length" + ], "ellipsis": false }, { @@ -229,6 +399,11 @@ "func_desc": "Returns the modified Bessel function In(x).", "is_nullary": false, "comp_str": "BESSELI(${1:x},${2: n})", + "req_param": [ + "x", + "n" + ], + "opt_param": [], "ellipsis": false }, { @@ -237,6 +412,11 @@ "func_desc": "Returns the Bessel function Jn(x).", "is_nullary": false, "comp_str": "BESSELJ(${1:x},${2: n})", + "req_param": [ + "x", + "n" + ], + "opt_param": [], "ellipsis": false }, { @@ -245,6 +425,11 @@ "func_desc": "Returns the modified Bessel function Kn(x).", "is_nullary": false, "comp_str": "BESSELK(${1:x},${2: n})", + "req_param": [ + "x", + "n" + ], + "opt_param": [], "ellipsis": false }, { @@ -253,6 +438,11 @@ "func_desc": "Returns the Bessel function Yn(x).", "is_nullary": false, "comp_str": "BESSELY(${1:x},${2: n})", + "req_param": [ + "x", + "n" + ], + "opt_param": [], "ellipsis": false }, { @@ -261,6 +451,16 @@ "func_desc": "Returns the beta cumulative distribution function.", "is_nullary": false, "comp_str": "BETA.DIST(${1:x},${2: alpha},${3: beta},${4: cumulative}${5:,${6: [A]},${7: [B]}})", + "req_param": [ + "x", + "alpha", + "beta", + "cumulative" + ], + "opt_param": [ + "A", + "B" + ], "ellipsis": false }, { @@ -269,6 +469,15 @@ "func_desc": "Returns the inverse of the cumulative distribution function for a specified beta distribution.", "is_nullary": false, "comp_str": "BETA.INV(${1:probability},${2: alpha},${3: beta}${4:,${5: [A]},${6: [B]}})", + "req_param": [ + "probability", + "alpha", + "beta" + ], + "opt_param": [ + "A", + "B" + ], "ellipsis": false }, { @@ -277,6 +486,15 @@ "func_desc": "Returns the beta cumulative distribution function. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "BETADIST(${1:x},${2: alpha},${3: beta}${4:,${5: [A]},${6: [B]}})", + "req_param": [ + "x", + "alpha", + "beta" + ], + "opt_param": [ + "A", + "B" + ], "ellipsis": false }, { @@ -285,6 +503,15 @@ "func_desc": "Returns the inverse of the cumulative distribution function for a specified beta. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "BETAINV(${1:probability},${2: alpha},${3: beta}${4:,${5: [A]},${6: [B]}})", + "req_param": [ + "probability", + "alpha", + "beta" + ], + "opt_param": [ + "A", + "B" + ], "ellipsis": false }, { @@ -293,6 +520,10 @@ "func_desc": "Converts a binary number to decimal.", "is_nullary": false, "comp_str": "BIN2DEC(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -301,6 +532,12 @@ "func_desc": "Converts a binary number to hexadecimal.", "is_nullary": false, "comp_str": "BIN2HEX(${1:number}${2:,${3: [places]}})", + "req_param": [ + "number" + ], + "opt_param": [ + "places" + ], "ellipsis": false }, { @@ -309,6 +546,12 @@ "func_desc": "Converts a binary number to octal.", "is_nullary": false, "comp_str": "BIN2OCT(${1:number}${2:,${3: [places]}})", + "req_param": [ + "number" + ], + "opt_param": [ + "places" + ], "ellipsis": false }, { @@ -317,6 +560,13 @@ "func_desc": "Returns the individual term binomial distribution probability.", "is_nullary": false, "comp_str": "BINOM.DIST(${1:number_s},${2: trials},${3: probability_s},${4: cumulative})", + "req_param": [ + "number_s", + "trials", + "probability_s", + "cumulative" + ], + "opt_param": [], "ellipsis": false }, { @@ -325,6 +575,14 @@ "func_desc": "Returns the probability of a trial result using a binomial distribution.", "is_nullary": false, "comp_str": "BINOM.DIST.RANGE(${1:trials},${2: probability_s},${3: number_s}${4:,${5: [number_s2]}})", + "req_param": [ + "trials", + "probability_s", + "number_s" + ], + "opt_param": [ + "number_s2" + ], "ellipsis": false }, { @@ -333,6 +591,12 @@ "func_desc": "Returns the smallest value for which the cumulative binomial distribution is less than or equal to a criterion value.", "is_nullary": false, "comp_str": "BINOM.INV(${1:trials},${2: probability_s},${3: alpha})", + "req_param": [ + "trials", + "probability_s", + "alpha" + ], + "opt_param": [], "ellipsis": false }, { @@ -341,6 +605,13 @@ "func_desc": "Returns the individual term binomial distribution probability. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "BINOMDIST(${1:number_s},${2: trials},${3: probability_s},${4: cumulative})", + "req_param": [ + "number_s", + "trials", + "probability_s", + "cumulative" + ], + "opt_param": [], "ellipsis": false }, { @@ -349,6 +620,11 @@ "func_desc": "Returns a 'Bitwise And' of two numbers.", "is_nullary": false, "comp_str": "BITAND(${1:number1},${2: number2})", + "req_param": [ + "number1", + "number2" + ], + "opt_param": [], "ellipsis": false }, { @@ -357,6 +633,11 @@ "func_desc": "Returns a value number shifted left by shift_amount bits.", "is_nullary": false, "comp_str": "BITLSHIFT(${1:number},${2: shift_amount})", + "req_param": [ + "number", + "shift_amount" + ], + "opt_param": [], "ellipsis": false }, { @@ -365,6 +646,11 @@ "func_desc": "Returns a bitwise OR of 2 numbers.", "is_nullary": false, "comp_str": "BITOR(${1:number1},${2: number2})", + "req_param": [ + "number1", + "number2" + ], + "opt_param": [], "ellipsis": false }, { @@ -373,6 +659,11 @@ "func_desc": "Returns a value number shifted right by shift_amount bits.", "is_nullary": false, "comp_str": "BITRSHIFT(${1:number},${2: shift_amount})", + "req_param": [ + "number", + "shift_amount" + ], + "opt_param": [], "ellipsis": false }, { @@ -381,6 +672,11 @@ "func_desc": "Returns a bitwise 'Exclusive Or' of two numbers.", "is_nullary": false, "comp_str": "BITXOR(${1:number1},${2: number2})", + "req_param": [ + "number1", + "number2" + ], + "opt_param": [], "ellipsis": false }, { @@ -389,6 +685,12 @@ "func_desc": "Applies a LAMBDA to each column and returns an array of the results.", "is_nullary": false, "comp_str": "BYCOL(${1:array}${2:,${3: [function]}})", + "req_param": [ + "array" + ], + "opt_param": [ + "function" + ], "ellipsis": false }, { @@ -397,6 +699,12 @@ "func_desc": "Applies a LAMBDA to each row and returns an array of the results.", "is_nullary": false, "comp_str": "BYROW(${1:array}${2:,${3: [function]}})", + "req_param": [ + "array" + ], + "opt_param": [ + "function" + ], "ellipsis": false }, { @@ -405,6 +713,12 @@ "func_desc": "Calls a procedure in a specified DLL or code resource.", "is_nullary": false, "comp_str": "CALL(${1:register_id}${2:,${3: [argument1], ...}})", + "req_param": [ + "register_id" + ], + "opt_param": [ + "argument1" + ], "ellipsis": true }, { @@ -413,6 +727,11 @@ "func_desc": "Rounds a number to the nearest integer or to the nearest multiple of significance.", "is_nullary": false, "comp_str": "CEILING(${1:number},${2: significance})", + "req_param": [ + "number", + "significance" + ], + "opt_param": [], "ellipsis": false }, { @@ -421,6 +740,13 @@ "func_desc": "Rounds a number up, to the nearest integer or to the nearest multiple of significance.", "is_nullary": false, "comp_str": "CEILING.MATH(${1:number}${2:,${3: [significance]},${4: [mode]}})", + "req_param": [ + "number" + ], + "opt_param": [ + "significance", + "mode" + ], "ellipsis": false }, { @@ -429,6 +755,12 @@ "func_desc": "Rounds a number the nearest integer or to the nearest multiple of significance. Regardless of the sign of the number, the number is rounded up.", "is_nullary": false, "comp_str": "CEILING.PRECISE(${1:number}${2:,${3: [significance]}})", + "req_param": [ + "number" + ], + "opt_param": [ + "significance" + ], "ellipsis": false }, { @@ -437,6 +769,12 @@ "func_desc": "Returns information about the formatting, location, or contents of a cell. This function is not available in Excel Online.", "is_nullary": false, "comp_str": "CELL(${1:info_type}${2:,${3: [reference]}})", + "req_param": [ + "info_type" + ], + "opt_param": [ + "reference" + ], "ellipsis": false }, { @@ -445,6 +783,10 @@ "func_desc": "Returns the character specified by the code number.", "is_nullary": false, "comp_str": "CHAR(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -453,6 +795,11 @@ "func_desc": "Returns the one-tailed probability of the chi-squared. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "CHIDIST(${1:x},${2: deg_freedom})", + "req_param": [ + "x", + "deg_freedom" + ], + "opt_param": [], "ellipsis": false }, { @@ -461,6 +808,11 @@ "func_desc": "Returns the inverse of the one-tailed probability of the chi-squared. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "CHIINV(${1:probability},${2: deg_freedom})", + "req_param": [ + "probability", + "deg_freedom" + ], + "opt_param": [], "ellipsis": false }, { @@ -469,6 +821,12 @@ "func_desc": "Returns the left-tailed probability of the chi-squared distribution.", "is_nullary": false, "comp_str": "CHISQ.DIST(${1:x},${2: deg_freedom},${3: cumulative})", + "req_param": [ + "x", + "deg_freedom", + "cumulative" + ], + "opt_param": [], "ellipsis": false }, { @@ -477,6 +835,11 @@ "func_desc": "Returns the right-tailed probability of the chi-squared distribution.", "is_nullary": false, "comp_str": "CHISQ.DIST.RT(${1:x},${2: deg_freedom})", + "req_param": [ + "x", + "deg_freedom" + ], + "opt_param": [], "ellipsis": false }, { @@ -485,6 +848,11 @@ "func_desc": "Returns the inverse of the left-tailed probability of the chi-squared distribution.", "is_nullary": false, "comp_str": "CHISQ.INV(${1:probability},${2: deg_freedom})", + "req_param": [ + "probability", + "deg_freedom" + ], + "opt_param": [], "ellipsis": false }, { @@ -493,6 +861,11 @@ "func_desc": "Returns the inverse of the right-tailed probability of the chi-squared distribution.", "is_nullary": false, "comp_str": "CHISQ.INV.RT(${1:probability},${2: deg_freedom})", + "req_param": [ + "probability", + "deg_freedom" + ], + "opt_param": [], "ellipsis": false }, { @@ -501,6 +874,11 @@ "func_desc": "Returns the test for independence: the value from the chi-squared distribution for the statistic and the appropriate degrees of freedom.", "is_nullary": false, "comp_str": "CHISQ.TEST(${1:actual_range},${2: expected_range})", + "req_param": [ + "actual_range", + "expected_range" + ], + "opt_param": [], "ellipsis": false }, { @@ -509,6 +887,11 @@ "func_desc": "Returns the test for independence. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "CHITEST(${1:actual_range},${2: expected_range})", + "req_param": [ + "actual_range", + "expected_range" + ], + "opt_param": [], "ellipsis": false }, { @@ -517,6 +900,13 @@ "func_desc": "Chooses a value from a list of values.", "is_nullary": false, "comp_str": "CHOOSE(${1:index_num},${2: value1}${3:,${4: [value2], ...}})", + "req_param": [ + "index_num", + "value1" + ], + "opt_param": [ + "value2" + ], "ellipsis": true }, { @@ -525,6 +915,13 @@ "func_desc": "Returns columns from an array or reference.", "is_nullary": false, "comp_str": "CHOOSECOLS(${1:array},${2: col_num1}${3:,${4: [col_num2], ...}})", + "req_param": [ + "array", + "col_num1" + ], + "opt_param": [ + "col_num2" + ], "ellipsis": true }, { @@ -533,6 +930,13 @@ "func_desc": "Returns rows from an array of reference.", "is_nullary": false, "comp_str": "CHOOSEROWS(${1:array},${2: row_num1}${3:,${4: [row_num2], ...}})", + "req_param": [ + "array", + "row_num1" + ], + "opt_param": [ + "row_num2" + ], "ellipsis": true }, { @@ -541,6 +945,10 @@ "func_desc": "Removes all nonprintable characters from text.", "is_nullary": false, "comp_str": "CLEAN(${1:text})", + "req_param": [ + "text" + ], + "opt_param": [], "ellipsis": false }, { @@ -549,6 +957,10 @@ "func_desc": "Returns a numeric code for the first character in a text string.", "is_nullary": false, "comp_str": "CODE(${1:text})", + "req_param": [ + "text" + ], + "opt_param": [], "ellipsis": false }, { @@ -557,6 +969,10 @@ "func_desc": "Returns the column number of a reference.", "is_nullary": false, "comp_str": "COLUMN(${1:,${2: [reference]}})", + "req_param": [], + "opt_param": [ + "reference" + ], "ellipsis": false }, { @@ -565,6 +981,10 @@ "func_desc": "Returns the number of columns in a reference.", "is_nullary": false, "comp_str": "COLUMNS(${1:array})", + "req_param": [ + "array" + ], + "opt_param": [], "ellipsis": false }, { @@ -573,6 +993,11 @@ "func_desc": "Returns the number of combinations for a given number of objects.", "is_nullary": false, "comp_str": "COMBIN(${1:number},${2: number_chosen})", + "req_param": [ + "number", + "number_chosen" + ], + "opt_param": [], "ellipsis": false }, { @@ -581,6 +1006,11 @@ "func_desc": "Returns the number of combinations with repetitions for a given number of items.", "is_nullary": false, "comp_str": "COMBINA(${1:number},${2: number_chosen})", + "req_param": [ + "number", + "number_chosen" + ], + "opt_param": [], "ellipsis": false }, { @@ -589,6 +1019,13 @@ "func_desc": "Converts real and imaginary coefficients into a complex number.", "is_nullary": false, "comp_str": "COMPLEX(${1:real_num},${2: i_num}${3:,${4: [suffix]}})", + "req_param": [ + "real_num", + "i_num" + ], + "opt_param": [ + "suffix" + ], "ellipsis": false }, { @@ -597,6 +1034,12 @@ "func_desc": "Combines the text from multiple ranges and/or strings, but it doesn't provide the delimiter or IgnoreEmpty arguments. This function isn't available in Excel 2016 for Mac.", "is_nullary": false, "comp_str": "CONCAT(${1:text1}${2:,${3: [text2], ...}})", + "req_param": [ + "text1" + ], + "opt_param": [ + "text2" + ], "ellipsis": true }, { @@ -605,6 +1048,12 @@ "func_desc": "Joins several text items into one text item.", "is_nullary": false, "comp_str": "CONCATENATE(${1:text1}${2:,${3: [text2], ...}})", + "req_param": [ + "text1" + ], + "opt_param": [ + "text2" + ], "ellipsis": true }, { @@ -613,6 +1062,12 @@ "func_desc": "Returns the confidence interval for a population mean. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "CONFIDENCE(${1:alpha},${2: standard_dev},${3: size})", + "req_param": [ + "alpha", + "standard_dev", + "size" + ], + "opt_param": [], "ellipsis": false }, { @@ -621,6 +1076,12 @@ "func_desc": "Returns the confidence interval for a population mean.", "is_nullary": false, "comp_str": "CONFIDENCE.NORM(${1:alpha},${2: standard_dev},${3: size})", + "req_param": [ + "alpha", + "standard_dev", + "size" + ], + "opt_param": [], "ellipsis": false }, { @@ -629,6 +1090,12 @@ "func_desc": "Returns the confidence interval for a population mean, using a Student's t distribution.", "is_nullary": false, "comp_str": "CONFIDENCE.T(${1:alpha},${2: standard_dev},${3: size})", + "req_param": [ + "alpha", + "standard_dev", + "size" + ], + "opt_param": [], "ellipsis": false }, { @@ -637,6 +1104,12 @@ "func_desc": "Converts a number from one measurement system to another.", "is_nullary": false, "comp_str": "CONVERT(${1:number},${2: from_unit},${3: to_unit})", + "req_param": [ + "number", + "from_unit", + "to_unit" + ], + "opt_param": [], "ellipsis": false }, { @@ -645,6 +1118,11 @@ "func_desc": "Returns the correlation coefficient between two data sets.", "is_nullary": false, "comp_str": "CORREL(${1:array1},${2: array2})", + "req_param": [ + "array1", + "array2" + ], + "opt_param": [], "ellipsis": false }, { @@ -653,6 +1131,10 @@ "func_desc": "Returns the cosine of a number.", "is_nullary": false, "comp_str": "COS(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -661,6 +1143,10 @@ "func_desc": "Returns the hyperbolic cosine of a number.", "is_nullary": false, "comp_str": "COSH(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -669,6 +1155,10 @@ "func_desc": "Returns the cotangent of a number.", "is_nullary": false, "comp_str": "COT(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -677,6 +1167,10 @@ "func_desc": "Returns the cotangent of an angle.", "is_nullary": false, "comp_str": "COTH(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -685,6 +1179,12 @@ "func_desc": "Counts how many numbers are in the list of arguments.", "is_nullary": false, "comp_str": "COUNT(${1:value1}${2:,${3: [value2], ...}})", + "req_param": [ + "value1" + ], + "opt_param": [ + "value2" + ], "ellipsis": true }, { @@ -693,6 +1193,12 @@ "func_desc": "Counts how many values are in the list of arguments.", "is_nullary": false, "comp_str": "COUNTA(${1:value1}${2:,${3: [value2], ...}})", + "req_param": [ + "value1" + ], + "opt_param": [ + "value2" + ], "ellipsis": true }, { @@ -701,6 +1207,10 @@ "func_desc": "Counts the number of blank cells within a range.", "is_nullary": false, "comp_str": "COUNTBLANK(${1:range})", + "req_param": [ + "range" + ], + "opt_param": [], "ellipsis": false }, { @@ -709,6 +1219,11 @@ "func_desc": "Counts the number of cells within a range that meet the given criteria.", "is_nullary": false, "comp_str": "COUNTIF(${1:range},${2: criteria})", + "req_param": [ + "range", + "criteria" + ], + "opt_param": [], "ellipsis": false }, { @@ -717,6 +1232,14 @@ "func_desc": "Counts the number of cells within a range that meet multiple criteria.", "is_nullary": false, "comp_str": "COUNTIFS(${1:criteria_range1},${2: criteria1}${3:,${4: [criteria_range2]},${5: [criteria2], ...}})", + "req_param": [ + "criteria_range1", + "criteria1" + ], + "opt_param": [ + "criteria_range2", + "criteria2" + ], "ellipsis": true }, { @@ -725,6 +1248,14 @@ "func_desc": "Returns the number of days from the beginning of the coupon period to the settlement date.", "is_nullary": false, "comp_str": "COUPDAYBS(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})", + "req_param": [ + "settlement", + "maturity", + "frequency" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -733,6 +1264,14 @@ "func_desc": "Returns the number of days in the coupon period that contains the settlement date.", "is_nullary": false, "comp_str": "COUPDAYS(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})", + "req_param": [ + "settlement", + "maturity", + "frequency" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -741,6 +1280,14 @@ "func_desc": "Returns the number of days from the settlement date to the next coupon date.", "is_nullary": false, "comp_str": "COUPDAYSNC(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})", + "req_param": [ + "settlement", + "maturity", + "frequency" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -749,6 +1296,14 @@ "func_desc": "Returns the next coupon date after the settlement date.", "is_nullary": false, "comp_str": "COUPNCD(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})", + "req_param": [ + "settlement", + "maturity", + "frequency" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -757,6 +1312,14 @@ "func_desc": "Returns the number of coupons payable between the settlement date and maturity date.", "is_nullary": false, "comp_str": "COUPNUM(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})", + "req_param": [ + "settlement", + "maturity", + "frequency" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -765,6 +1328,14 @@ "func_desc": "Returns the previous coupon date before the settlement date.", "is_nullary": false, "comp_str": "COUPPCD(${1:settlement},${2: maturity},${3: frequency}${4:,${5: [basis]}})", + "req_param": [ + "settlement", + "maturity", + "frequency" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -773,6 +1344,11 @@ "func_desc": "Returns covariance, the average of the products of paired deviations. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "COVAR(${1:array1},${2: array2})", + "req_param": [ + "array1", + "array2" + ], + "opt_param": [], "ellipsis": false }, { @@ -781,6 +1357,11 @@ "func_desc": "Returns covariance, the average of the products of paired deviations.", "is_nullary": false, "comp_str": "COVARIANCE.P(${1:array1},${2: array2})", + "req_param": [ + "array1", + "array2" + ], + "opt_param": [], "ellipsis": false }, { @@ -789,6 +1370,11 @@ "func_desc": "Returns the sample covariance, the average of the products deviations for each data point pair in two data sets.", "is_nullary": false, "comp_str": "COVARIANCE.S(${1:array1},${2: array2})", + "req_param": [ + "array1", + "array2" + ], + "opt_param": [], "ellipsis": false }, { @@ -797,6 +1383,12 @@ "func_desc": "Returns the smallest value for which the cumulative binomial distribution is less than or equal to a criterion value. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "CRITBINOM(${1:trials},${2: probability_s},${3: alpha})", + "req_param": [ + "trials", + "probability_s", + "alpha" + ], + "opt_param": [], "ellipsis": false }, { @@ -805,6 +1397,10 @@ "func_desc": "Returns the cosecant of an angle.", "is_nullary": false, "comp_str": "CSC(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -813,6 +1409,10 @@ "func_desc": "Returns the hyperbolic cosecant of an angle.", "is_nullary": false, "comp_str": "CSCH(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -821,6 +1421,14 @@ "func_desc": "Returns a key performance (KPI) name, property, and measure, and displays the name and property in the cell. A KPI is a quantifiable measurement, such as monthly gross profit or quarterly employee turnover, used to monitor an organization's performance.", "is_nullary": false, "comp_str": "CUBEKPIMEMBER(${1:connection},${2: kpi_name},${3: kpi_property}${4:,${5: [caption]}})", + "req_param": [ + "connection", + "kpi_name", + "kpi_property" + ], + "opt_param": [ + "caption" + ], "ellipsis": false }, { @@ -829,6 +1437,13 @@ "func_desc": "Returns a member or tuple in a cube hierarchy. Use to validate that the member or tuple exists in the cube.", "is_nullary": false, "comp_str": "CUBEMEMBER(${1:connection},${2: member_expression}${3:,${4: [caption]}})", + "req_param": [ + "connection", + "member_expression" + ], + "opt_param": [ + "caption" + ], "ellipsis": false }, { @@ -837,6 +1452,12 @@ "func_desc": "Returns the value of a member property in the cube. Use to validate that a member name exists within the cube and to return the specified property for this member.", "is_nullary": false, "comp_str": "CUBEMEMBERPROPERTY(${1:connection},${2: member_expression},${3: property})", + "req_param": [ + "connection", + "member_expression", + "property" + ], + "opt_param": [], "ellipsis": false }, { @@ -845,6 +1466,14 @@ "func_desc": "Returns the nth, or ranked, member in a set. Use to return one or more elements in a set, such as the top sales performer or top 10 students.", "is_nullary": false, "comp_str": "CUBERANKEDMEMBER(${1:connection},${2: set_expression},${3: rank}${4:,${5: [caption]}})", + "req_param": [ + "connection", + "set_expression", + "rank" + ], + "opt_param": [ + "caption" + ], "ellipsis": false }, { @@ -853,6 +1482,15 @@ "func_desc": "Defines a calculated set of members or tuples by sending a set expression to the cube on the server, which creates the set, and then returns that set to Microsoft Office Excel.", "is_nullary": false, "comp_str": "CUBESET(${1:connection},${2: set_expression}${3:,${4: [caption]},${5: [sort_order]},${6: [sort_by]}})", + "req_param": [ + "connection", + "set_expression" + ], + "opt_param": [ + "caption", + "sort_order", + "sort_by" + ], "ellipsis": false }, { @@ -861,6 +1499,10 @@ "func_desc": "Returns the number of items in a set.", "is_nullary": false, "comp_str": "CUBESETCOUNT(${1:set})", + "req_param": [ + "set" + ], + "opt_param": [], "ellipsis": false }, { @@ -869,6 +1511,12 @@ "func_desc": "Returns an aggregated value from a cube.", "is_nullary": false, "comp_str": "CUBEVALUE(${1:connection}${2:,${3: [member_expression1], ...}})", + "req_param": [ + "connection" + ], + "opt_param": [ + "member_expression1" + ], "ellipsis": true }, { @@ -877,6 +1525,15 @@ "func_desc": "Returns the cumulative interest paid between two periods.", "is_nullary": false, "comp_str": "CUMIPMT(${1:rate},${2: nper},${3: pv},${4: start_period},${5: end_period},${6: type})", + "req_param": [ + "rate", + "nper", + "pv", + "start_period", + "end_period", + "type" + ], + "opt_param": [], "ellipsis": false }, { @@ -885,6 +1542,15 @@ "func_desc": "Returns the cumulative principal paid on a loan between two periods.", "is_nullary": false, "comp_str": "CUMPRINC(${1:rate},${2: nper},${3: pv},${4: start_period},${5: end_period},${6: type})", + "req_param": [ + "rate", + "nper", + "pv", + "start_period", + "end_period", + "type" + ], + "opt_param": [], "ellipsis": false }, { @@ -893,6 +1559,12 @@ "func_desc": "Returns the serial number of a particular date.", "is_nullary": false, "comp_str": "DATE(${1:year},${2: month},${3: day})", + "req_param": [ + "year", + "month", + "day" + ], + "opt_param": [], "ellipsis": false }, { @@ -901,6 +1573,12 @@ "func_desc": "Calculates the number of days, months, or years between two dates. This is useful in formulas where you need to calculate an age.", "is_nullary": false, "comp_str": "DATEDIF(${1:start_date},${2: end_date},${3: unit})", + "req_param": [ + "start_date", + "end_date", + "unit" + ], + "opt_param": [], "ellipsis": false }, { @@ -909,6 +1587,10 @@ "func_desc": "Converts a date in the form of text to a serial number.", "is_nullary": false, "comp_str": "DATEVALUE(${1:date_text})", + "req_param": [ + "date_text" + ], + "opt_param": [], "ellipsis": false }, { @@ -917,6 +1599,12 @@ "func_desc": "Returns the average of selected database entries.", "is_nullary": false, "comp_str": "DAVERAGE(${1:database},${2: field},${3: criteria})", + "req_param": [ + "database", + "field", + "criteria" + ], + "opt_param": [], "ellipsis": false }, { @@ -925,6 +1613,10 @@ "func_desc": "Converts a serial number to a day of the month.", "is_nullary": false, "comp_str": "DAY(${1:serial_number})", + "req_param": [ + "serial_number" + ], + "opt_param": [], "ellipsis": false }, { @@ -933,6 +1625,11 @@ "func_desc": "Returns the number of days between two dates.", "is_nullary": false, "comp_str": "DAYS(${1:end_date},${2: start_date})", + "req_param": [ + "end_date", + "start_date" + ], + "opt_param": [], "ellipsis": false }, { @@ -941,6 +1638,13 @@ "func_desc": "Calculates the number of days between two dates based on a 360-day year.", "is_nullary": false, "comp_str": "DAYS360(${1:start_date},${2: end_date}${3:,${4: [method]}})", + "req_param": [ + "start_date", + "end_date" + ], + "opt_param": [ + "method" + ], "ellipsis": false }, { @@ -949,6 +1653,15 @@ "func_desc": "Returns the depreciation of an asset for a specified period by using the fixed-declining balance method.", "is_nullary": false, "comp_str": "DB(${1:cost},${2: salvage},${3: life},${4: period}${5:,${6: [month]}})", + "req_param": [ + "cost", + "salvage", + "life", + "period" + ], + "opt_param": [ + "month" + ], "ellipsis": false }, { @@ -957,6 +1670,10 @@ "func_desc": "Changes half-width (single-byte) English letters or katakana within a character string to full-width (double-byte) characters.", "is_nullary": false, "comp_str": "DBCS(${1:text})", + "req_param": [ + "text" + ], + "opt_param": [], "ellipsis": false }, { @@ -965,6 +1682,12 @@ "func_desc": "Counts the cells that contain numbers in a database.", "is_nullary": false, "comp_str": "DCOUNT(${1:database},${2: field},${3: criteria})", + "req_param": [ + "database", + "field", + "criteria" + ], + "opt_param": [], "ellipsis": false }, { @@ -973,6 +1696,12 @@ "func_desc": "Counts nonblank cells in a database.", "is_nullary": false, "comp_str": "DCOUNTA(${1:database},${2: field},${3: criteria})", + "req_param": [ + "database", + "field", + "criteria" + ], + "opt_param": [], "ellipsis": false }, { @@ -981,6 +1710,15 @@ "func_desc": "Returns the depreciation of an asset for a specified period by using the double-declining balance method or some other method that you specify.", "is_nullary": false, "comp_str": "DDB(${1:cost},${2: salvage},${3: life},${4: period}${5:,${6: [factor]}})", + "req_param": [ + "cost", + "salvage", + "life", + "period" + ], + "opt_param": [ + "factor" + ], "ellipsis": false }, { @@ -989,6 +1727,12 @@ "func_desc": "Converts a decimal number to binary.", "is_nullary": false, "comp_str": "DEC2BIN(${1:number}${2:,${3: [places]}})", + "req_param": [ + "number" + ], + "opt_param": [ + "places" + ], "ellipsis": false }, { @@ -997,6 +1741,12 @@ "func_desc": "Converts a decimal number to hexadecimal.", "is_nullary": false, "comp_str": "DEC2HEX(${1:number}${2:,${3: [places]}})", + "req_param": [ + "number" + ], + "opt_param": [ + "places" + ], "ellipsis": false }, { @@ -1005,6 +1755,12 @@ "func_desc": "Converts a decimal number to octal.", "is_nullary": false, "comp_str": "DEC2OCT(${1:number}${2:,${3: [places]}})", + "req_param": [ + "number" + ], + "opt_param": [ + "places" + ], "ellipsis": false }, { @@ -1013,6 +1769,11 @@ "func_desc": "Converts a text representation of a number in a given base into a decimal number.", "is_nullary": false, "comp_str": "DECIMAL(${1:number},${2: radix})", + "req_param": [ + "number", + "radix" + ], + "opt_param": [], "ellipsis": false }, { @@ -1021,6 +1782,10 @@ "func_desc": "Converts radians to degrees.", "is_nullary": false, "comp_str": "DEGREES(${1:angle})", + "req_param": [ + "angle" + ], + "opt_param": [], "ellipsis": false }, { @@ -1029,6 +1794,12 @@ "func_desc": "Tests whether two values are equal.", "is_nullary": false, "comp_str": "DELTA(${1:number1}${2:,${3: [number2]}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": false }, { @@ -1037,6 +1808,12 @@ "func_desc": "Returns the sum of squares of deviations.", "is_nullary": false, "comp_str": "DEVSQ(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -1045,6 +1822,12 @@ "func_desc": "Extracts from a database a single record that matches the specified criteria.", "is_nullary": false, "comp_str": "DGET(${1:database},${2: field},${3: criteria})", + "req_param": [ + "database", + "field", + "criteria" + ], + "opt_param": [], "ellipsis": false }, { @@ -1053,6 +1836,15 @@ "func_desc": "Returns the discount rate for a security.", "is_nullary": false, "comp_str": "DISC(${1:settlement},${2: maturity},${3: pr},${4: redemption}${5:,${6: [basis]}})", + "req_param": [ + "settlement", + "maturity", + "pr", + "redemption" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -1061,6 +1853,12 @@ "func_desc": "Returns the maximum value from selected database entries.", "is_nullary": false, "comp_str": "DMAX(${1:database},${2: field},${3: criteria})", + "req_param": [ + "database", + "field", + "criteria" + ], + "opt_param": [], "ellipsis": false }, { @@ -1069,6 +1867,12 @@ "func_desc": "Returns the minimum value from selected database entries.", "is_nullary": false, "comp_str": "DMIN(${1:database},${2: field},${3: criteria})", + "req_param": [ + "database", + "field", + "criteria" + ], + "opt_param": [], "ellipsis": false }, { @@ -1077,6 +1881,12 @@ "func_desc": "Converts a number to text, using the $ (dollar) currency format.", "is_nullary": false, "comp_str": "DOLLAR(${1:number}${2:,${3: [decimals]}})", + "req_param": [ + "number" + ], + "opt_param": [ + "decimals" + ], "ellipsis": false }, { @@ -1085,6 +1895,11 @@ "func_desc": "Converts a dollar price, expressed as a fraction, into a dollar price, expressed as a decimal number.", "is_nullary": false, "comp_str": "DOLLARDE(${1:fractional_dollar},${2: fraction})", + "req_param": [ + "fractional_dollar", + "fraction" + ], + "opt_param": [], "ellipsis": false }, { @@ -1093,6 +1908,11 @@ "func_desc": "Converts a dollar price, expressed as a decimal number, into a dollar price, expressed as a fraction.", "is_nullary": false, "comp_str": "DOLLARFR(${1:decimal_dollar},${2: fraction})", + "req_param": [ + "decimal_dollar", + "fraction" + ], + "opt_param": [], "ellipsis": false }, { @@ -1101,6 +1921,12 @@ "func_desc": "Multiplies the values in a particular field of records that match the criteria in a database.", "is_nullary": false, "comp_str": "DPRODUCT(${1:database},${2: field},${3: criteria})", + "req_param": [ + "database", + "field", + "criteria" + ], + "opt_param": [], "ellipsis": false }, { @@ -1109,6 +1935,13 @@ "func_desc": "Removes rows or columns from the start or end of an array.", "is_nullary": false, "comp_str": "DROP(${1:array},${2: rows}${3:,${4: [columns]}})", + "req_param": [ + "array", + "rows" + ], + "opt_param": [ + "columns" + ], "ellipsis": false }, { @@ -1117,6 +1950,12 @@ "func_desc": "Estimates the standard deviation based on a sample of selected database entries.", "is_nullary": false, "comp_str": "DSTDEV(${1:database},${2: field},${3: criteria})", + "req_param": [ + "database", + "field", + "criteria" + ], + "opt_param": [], "ellipsis": false }, { @@ -1125,6 +1964,12 @@ "func_desc": "Calculates the standard deviation based on the entire population of selected database entries.", "is_nullary": false, "comp_str": "DSTDEVP(${1:database},${2: field},${3: criteria})", + "req_param": [ + "database", + "field", + "criteria" + ], + "opt_param": [], "ellipsis": false }, { @@ -1133,6 +1978,12 @@ "func_desc": "Adds the numbers in the field column of records in the database that match the criteria.", "is_nullary": false, "comp_str": "DSUM(${1:database},${2: field},${3: criteria})", + "req_param": [ + "database", + "field", + "criteria" + ], + "opt_param": [], "ellipsis": false }, { @@ -1141,6 +1992,16 @@ "func_desc": "Returns the annual duration of a security with periodic interest payments.", "is_nullary": false, "comp_str": "DURATION(${1:settlement},${2: maturity},${3: coupon},${4: yld},${5: frequency}${6:,${7: [basis]}})", + "req_param": [ + "settlement", + "maturity", + "coupon", + "yld", + "frequency" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -1149,6 +2010,12 @@ "func_desc": "Estimates variance based on a sample from selected database entries.", "is_nullary": false, "comp_str": "DVAR(${1:database},${2: field},${3: criteria})", + "req_param": [ + "database", + "field", + "criteria" + ], + "opt_param": [], "ellipsis": false }, { @@ -1157,6 +2024,12 @@ "func_desc": "Calculates variance based on the entire population of selected database entries.", "is_nullary": false, "comp_str": "DVARP(${1:database},${2: field},${3: criteria})", + "req_param": [ + "database", + "field", + "criteria" + ], + "opt_param": [], "ellipsis": false }, { @@ -1165,6 +2038,11 @@ "func_desc": "Returns the serial number of the date that is the indicated number of months before or after the start date.", "is_nullary": false, "comp_str": "EDATE(${1:start_date},${2: months})", + "req_param": [ + "start_date", + "months" + ], + "opt_param": [], "ellipsis": false }, { @@ -1173,6 +2051,11 @@ "func_desc": "Returns the effective annual interest rate.", "is_nullary": false, "comp_str": "EFFECT(${1:nominal_rate},${2: npery})", + "req_param": [ + "nominal_rate", + "npery" + ], + "opt_param": [], "ellipsis": false }, { @@ -1181,6 +2064,10 @@ "func_desc": "Returns a URL-encoded string. This function is not available in Excel Online.", "is_nullary": false, "comp_str": "ENCODEURL(${1:text})", + "req_param": [ + "text" + ], + "opt_param": [], "ellipsis": false }, { @@ -1189,6 +2076,11 @@ "func_desc": "Returns the serial number of the last day of the month before or after a specified number of months.", "is_nullary": false, "comp_str": "EOMONTH(${1:start_date},${2: months})", + "req_param": [ + "start_date", + "months" + ], + "opt_param": [], "ellipsis": false }, { @@ -1197,6 +2089,12 @@ "func_desc": "Returns the error function integrated between lower_limit and upper_limit.", "is_nullary": false, "comp_str": "ERF(${1:lower_limit}${2:,${3: [upper_limit]}})", + "req_param": [ + "lower_limit" + ], + "opt_param": [ + "upper_limit" + ], "ellipsis": false }, { @@ -1205,6 +2103,10 @@ "func_desc": "Returns the error function integrated between lower_limit and 0.", "is_nullary": false, "comp_str": "ERF.PRECISE(${1:x})", + "req_param": [ + "x" + ], + "opt_param": [], "ellipsis": false }, { @@ -1213,6 +2115,10 @@ "func_desc": "Returns the complementary error function.", "is_nullary": false, "comp_str": "ERFC(${1:x})", + "req_param": [ + "x" + ], + "opt_param": [], "ellipsis": false }, { @@ -1221,6 +2127,10 @@ "func_desc": "Returns the complementary ERF function integrated between x and infinity.", "is_nullary": false, "comp_str": "ERFC.PRECISE(${1:x})", + "req_param": [ + "x" + ], + "opt_param": [], "ellipsis": false }, { @@ -1229,6 +2139,10 @@ "func_desc": "Returns a number corresponding to an error type.", "is_nullary": false, "comp_str": "ERROR.TYPE(${1:error_val})", + "req_param": [ + "error_val" + ], + "opt_param": [], "ellipsis": false }, { @@ -1237,6 +2151,14 @@ "func_desc": "Converts a number to euros, from euros to euro member currency, or between euro member currencies using euro as intermediary.", "is_nullary": false, "comp_str": "EUROCONVERT(${1:number},${2: source},${3: target},${4: full_precision},${5: triangulation_precision})", + "req_param": [ + "number", + "source", + "target", + "full_precision", + "triangulation_precision" + ], + "opt_param": [], "ellipsis": false }, { @@ -1245,6 +2167,10 @@ "func_desc": "Rounds a number up to the nearest even integer.", "is_nullary": false, "comp_str": "EVEN(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -1253,6 +2179,11 @@ "func_desc": "Checks to see if two text values are identical.", "is_nullary": false, "comp_str": "EXACT(${1:text1},${2: text2})", + "req_param": [ + "text1", + "text2" + ], + "opt_param": [], "ellipsis": false }, { @@ -1261,6 +2192,10 @@ "func_desc": "Returns e raised to the power of a given number.", "is_nullary": false, "comp_str": "EXP(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -1269,6 +2204,14 @@ "func_desc": "Expands an array to the specified dimensions. ", "is_nullary": false, "comp_str": "EXPAND(${1:array},${2: rows}${3:,${4: [columns]},${5: [pad_with]}})", + "req_param": [ + "array", + "rows" + ], + "opt_param": [ + "columns", + "pad_with" + ], "ellipsis": false }, { @@ -1277,6 +2220,12 @@ "func_desc": "Returns the exponential distribution.", "is_nullary": false, "comp_str": "EXPON.DIST(${1:x},${2: lambda},${3: cumulative})", + "req_param": [ + "x", + "lambda", + "cumulative" + ], + "opt_param": [], "ellipsis": false }, { @@ -1285,6 +2234,12 @@ "func_desc": "Returns the exponential. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "EXPONDIST(${1:x},${2: lambda},${3: cumulative})", + "req_param": [ + "x", + "lambda", + "cumulative" + ], + "opt_param": [], "ellipsis": false }, { @@ -1293,6 +2248,13 @@ "func_desc": "Returns the (left-tailed) F probability distribution (degree of diversity) for two data sets.", "is_nullary": false, "comp_str": "F.DIST(${1:x},${2: deg_freedom1},${3: deg_freedom2},${4: cumulative})", + "req_param": [ + "x", + "deg_freedom1", + "deg_freedom2", + "cumulative" + ], + "opt_param": [], "ellipsis": false }, { @@ -1301,6 +2263,12 @@ "func_desc": "Returns the (right-tailed) F probability distribution (degree of diversity) for two data sets.", "is_nullary": false, "comp_str": "F.DIST.RT(${1:x},${2: deg_freedom1},${3: deg_freedom2})", + "req_param": [ + "x", + "deg_freedom1", + "deg_freedom2" + ], + "opt_param": [], "ellipsis": false }, { @@ -1309,6 +2277,12 @@ "func_desc": "Returns the inverse of the (left-tailed) F probability distribution.", "is_nullary": false, "comp_str": "F.INV(${1:probability},${2: deg_freedom1},${3: deg_freedom2})", + "req_param": [ + "probability", + "deg_freedom1", + "deg_freedom2" + ], + "opt_param": [], "ellipsis": false }, { @@ -1317,6 +2291,12 @@ "func_desc": "Returns the inverse of the (right-tailed) F probability distribution.", "is_nullary": false, "comp_str": "F.INV.RT(${1:probability},${2: deg_freedom1},${3: deg_freedom2})", + "req_param": [ + "probability", + "deg_freedom1", + "deg_freedom2" + ], + "opt_param": [], "ellipsis": false }, { @@ -1325,6 +2305,11 @@ "func_desc": "Returns the result of an F-test.", "is_nullary": false, "comp_str": "F.TEST(${1:array1},${2: array2})", + "req_param": [ + "array1", + "array2" + ], + "opt_param": [], "ellipsis": false }, { @@ -1333,6 +2318,10 @@ "func_desc": "Returns the factorial of a number.", "is_nullary": false, "comp_str": "FACT(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -1341,6 +2330,10 @@ "func_desc": "Returns the double factorial of a number.", "is_nullary": false, "comp_str": "FACTDOUBLE(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -1349,6 +2342,12 @@ "func_desc": "Returns the F probability. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "FDIST(${1:x},${2: deg_freedom1},${3: deg_freedom2})", + "req_param": [ + "x", + "deg_freedom1", + "deg_freedom2" + ], + "opt_param": [], "ellipsis": false }, { @@ -1357,6 +2356,13 @@ "func_desc": "Filters a range of data based on criteria you define.", "is_nullary": false, "comp_str": "FILTER(${1:array},${2: include}${3:,${4: [if_empty]}})", + "req_param": [ + "array", + "include" + ], + "opt_param": [ + "if_empty" + ], "ellipsis": false }, { @@ -1365,6 +2371,11 @@ "func_desc": "Returns specific data from the XML content by using the specified XPath. This function is not available in Excel Online.", "is_nullary": false, "comp_str": "FILTERXML(${1:xml},${2: xpath})", + "req_param": [ + "xml", + "xpath" + ], + "opt_param": [], "ellipsis": false }, { @@ -1373,6 +2384,13 @@ "func_desc": "Returns the position of a substring within a text string, case-sensitive.", "is_nullary": false, "comp_str": "FIND(${1:find_text},${2: within_text}${3:,${4: [start_num]}})", + "req_param": [ + "find_text", + "within_text" + ], + "opt_param": [ + "start_num" + ], "ellipsis": false }, { @@ -1381,6 +2399,13 @@ "func_desc": "Returns the position of the last occurrence of a specified substring within a text string, counting by bytes.", "is_nullary": false, "comp_str": "FINDB(${1:find_text},${2: within_text}${3:,${4: [start_num]}})", + "req_param": [ + "find_text", + "within_text" + ], + "opt_param": [ + "start_num" + ], "ellipsis": false }, { @@ -1389,6 +2414,12 @@ "func_desc": "Returns the inverse of the F probability distribution.", "is_nullary": false, "comp_str": "FINV(${1:probability},${2: deg_freedom1},${3: deg_freedom2})", + "req_param": [ + "probability", + "deg_freedom1", + "deg_freedom2" + ], + "opt_param": [], "ellipsis": false }, { @@ -1397,6 +2428,10 @@ "func_desc": "Returns the Fisher transformation.", "is_nullary": false, "comp_str": "FISHER(${1:x})", + "req_param": [ + "x" + ], + "opt_param": [], "ellipsis": false }, { @@ -1405,6 +2440,10 @@ "func_desc": "Returns the inverse of the Fisher transformation.", "is_nullary": false, "comp_str": "FISHERINV(${1:y})", + "req_param": [ + "y" + ], + "opt_param": [], "ellipsis": false }, { @@ -1413,6 +2452,13 @@ "func_desc": "Formats a number as text with a fixed number of decimals.", "is_nullary": false, "comp_str": "FIXED(${1:number}${2:,${3: [decimals]},${4: [no_commas]}})", + "req_param": [ + "number" + ], + "opt_param": [ + "decimals", + "no_commas" + ], "ellipsis": false }, { @@ -1421,6 +2467,11 @@ "func_desc": "Rounds a number down, toward zero. In Excel 2007 and Excel 2010, this is a Math and trigonometry function.. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "FLOOR(${1:number},${2: significance})", + "req_param": [ + "number", + "significance" + ], + "opt_param": [], "ellipsis": false }, { @@ -1429,6 +2480,13 @@ "func_desc": "Rounds a number down, to the nearest integer or to the nearest multiple of significance.", "is_nullary": false, "comp_str": "FLOOR.MATH(${1:number}${2:,${3: [significance]},${4: [mode]}})", + "req_param": [ + "number" + ], + "opt_param": [ + "significance", + "mode" + ], "ellipsis": false }, { @@ -1437,6 +2495,12 @@ "func_desc": "Rounds a number the nearest integer or to the nearest multiple of significance. Regardless of the sign of the number, the number is rounded up.", "is_nullary": false, "comp_str": "FLOOR.PRECISE(${1:number}${2:,${3: [significance]}})", + "req_param": [ + "number" + ], + "opt_param": [ + "significance" + ], "ellipsis": false }, { @@ -1445,6 +2509,12 @@ "func_desc": "Returns a value along a linear trend. In Excel 2016, this function is replaced with FORECAST.LINEAR as part of the new Forecasting functions, but it's still available for compatibility with earlier versions.", "is_nullary": false, "comp_str": "FORECAST(${1:x},${2: known_ys},${3: known_xs})", + "req_param": [ + "x", + "known_ys", + "known_xs" + ], + "opt_param": [], "ellipsis": false }, { @@ -1453,6 +2523,16 @@ "func_desc": "Returns a future value based on existing (historical) values by using the AAA version of the Exponential Smoothing (ETS) algorithm. This function isn't available in Excel 2016 for Mac.", "is_nullary": false, "comp_str": "FORECAST.ETS(${1:target_date},${2: values},${3: timeline}${4:,${5: [seasonality]},${6: [data_completion]},${7: [aggregation]}})", + "req_param": [ + "target_date", + "values", + "timeline" + ], + "opt_param": [ + "seasonality", + "data_completion", + "aggregation" + ], "ellipsis": false }, { @@ -1461,6 +2541,17 @@ "func_desc": "Returns a confidence interval for the forecast value at the specified target date. This function isn't available in Excel 2016 for Mac.", "is_nullary": false, "comp_str": "FORECAST.ETS.CONFINT(${1:target_date},${2: values},${3: timeline}${4:,${5: [confidence_level]},${6: [seasonality]},${7: [data_completion]},${8: [aggregation]}})", + "req_param": [ + "target_date", + "values", + "timeline" + ], + "opt_param": [ + "confidence_level", + "seasonality", + "data_completion", + "aggregation" + ], "ellipsis": false }, { @@ -1469,6 +2560,14 @@ "func_desc": "Returns the length of the repetitive pattern Excel detects for the specified time series. This function isn't available in Excel 2016 for Mac.", "is_nullary": false, "comp_str": "FORECAST.ETS.SEASONALITY(${1:values},${2: timeline}${3:,${4: [data_completion]},${5: [aggregation]}})", + "req_param": [ + "values", + "timeline" + ], + "opt_param": [ + "data_completion", + "aggregation" + ], "ellipsis": false }, { @@ -1477,6 +2576,16 @@ "func_desc": "Returns a statistical value as a result of time series forecasting. This function isn't available in Excel 2016 for Mac.", "is_nullary": false, "comp_str": "FORECAST.ETS.STAT(${1:values},${2: timeline},${3: statistic_type}${4:,${5: [seasonality]},${6: [data_completion]},${7: [aggregation]}})", + "req_param": [ + "values", + "timeline", + "statistic_type" + ], + "opt_param": [ + "seasonality", + "data_completion", + "aggregation" + ], "ellipsis": false }, { @@ -1485,6 +2594,12 @@ "func_desc": "Returns a future value based on existing values. This function isn't available in Excel 2016 for Mac.", "is_nullary": false, "comp_str": "FORECAST.LINEAR(${1:x},${2: known_ys},${3: known_xs})", + "req_param": [ + "x", + "known_ys", + "known_xs" + ], + "opt_param": [], "ellipsis": false }, { @@ -1493,6 +2608,10 @@ "func_desc": "Returns the formula at the given reference as text.", "is_nullary": false, "comp_str": "FORMULATEXT(${1:reference})", + "req_param": [ + "reference" + ], + "opt_param": [], "ellipsis": false }, { @@ -1501,6 +2620,11 @@ "func_desc": "Returns a frequency distribution as a vertical array.", "is_nullary": false, "comp_str": "FREQUENCY(${1:data_array},${2: bins_array})", + "req_param": [ + "data_array", + "bins_array" + ], + "opt_param": [], "ellipsis": false }, { @@ -1509,6 +2633,11 @@ "func_desc": "Returns the result of an F-test. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "FTEST(${1:array1},${2: array2})", + "req_param": [ + "array1", + "array2" + ], + "opt_param": [], "ellipsis": false }, { @@ -1517,6 +2646,15 @@ "func_desc": "Returns the future value of an investment.", "is_nullary": false, "comp_str": "FV(${1:rate},${2: nper},${3: pmt}${4:,${5: [pv]},${6: [type]}})", + "req_param": [ + "rate", + "nper", + "pmt" + ], + "opt_param": [ + "pv", + "type" + ], "ellipsis": false }, { @@ -1525,6 +2663,11 @@ "func_desc": "Returns the future value of an initial principal after applying a series of compound interest rates.", "is_nullary": false, "comp_str": "FVSCHEDULE(${1:principal},${2: schedule})", + "req_param": [ + "principal", + "schedule" + ], + "opt_param": [], "ellipsis": false }, { @@ -1533,6 +2676,10 @@ "func_desc": "Returns the Gamma function value.", "is_nullary": false, "comp_str": "GAMMA(${1:x})", + "req_param": [ + "x" + ], + "opt_param": [], "ellipsis": false }, { @@ -1541,6 +2688,13 @@ "func_desc": "Returns the gamma distribution.", "is_nullary": false, "comp_str": "GAMMA.DIST(${1:x},${2: alpha},${3: beta},${4: cumulative})", + "req_param": [ + "x", + "alpha", + "beta", + "cumulative" + ], + "opt_param": [], "ellipsis": false }, { @@ -1549,6 +2703,12 @@ "func_desc": "Returns the inverse of the gamma cumulative distribution.", "is_nullary": false, "comp_str": "GAMMA.INV(${1:probability},${2: alpha},${3: beta})", + "req_param": [ + "probability", + "alpha", + "beta" + ], + "opt_param": [], "ellipsis": false }, { @@ -1557,6 +2717,13 @@ "func_desc": "Returns the gamma. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "GAMMADIST(${1:x},${2: alpha},${3: beta},${4: cumulative})", + "req_param": [ + "x", + "alpha", + "beta", + "cumulative" + ], + "opt_param": [], "ellipsis": false }, { @@ -1565,6 +2732,12 @@ "func_desc": "Returns the inverse of the gamma cumulative. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "GAMMAINV(${1:probability},${2: alpha},${3: beta})", + "req_param": [ + "probability", + "alpha", + "beta" + ], + "opt_param": [], "ellipsis": false }, { @@ -1573,6 +2746,10 @@ "func_desc": "Returns the natural logarithm of the gamma function, \u0393(x).", "is_nullary": false, "comp_str": "GAMMALN(${1:x})", + "req_param": [ + "x" + ], + "opt_param": [], "ellipsis": false }, { @@ -1581,6 +2758,10 @@ "func_desc": "Returns the natural logarithm of the gamma function, \u0393(x).", "is_nullary": false, "comp_str": "GAMMALN.PRECISE(${1:x})", + "req_param": [ + "x" + ], + "opt_param": [], "ellipsis": false }, { @@ -1589,6 +2770,10 @@ "func_desc": "Returns 0.5 less than the standard normal cumulative distribution.", "is_nullary": false, "comp_str": "GAUSS(${1:x})", + "req_param": [ + "x" + ], + "opt_param": [], "ellipsis": false }, { @@ -1597,6 +2782,12 @@ "func_desc": "Returns the greatest common divisor.", "is_nullary": false, "comp_str": "GCD(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -1605,6 +2796,12 @@ "func_desc": "Returns the geometric mean.", "is_nullary": false, "comp_str": "GEOMEAN(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -1613,6 +2810,12 @@ "func_desc": "Tests whether a number is greater than a threshold value.", "is_nullary": false, "comp_str": "GESTEP(${1:number}${2:,${3: [step]}})", + "req_param": [ + "number" + ], + "opt_param": [ + "step" + ], "ellipsis": false }, { @@ -1621,6 +2824,14 @@ "func_desc": "Returns data stored in a PivotTable report.", "is_nullary": false, "comp_str": "GETPIVOTDATA(${1:data_field},${2: pivot_table}${3:,${4: [field1]},${5: [item1], ...}})", + "req_param": [ + "data_field", + "pivot_table" + ], + "opt_param": [ + "field1", + "item1" + ], "ellipsis": true }, { @@ -1629,6 +2840,14 @@ "func_desc": "Returns values along an exponential trend.", "is_nullary": false, "comp_str": "GROWTH(${1:known_ys}${2:,${3: [known_xs]},${4: [new_xs]},${5: [const]}})", + "req_param": [ + "known_ys" + ], + "opt_param": [ + "known_xs", + "new_xs", + "const" + ], "ellipsis": false }, { @@ -1637,6 +2856,12 @@ "func_desc": "Returns the harmonic mean.", "is_nullary": false, "comp_str": "HARMEAN(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -1645,6 +2870,12 @@ "func_desc": "Converts a hexadecimal number to binary.", "is_nullary": false, "comp_str": "HEX2BIN(${1:number}${2:,${3: [places]}})", + "req_param": [ + "number" + ], + "opt_param": [ + "places" + ], "ellipsis": false }, { @@ -1653,6 +2884,10 @@ "func_desc": "Converts a hexadecimal number to decimal.", "is_nullary": false, "comp_str": "HEX2DEC(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -1661,6 +2896,12 @@ "func_desc": "Converts a hexadecimal number to octal.", "is_nullary": false, "comp_str": "HEX2OCT(${1:number}${2:,${3: [places]}})", + "req_param": [ + "number" + ], + "opt_param": [ + "places" + ], "ellipsis": false }, { @@ -1669,6 +2910,14 @@ "func_desc": "Looks in the top row of an array and returns the value of the indicated cell.", "is_nullary": false, "comp_str": "HLOOKUP(${1:lookup_value},${2: table_array},${3: row_index_num}${4:,${5: [range_lookup]}})", + "req_param": [ + "lookup_value", + "table_array", + "row_index_num" + ], + "opt_param": [ + "range_lookup" + ], "ellipsis": false }, { @@ -1677,6 +2926,10 @@ "func_desc": "Converts a serial number to an hour.", "is_nullary": false, "comp_str": "HOUR(${1:serial_number})", + "req_param": [ + "serial_number" + ], + "opt_param": [], "ellipsis": false }, { @@ -1685,6 +2938,12 @@ "func_desc": "Horizontally combine arrays into one array.", "is_nullary": false, "comp_str": "HSTACK(${1:array1}${2:,${3: [array2], ...}})", + "req_param": [ + "array1" + ], + "opt_param": [ + "array2" + ], "ellipsis": true }, { @@ -1693,6 +2952,12 @@ "func_desc": "Creates a shortcut or jump that opens a document stored on a network server, an intranet, or the Internet.", "is_nullary": false, "comp_str": "HYPERLINK(${1:link_location}${2:,${3: [friendly_name]}})", + "req_param": [ + "link_location" + ], + "opt_param": [ + "friendly_name" + ], "ellipsis": false }, { @@ -1701,6 +2966,14 @@ "func_desc": "Returns the hypergeometric distribution.", "is_nullary": false, "comp_str": "HYPGEOM.DIST(${1:sample_s},${2: number_sample},${3: population_s},${4: number_pop},${5: cumulative})", + "req_param": [ + "sample_s", + "number_sample", + "population_s", + "number_pop", + "cumulative" + ], + "opt_param": [], "ellipsis": false }, { @@ -1709,6 +2982,13 @@ "func_desc": "Returns the hypergeometric. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "HYPGEOMDIST(${1:sample_s},${2: number_sample},${3: population_s},${4: number_pop})", + "req_param": [ + "sample_s", + "number_sample", + "population_s", + "number_pop" + ], + "opt_param": [], "ellipsis": false }, { @@ -1717,6 +2997,13 @@ "func_desc": "Specifies a logical test to perform.", "is_nullary": false, "comp_str": "IF(${1:logical_test}${2:,${3: [value_if_true]},${4: [value_if_false]}})", + "req_param": [ + "logical_test" + ], + "opt_param": [ + "value_if_true", + "value_if_false" + ], "ellipsis": false }, { @@ -1725,6 +3012,11 @@ "func_desc": "Returns a value you specify if a formula evaluates to an error.", "is_nullary": false, "comp_str": "IFERROR(${1:value},${2: value_if_error})", + "req_param": [ + "value", + "value_if_error" + ], + "opt_param": [], "ellipsis": false }, { @@ -1733,6 +3025,11 @@ "func_desc": "Returns the value you specify if the expression resolves to #N/A, otherwise. Returns the result of the expression.", "is_nullary": false, "comp_str": "IFNA(${1:value},${2: value_if_na})", + "req_param": [ + "value", + "value_if_na" + ], + "opt_param": [], "ellipsis": false }, { @@ -1741,6 +3038,14 @@ "func_desc": "Checks whether one or more conditions are met and returns a value that corresponds to the first TRUE condition. This function isn't available in Excel 2016 for Mac.", "is_nullary": false, "comp_str": "IFS(${1:logical_test1},${2: value_if_true1}${3:,${4: [logical_test2]},${5: [value_if_true2], ...}})", + "req_param": [ + "logical_test1", + "value_if_true1" + ], + "opt_param": [ + "logical_test2", + "value_if_true2" + ], "ellipsis": true }, { @@ -1749,6 +3054,10 @@ "func_desc": "Returns the absolute value (modulus) of a complex number.", "is_nullary": false, "comp_str": "IMABS(${1:inumber})", + "req_param": [ + "inumber" + ], + "opt_param": [], "ellipsis": false }, { @@ -1757,6 +3066,15 @@ "func_desc": "Returns an image from a given source.", "is_nullary": false, "comp_str": "IMAGE(${1:source}${2:,${3: [alt_text]},${4: [sizing]},${5: [height]},${6: [width]}})", + "req_param": [ + "source" + ], + "opt_param": [ + "alt_text", + "sizing", + "height", + "width" + ], "ellipsis": false }, { @@ -1765,6 +3083,10 @@ "func_desc": "Returns the imaginary coefficient of a complex number.", "is_nullary": false, "comp_str": "IMAGINARY(${1:inumber})", + "req_param": [ + "inumber" + ], + "opt_param": [], "ellipsis": false }, { @@ -1773,6 +3095,10 @@ "func_desc": "Returns the argument theta, an angle expressed in radians.", "is_nullary": false, "comp_str": "IMARGUMENT(${1:inumber})", + "req_param": [ + "inumber" + ], + "opt_param": [], "ellipsis": false }, { @@ -1781,6 +3107,10 @@ "func_desc": "Returns the complex conjugate of a complex number.", "is_nullary": false, "comp_str": "IMCONJUGATE(${1:inumber})", + "req_param": [ + "inumber" + ], + "opt_param": [], "ellipsis": false }, { @@ -1789,6 +3119,10 @@ "func_desc": "Returns the cosine of a complex number.", "is_nullary": false, "comp_str": "IMCOS(${1:inumber})", + "req_param": [ + "inumber" + ], + "opt_param": [], "ellipsis": false }, { @@ -1797,6 +3131,10 @@ "func_desc": "Returns the hyperbolic cosine of a complex number.", "is_nullary": false, "comp_str": "IMCOSH(${1:inumber})", + "req_param": [ + "inumber" + ], + "opt_param": [], "ellipsis": false }, { @@ -1805,6 +3143,10 @@ "func_desc": "Returns the cotangent of a complex number.", "is_nullary": false, "comp_str": "IMCOT(${1:inumber})", + "req_param": [ + "inumber" + ], + "opt_param": [], "ellipsis": false }, { @@ -1813,6 +3155,10 @@ "func_desc": "Returns the cosecant of a complex number.", "is_nullary": false, "comp_str": "IMCSC(${1:inumber})", + "req_param": [ + "inumber" + ], + "opt_param": [], "ellipsis": false }, { @@ -1821,6 +3167,10 @@ "func_desc": "Returns the hyperbolic cosecant of a complex number.", "is_nullary": false, "comp_str": "IMCSCH(${1:inumber})", + "req_param": [ + "inumber" + ], + "opt_param": [], "ellipsis": false }, { @@ -1829,6 +3179,11 @@ "func_desc": "Returns the quotient of two complex numbers.", "is_nullary": false, "comp_str": "IMDIV(${1:inumber1},${2: inumber2})", + "req_param": [ + "inumber1", + "inumber2" + ], + "opt_param": [], "ellipsis": false }, { @@ -1837,6 +3192,10 @@ "func_desc": "Returns the exponential of a complex number.", "is_nullary": false, "comp_str": "IMEXP(${1:inumber})", + "req_param": [ + "inumber" + ], + "opt_param": [], "ellipsis": false }, { @@ -1845,6 +3204,10 @@ "func_desc": "Returns the natural logarithm of a complex number.", "is_nullary": false, "comp_str": "IMLN(${1:inumber})", + "req_param": [ + "inumber" + ], + "opt_param": [], "ellipsis": false }, { @@ -1853,6 +3216,10 @@ "func_desc": "Returns the base-10 logarithm of a complex number.", "is_nullary": false, "comp_str": "IMLOG10(${1:inumber})", + "req_param": [ + "inumber" + ], + "opt_param": [], "ellipsis": false }, { @@ -1861,6 +3228,10 @@ "func_desc": "Returns the base-2 logarithm of a complex number.", "is_nullary": false, "comp_str": "IMLOG2(${1:inumber})", + "req_param": [ + "inumber" + ], + "opt_param": [], "ellipsis": false }, { @@ -1869,6 +3240,11 @@ "func_desc": "Returns a complex number raised to an integer power.", "is_nullary": false, "comp_str": "IMPOWER(${1:inumber},${2: number})", + "req_param": [ + "inumber", + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -1877,6 +3253,12 @@ "func_desc": "Returns the product of complex numbers.", "is_nullary": false, "comp_str": "IMPRODUCT(${1:inumber1}${2:,${3: [inumber2], ...}})", + "req_param": [ + "inumber1" + ], + "opt_param": [ + "inumber2" + ], "ellipsis": true }, { @@ -1885,6 +3267,10 @@ "func_desc": "Returns the real coefficient of a complex number.", "is_nullary": false, "comp_str": "IMREAL(${1:inumber})", + "req_param": [ + "inumber" + ], + "opt_param": [], "ellipsis": false }, { @@ -1893,6 +3279,10 @@ "func_desc": "Returns the secant of a complex number.", "is_nullary": false, "comp_str": "IMSEC(${1:inumber})", + "req_param": [ + "inumber" + ], + "opt_param": [], "ellipsis": false }, { @@ -1901,6 +3291,10 @@ "func_desc": "Returns the hyperbolic secant of a complex number.", "is_nullary": false, "comp_str": "IMSECH(${1:inumber})", + "req_param": [ + "inumber" + ], + "opt_param": [], "ellipsis": false }, { @@ -1909,6 +3303,10 @@ "func_desc": "Returns the sine of a complex number.", "is_nullary": false, "comp_str": "IMSIN(${1:inumber})", + "req_param": [ + "inumber" + ], + "opt_param": [], "ellipsis": false }, { @@ -1917,6 +3315,10 @@ "func_desc": "Returns the hyperbolic sine of a complex number.", "is_nullary": false, "comp_str": "IMSINH(${1:inumber})", + "req_param": [ + "inumber" + ], + "opt_param": [], "ellipsis": false }, { @@ -1925,6 +3327,10 @@ "func_desc": "Returns the square root of a complex number.", "is_nullary": false, "comp_str": "IMSQRT(${1:inumber})", + "req_param": [ + "inumber" + ], + "opt_param": [], "ellipsis": false }, { @@ -1933,6 +3339,11 @@ "func_desc": "Returns the difference between two complex numbers.", "is_nullary": false, "comp_str": "IMSUB(${1:inumber1},${2: inumber2})", + "req_param": [ + "inumber1", + "inumber2" + ], + "opt_param": [], "ellipsis": false }, { @@ -1941,6 +3352,12 @@ "func_desc": "Returns the sum of complex numbers.", "is_nullary": false, "comp_str": "IMSUM(${1:inumber1}${2:,${3: [inumber2], ...}})", + "req_param": [ + "inumber1" + ], + "opt_param": [ + "inumber2" + ], "ellipsis": true }, { @@ -1949,6 +3366,10 @@ "func_desc": "Returns the tangent of a complex number.", "is_nullary": false, "comp_str": "IMTAN(${1:inumber})", + "req_param": [ + "inumber" + ], + "opt_param": [], "ellipsis": false }, { @@ -1957,6 +3378,13 @@ "func_desc": "Uses an index to choose a value from a reference or array.", "is_nullary": false, "comp_str": "INDEX(${1:array},${2: row_num}${3:,${4: [column_num]}})", + "req_param": [ + "array", + "row_num" + ], + "opt_param": [ + "column_num" + ], "ellipsis": false }, { @@ -1965,6 +3393,12 @@ "func_desc": "Returns a reference indicated by a text value.", "is_nullary": false, "comp_str": "INDIRECT(${1:ref_text}${2:,${3: [a1]}})", + "req_param": [ + "ref_text" + ], + "opt_param": [ + "a1" + ], "ellipsis": false }, { @@ -1973,6 +3407,10 @@ "func_desc": "Returns information about the current operating environment. This function is not available in Excel Online.", "is_nullary": false, "comp_str": "INFO(${1:type_text})", + "req_param": [ + "type_text" + ], + "opt_param": [], "ellipsis": false }, { @@ -1981,6 +3419,10 @@ "func_desc": "Rounds a number down to the nearest integer.", "is_nullary": false, "comp_str": "INT(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -1989,6 +3431,11 @@ "func_desc": "Returns the intercept of the linear regression line.", "is_nullary": false, "comp_str": "INTERCEPT(${1:known_ys},${2: known_xs})", + "req_param": [ + "known_ys", + "known_xs" + ], + "opt_param": [], "ellipsis": false }, { @@ -1997,6 +3444,15 @@ "func_desc": "Returns the interest rate for a fully invested security.", "is_nullary": false, "comp_str": "INTRATE(${1:settlement},${2: maturity},${3: investment},${4: redemption}${5:,${6: [basis]}})", + "req_param": [ + "settlement", + "maturity", + "investment", + "redemption" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -2005,6 +3461,16 @@ "func_desc": "Returns the interest payment for an investment for a given period.", "is_nullary": false, "comp_str": "IPMT(${1:rate},${2: per},${3: nper},${4: pv}${5:,${6: [fv]},${7: [type]}})", + "req_param": [ + "rate", + "per", + "nper", + "pv" + ], + "opt_param": [ + "fv", + "type" + ], "ellipsis": false }, { @@ -2013,6 +3479,12 @@ "func_desc": "Returns the internal rate of return for a series of cash flows.", "is_nullary": false, "comp_str": "IRR(${1:values}${2:,${3: [guess]}})", + "req_param": [ + "values" + ], + "opt_param": [ + "guess" + ], "ellipsis": false }, { @@ -2021,6 +3493,10 @@ "func_desc": "Returns TRUE if the value is blank.", "is_nullary": false, "comp_str": "ISBLANK(${1:value})", + "req_param": [ + "value" + ], + "opt_param": [], "ellipsis": false }, { @@ -2029,6 +3505,10 @@ "func_desc": "Returns TRUE if the value is any error value except #N/A.", "is_nullary": false, "comp_str": "ISERR(${1:value})", + "req_param": [ + "value" + ], + "opt_param": [], "ellipsis": false }, { @@ -2037,6 +3517,10 @@ "func_desc": "Returns TRUE if the value is any error value.", "is_nullary": false, "comp_str": "ISERROR(${1:value})", + "req_param": [ + "value" + ], + "opt_param": [], "ellipsis": false }, { @@ -2045,6 +3529,10 @@ "func_desc": "Returns TRUE if the number is even.", "is_nullary": false, "comp_str": "ISEVEN(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -2053,6 +3541,10 @@ "func_desc": "Returns TRUE if there is a reference to a cell that contains a formula.", "is_nullary": false, "comp_str": "ISFORMULA(${1:reference})", + "req_param": [ + "reference" + ], + "opt_param": [], "ellipsis": false }, { @@ -2061,6 +3553,10 @@ "func_desc": "Returns TRUE if the value is a logical value.", "is_nullary": false, "comp_str": "ISLOGICAL(${1:value})", + "req_param": [ + "value" + ], + "opt_param": [], "ellipsis": false }, { @@ -2069,6 +3565,10 @@ "func_desc": "Returns TRUE if the value is the #N/A error value.", "is_nullary": false, "comp_str": "ISNA(${1:value})", + "req_param": [ + "value" + ], + "opt_param": [], "ellipsis": false }, { @@ -2077,6 +3577,10 @@ "func_desc": "Returns TRUE if the value is not text.", "is_nullary": false, "comp_str": "ISNONTEXT(${1:value})", + "req_param": [ + "value" + ], + "opt_param": [], "ellipsis": false }, { @@ -2085,6 +3589,10 @@ "func_desc": "Returns TRUE if the value is a number.", "is_nullary": false, "comp_str": "ISNUMBER(${1:value})", + "req_param": [ + "value" + ], + "opt_param": [], "ellipsis": false }, { @@ -2093,6 +3601,12 @@ "func_desc": "Returns a number that is rounded up to the nearest integer or to the nearest multiple of significance.", "is_nullary": false, "comp_str": "ISO.CEILING(${1:number}${2:,${3: [significance]}})", + "req_param": [ + "number" + ], + "opt_param": [ + "significance" + ], "ellipsis": false }, { @@ -2101,6 +3615,10 @@ "func_desc": "Returns TRUE if the number is odd.", "is_nullary": false, "comp_str": "ISODD(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -2109,6 +3627,10 @@ "func_desc": "Checks whether the value is omitted, and returns TRUE or FALSE.", "is_nullary": false, "comp_str": "ISOMITTED(${1:argument})", + "req_param": [ + "argument" + ], + "opt_param": [], "ellipsis": false }, { @@ -2117,6 +3639,10 @@ "func_desc": "Returns the number of the ISO week number of the year for a given date.", "is_nullary": false, "comp_str": "ISOWEEKNUM(${1:date})", + "req_param": [ + "date" + ], + "opt_param": [], "ellipsis": false }, { @@ -2125,6 +3651,13 @@ "func_desc": "Calculates the interest paid during a specific period of an investment.", "is_nullary": false, "comp_str": "ISPMT(${1:rate},${2: per},${3: nper},${4: pv})", + "req_param": [ + "rate", + "per", + "nper", + "pv" + ], + "opt_param": [], "ellipsis": false }, { @@ -2133,6 +3666,10 @@ "func_desc": "Returns TRUE if the value is a reference.", "is_nullary": false, "comp_str": "ISREF(${1:value})", + "req_param": [ + "value" + ], + "opt_param": [], "ellipsis": false }, { @@ -2141,6 +3678,10 @@ "func_desc": "Returns TRUE if the value is text.", "is_nullary": false, "comp_str": "ISTEXT(${1:value})", + "req_param": [ + "value" + ], + "opt_param": [], "ellipsis": false }, { @@ -2149,6 +3690,10 @@ "func_desc": "Changes half-width characters to full-width characters.", "is_nullary": false, "comp_str": "JIS(${1:text})", + "req_param": [ + "text" + ], + "opt_param": [], "ellipsis": false }, { @@ -2157,6 +3702,12 @@ "func_desc": "Returns the kurtosis of a data set.", "is_nullary": false, "comp_str": "KURT(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -2165,6 +3716,12 @@ "func_desc": "Creates a function value, which can be called within formulas.", "is_nullary": false, "comp_str": "LAMBDA(${1:parameter_or_calculation1}${2:,${3: [parameter_or_calculation2], ...}})", + "req_param": [ + "parameter_or_calculation1" + ], + "opt_param": [ + "parameter_or_calculation2" + ], "ellipsis": true }, { @@ -2173,6 +3730,11 @@ "func_desc": "Returns the k-th largest value in a data set.", "is_nullary": false, "comp_str": "LARGE(${1:array},${2: k})", + "req_param": [ + "array", + "k" + ], + "opt_param": [], "ellipsis": false }, { @@ -2181,6 +3743,12 @@ "func_desc": "Returns the least common multiple.", "is_nullary": false, "comp_str": "LCM(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -2189,6 +3757,12 @@ "func_desc": "Extracts a specified number of characters from the start (left) of a text string.", "is_nullary": false, "comp_str": "LEFT(${1:text}${2:,${3: [num_chars]}})", + "req_param": [ + "text" + ], + "opt_param": [ + "num_chars" + ], "ellipsis": false }, { @@ -2197,6 +3771,12 @@ "func_desc": "Returns the first character or characters in a text string based on bytes.", "is_nullary": false, "comp_str": "LEFTB(${1:text}${2:,${3: [num_bytes]}})", + "req_param": [ + "text" + ], + "opt_param": [ + "num_bytes" + ], "ellipsis": false }, { @@ -2205,6 +3785,10 @@ "func_desc": "Returns the total number of characters in a text string, including spaces.", "is_nullary": false, "comp_str": "LEN(${1:text})", + "req_param": [ + "text" + ], + "opt_param": [], "ellipsis": false }, { @@ -2213,6 +3797,10 @@ "func_desc": "Returns the number of bytes used to represent a string.", "is_nullary": false, "comp_str": "LENB(${1:text})", + "req_param": [ + "text" + ], + "opt_param": [], "ellipsis": false }, { @@ -2221,6 +3809,14 @@ "func_desc": "Assigns names to calculation results to allow storing intermediate calculations, values, or defining names inside a formula", "is_nullary": false, "comp_str": "LET(${1:name1},${2: name_value1},${3: calculation_or_name2}${4:,${5: [name_value2], ...}})", + "req_param": [ + "name1", + "name_value1", + "calculation_or_name2" + ], + "opt_param": [ + "name_value2" + ], "ellipsis": true }, { @@ -2229,6 +3825,14 @@ "func_desc": "Returns the parameters of a linear trend.", "is_nullary": false, "comp_str": "LINEST(${1:known_ys}${2:,${3: [known_xs]},${4: [const]},${5: [stats]}})", + "req_param": [ + "known_ys" + ], + "opt_param": [ + "known_xs", + "const", + "stats" + ], "ellipsis": false }, { @@ -2237,6 +3841,10 @@ "func_desc": "Returns the natural logarithm of a number.", "is_nullary": false, "comp_str": "LN(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -2245,6 +3853,12 @@ "func_desc": "Returns the logarithm of a number to a specified base.", "is_nullary": false, "comp_str": "LOG(${1:number}${2:,${3: [base]}})", + "req_param": [ + "number" + ], + "opt_param": [ + "base" + ], "ellipsis": false }, { @@ -2253,6 +3867,10 @@ "func_desc": "Returns the base-10 logarithm of a number.", "is_nullary": false, "comp_str": "LOG10(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -2261,6 +3879,14 @@ "func_desc": "Returns the parameters of an exponential trend.", "is_nullary": false, "comp_str": "LOGEST(${1:known_ys}${2:,${3: [known_xs]},${4: [const]},${5: [stats]}})", + "req_param": [ + "known_ys" + ], + "opt_param": [ + "known_xs", + "const", + "stats" + ], "ellipsis": false }, { @@ -2269,6 +3895,12 @@ "func_desc": "Returns the inverse of the lognormal cumulative distribution. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "LOGINV(${1:probability},${2: mean},${3: standard_dev})", + "req_param": [ + "probability", + "mean", + "standard_dev" + ], + "opt_param": [], "ellipsis": false }, { @@ -2277,6 +3909,13 @@ "func_desc": "Returns the lognormal distribution of x, where ln(x) is normally distributed with parameters Mean and Standard_dev.", "is_nullary": false, "comp_str": "LOGNORM.DIST(${1:x},${2: mean},${3: standard_dev},${4: cumulative})", + "req_param": [ + "x", + "mean", + "standard_dev", + "cumulative" + ], + "opt_param": [], "ellipsis": false }, { @@ -2285,6 +3924,12 @@ "func_desc": "Returns the inverse of the lognormal cumulative distribution function of x, where ln(x) is normally distributed with parameters Mean and Standard_dev.", "is_nullary": false, "comp_str": "LOGNORM.INV(${1:probability},${2: mean},${3: standard_dev})", + "req_param": [ + "probability", + "mean", + "standard_dev" + ], + "opt_param": [], "ellipsis": false }, { @@ -2293,6 +3938,12 @@ "func_desc": "Returns the cumulative lognormal distribution. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "LOGNORMDIST(${1:x},${2: mean},${3: standard_dev})", + "req_param": [ + "x", + "mean", + "standard_dev" + ], + "opt_param": [], "ellipsis": false }, { @@ -2301,6 +3952,13 @@ "func_desc": "Looks up values in a vector or array.", "is_nullary": false, "comp_str": "LOOKUP(${1:lookup_value},${2: lookup_vector}${3:,${4: [result_vector]}})", + "req_param": [ + "lookup_value", + "lookup_vector" + ], + "opt_param": [ + "result_vector" + ], "ellipsis": false }, { @@ -2309,6 +3967,10 @@ "func_desc": "Converts text to lowercase.", "is_nullary": false, "comp_str": "LOWER(${1:text})", + "req_param": [ + "text" + ], + "opt_param": [], "ellipsis": false }, { @@ -2317,6 +3979,12 @@ "func_desc": "Returns a calculated array of a specified row and column size, by applying a LAMBDA function.", "is_nullary": false, "comp_str": "MAKEARRAY(${1:rows},${2: columns},${3: function})", + "req_param": [ + "rows", + "columns", + "function" + ], + "opt_param": [], "ellipsis": false }, { @@ -2325,6 +3993,13 @@ "func_desc": "Returns an array formed by 'mapping' each value in the array(s) to a new value by applying a lambda to create a new value.", "is_nullary": false, "comp_str": "MAP(${1:array},${2: lambda_or_array2}${3:,${4: [lambda_or_array3], ...}})", + "req_param": [ + "array", + "lambda_or_array2" + ], + "opt_param": [ + "lambda_or_array3" + ], "ellipsis": true }, { @@ -2333,6 +4008,13 @@ "func_desc": "Looks up values in a reference or array.", "is_nullary": false, "comp_str": "MATCH(${1:lookup_value},${2: lookup_array}${3:,${4: [match_type]}})", + "req_param": [ + "lookup_value", + "lookup_array" + ], + "opt_param": [ + "match_type" + ], "ellipsis": false }, { @@ -2341,6 +4023,12 @@ "func_desc": "Returns the maximum value in a list of arguments.", "is_nullary": false, "comp_str": "MAX(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -2349,6 +4037,12 @@ "func_desc": "Returns the maximum value in a list of arguments, including numbers, text, and logical values.", "is_nullary": false, "comp_str": "MAXA(${1:value1}${2:,${3: [value2], ...}})", + "req_param": [ + "value1" + ], + "opt_param": [ + "value2" + ], "ellipsis": true }, { @@ -2357,6 +4051,15 @@ "func_desc": "Returns the maximum value among cells specified by a given set of conditions or criteria. This function isn't available in Excel 2016 for Mac.", "is_nullary": false, "comp_str": "MAXIFS(${1:max_range},${2: criteria_range1},${3: criteria1}${4:,${5: [criteria_range2]},${6: [criteria2], ...}})", + "req_param": [ + "max_range", + "criteria_range1", + "criteria1" + ], + "opt_param": [ + "criteria_range2", + "criteria2" + ], "ellipsis": true }, { @@ -2365,6 +4068,10 @@ "func_desc": "Returns the matrix determinant of an array.", "is_nullary": false, "comp_str": "MDETERM(${1:array})", + "req_param": [ + "array" + ], + "opt_param": [], "ellipsis": false }, { @@ -2373,6 +4080,16 @@ "func_desc": "Returns the Macauley modified duration for a security with an assumed par value of $100.", "is_nullary": false, "comp_str": "MDURATION(${1:settlement},${2: maturity},${3: coupon},${4: yld},${5: frequency}${6:,${7: [basis]}})", + "req_param": [ + "settlement", + "maturity", + "coupon", + "yld", + "frequency" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -2381,6 +4098,12 @@ "func_desc": "Returns the median of the given numbers.", "is_nullary": false, "comp_str": "MEDIAN(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -2389,6 +4112,12 @@ "func_desc": "Extracts a substring from a text string, starting at a specified position for a given length.", "is_nullary": false, "comp_str": "MID(${1:text},${2: start_num},${3: num_chars})", + "req_param": [ + "text", + "start_num", + "num_chars" + ], + "opt_param": [], "ellipsis": false }, { @@ -2397,6 +4126,12 @@ "func_desc": "Returns a specific number of bytes from a text string, starting at a specified position.", "is_nullary": false, "comp_str": "MIDB(${1:text},${2: start_num},${3: num_bytes})", + "req_param": [ + "text", + "start_num", + "num_bytes" + ], + "opt_param": [], "ellipsis": false }, { @@ -2405,6 +4140,12 @@ "func_desc": "Returns the minimum value in a list of arguments.", "is_nullary": false, "comp_str": "MIN(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -2413,6 +4154,12 @@ "func_desc": "Returns the smallest value in a list of arguments, including numbers, text, and logical values.", "is_nullary": false, "comp_str": "MINA(${1:value1}${2:,${3: [value2], ...}})", + "req_param": [ + "value1" + ], + "opt_param": [ + "value2" + ], "ellipsis": true }, { @@ -2421,6 +4168,15 @@ "func_desc": "Returns the minimum value among cells specified by a given set of conditions or criteria. This function isn't available in Excel 2016 for Mac.", "is_nullary": false, "comp_str": "MINIFS(${1:min_range},${2: criteria_range1},${3: criteria1}${4:,${5: [criteria_range2]},${6: [criteria2], ...}})", + "req_param": [ + "min_range", + "criteria_range1", + "criteria1" + ], + "opt_param": [ + "criteria_range2", + "criteria2" + ], "ellipsis": true }, { @@ -2429,6 +4185,10 @@ "func_desc": "Converts a serial number to a minute.", "is_nullary": false, "comp_str": "MINUTE(${1:serial_number})", + "req_param": [ + "serial_number" + ], + "opt_param": [], "ellipsis": false }, { @@ -2437,6 +4197,10 @@ "func_desc": "Returns the matrix inverse of an array.", "is_nullary": false, "comp_str": "MINVERSE(${1:array})", + "req_param": [ + "array" + ], + "opt_param": [], "ellipsis": false }, { @@ -2445,6 +4209,12 @@ "func_desc": "Returns the internal rate of return where positive and negative cash flows are financed at different rates.", "is_nullary": false, "comp_str": "MIRR(${1:values},${2: finance_rate},${3: reinvest_rate})", + "req_param": [ + "values", + "finance_rate", + "reinvest_rate" + ], + "opt_param": [], "ellipsis": false }, { @@ -2453,6 +4223,11 @@ "func_desc": "Returns the matrix product of two arrays.", "is_nullary": false, "comp_str": "MMULT(${1:array1},${2: array2})", + "req_param": [ + "array1", + "array2" + ], + "opt_param": [], "ellipsis": false }, { @@ -2461,6 +4236,11 @@ "func_desc": "Returns the remainder from division.", "is_nullary": false, "comp_str": "MOD(${1:number},${2: divisor})", + "req_param": [ + "number", + "divisor" + ], + "opt_param": [], "ellipsis": false }, { @@ -2469,6 +4249,12 @@ "func_desc": "Returns the most common value in a data set. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "MODE(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -2477,6 +4263,12 @@ "func_desc": "Returns a vertical array of the most frequently occurring, or repetitive values in an array or range of data.", "is_nullary": false, "comp_str": "MODE.MULT(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -2485,6 +4277,12 @@ "func_desc": "Returns the most common value in a data set.", "is_nullary": false, "comp_str": "MODE.SNGL(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -2493,6 +4291,10 @@ "func_desc": "Converts a serial number to a month.", "is_nullary": false, "comp_str": "MONTH(${1:serial_number})", + "req_param": [ + "serial_number" + ], + "opt_param": [], "ellipsis": false }, { @@ -2501,6 +4303,11 @@ "func_desc": "Returns a number rounded to the desired multiple.", "is_nullary": false, "comp_str": "MROUND(${1:number},${2: multiple})", + "req_param": [ + "number", + "multiple" + ], + "opt_param": [], "ellipsis": false }, { @@ -2509,6 +4316,12 @@ "func_desc": "Returns the multinomial of a set of numbers.", "is_nullary": false, "comp_str": "MULTINOMIAL(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -2517,6 +4330,10 @@ "func_desc": "Returns the unit matrix or the specified dimension.", "is_nullary": false, "comp_str": "MUNIT(${1:dimension})", + "req_param": [ + "dimension" + ], + "opt_param": [], "ellipsis": false }, { @@ -2525,6 +4342,10 @@ "func_desc": "Returns a value converted to a number.", "is_nullary": false, "comp_str": "N(${1:value})", + "req_param": [ + "value" + ], + "opt_param": [], "ellipsis": false }, { @@ -2532,7 +4353,8 @@ "func_cat": "Information", "func_desc": "Returns the error value #N/A.", "is_nullary": true, - "comp_str": "=NA()" + "comp_str": "NA()", + "ellipsis": false }, { "func_name": "NEGBINOM.DIST", @@ -2540,6 +4362,13 @@ "func_desc": "Returns the negative binomial distribution.", "is_nullary": false, "comp_str": "NEGBINOM.DIST(${1:number_f},${2: number_s},${3: probability_s},${4: cumulative})", + "req_param": [ + "number_f", + "number_s", + "probability_s", + "cumulative" + ], + "opt_param": [], "ellipsis": false }, { @@ -2548,6 +4377,12 @@ "func_desc": "Returns the negative binomial. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "NEGBINOMDIST(${1:number_f},${2: number_s},${3: probability_s})", + "req_param": [ + "number_f", + "number_s", + "probability_s" + ], + "opt_param": [], "ellipsis": false }, { @@ -2556,6 +4391,13 @@ "func_desc": "Returns the number of whole workdays between two dates.", "is_nullary": false, "comp_str": "NETWORKDAYS(${1:start_date},${2: end_date}${3:,${4: [holidays]}})", + "req_param": [ + "start_date", + "end_date" + ], + "opt_param": [ + "holidays" + ], "ellipsis": false }, { @@ -2564,6 +4406,14 @@ "func_desc": "Returns the number of whole workdays between two dates using parameters to indicate which and how many days are weekend days.", "is_nullary": false, "comp_str": "NETWORKDAYS.INTL(${1:start_date},${2: end_date}${3:,${4: [weekend]},${5: [holidays]}})", + "req_param": [ + "start_date", + "end_date" + ], + "opt_param": [ + "weekend", + "holidays" + ], "ellipsis": false }, { @@ -2572,6 +4422,11 @@ "func_desc": "Returns the annual nominal interest rate.", "is_nullary": false, "comp_str": "NOMINAL(${1:effect_rate},${2: npery})", + "req_param": [ + "effect_rate", + "npery" + ], + "opt_param": [], "ellipsis": false }, { @@ -2580,6 +4435,13 @@ "func_desc": "Returns the normal cumulative distribution.", "is_nullary": false, "comp_str": "NORM.DIST(${1:x},${2: mean},${3: standard_dev},${4: cumulative})", + "req_param": [ + "x", + "mean", + "standard_dev", + "cumulative" + ], + "opt_param": [], "ellipsis": false }, { @@ -2588,6 +4450,12 @@ "func_desc": "Returns the inverse of the normal cumulative. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "NORM.INV(${1:probability},${2: mean},${3: standard_dev})", + "req_param": [ + "probability", + "mean", + "standard_dev" + ], + "opt_param": [], "ellipsis": false }, { @@ -2596,6 +4464,11 @@ "func_desc": "Returns the standard normal cumulative distribution.", "is_nullary": false, "comp_str": "NORM.S.DIST(${1:z},${2: cumulative})", + "req_param": [ + "z", + "cumulative" + ], + "opt_param": [], "ellipsis": false }, { @@ -2604,6 +4477,10 @@ "func_desc": "Returns the inverse of the standard normal cumulative distribution.", "is_nullary": false, "comp_str": "NORM.S.INV(${1:probability})", + "req_param": [ + "probability" + ], + "opt_param": [], "ellipsis": false }, { @@ -2612,6 +4489,13 @@ "func_desc": "Returns the normal cumulative. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "NORMDIST(${1:x},${2: mean},${3: standard_dev},${4: cumulative})", + "req_param": [ + "x", + "mean", + "standard_dev", + "cumulative" + ], + "opt_param": [], "ellipsis": false }, { @@ -2620,6 +4504,12 @@ "func_desc": "Returns the inverse of the normal cumulative distribution.", "is_nullary": false, "comp_str": "NORMINV(${1:probability},${2: mean},${3: standard_dev})", + "req_param": [ + "probability", + "mean", + "standard_dev" + ], + "opt_param": [], "ellipsis": false }, { @@ -2628,6 +4518,10 @@ "func_desc": "Returns the standard normal cumulative. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "NORMSDIST(${1:z})", + "req_param": [ + "z" + ], + "opt_param": [], "ellipsis": false }, { @@ -2636,6 +4530,10 @@ "func_desc": "Returns the inverse of the standard normal cumulative. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "NORMSINV(${1:probability})", + "req_param": [ + "probability" + ], + "opt_param": [], "ellipsis": false }, { @@ -2644,6 +4542,10 @@ "func_desc": "Reverses the logic of its argument.", "is_nullary": false, "comp_str": "NOT(${1:logical})", + "req_param": [ + "logical" + ], + "opt_param": [], "ellipsis": false }, { @@ -2651,7 +4553,8 @@ "func_cat": "Date and time", "func_desc": "Returns the serial number of the current date and time.", "is_nullary": true, - "comp_str": "=NOW()" + "comp_str": "NOW()", + "ellipsis": false }, { "func_name": "NPER", @@ -2659,6 +4562,15 @@ "func_desc": "Returns the number of periods for an investment.", "is_nullary": false, "comp_str": "NPER(${1:rate},${2: pmt},${3: pv}${4:,${5: [fv]},${6: [type]}})", + "req_param": [ + "rate", + "pmt", + "pv" + ], + "opt_param": [ + "fv", + "type" + ], "ellipsis": false }, { @@ -2667,6 +4579,13 @@ "func_desc": "Returns the net present value of an investment based on a series of periodic cash flows and a discount rate.", "is_nullary": false, "comp_str": "NPV(${1:rate},${2: value1}${3:,${4: [value2], ...}})", + "req_param": [ + "rate", + "value1" + ], + "opt_param": [ + "value2" + ], "ellipsis": true }, { @@ -2675,6 +4594,13 @@ "func_desc": "Converts text to number in a locale-independent manner.", "is_nullary": false, "comp_str": "NUMBERVALUE(${1:text}${2:,${3: [decimal_separator]},${4: [group_separator]}})", + "req_param": [ + "text" + ], + "opt_param": [ + "decimal_separator", + "group_separator" + ], "ellipsis": false }, { @@ -2683,6 +4609,12 @@ "func_desc": "Converts an octal number to binary.", "is_nullary": false, "comp_str": "OCT2BIN(${1:number}${2:,${3: [places]}})", + "req_param": [ + "number" + ], + "opt_param": [ + "places" + ], "ellipsis": false }, { @@ -2691,6 +4623,10 @@ "func_desc": "Converts an octal number to decimal.", "is_nullary": false, "comp_str": "OCT2DEC(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -2699,6 +4635,12 @@ "func_desc": "Converts an octal number to hexadecimal.", "is_nullary": false, "comp_str": "OCT2HEX(${1:number}${2:,${3: [places]}})", + "req_param": [ + "number" + ], + "opt_param": [ + "places" + ], "ellipsis": false }, { @@ -2707,6 +4649,10 @@ "func_desc": "Rounds a number up to the nearest odd integer.", "is_nullary": false, "comp_str": "ODD(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -2715,6 +4661,19 @@ "func_desc": "Returns the price per $100 face value of a security with an odd first period.", "is_nullary": false, "comp_str": "ODDFPRICE(${1:settlement},${2: maturity},${3: issue},${4: first_coupon},${5: rate},${6: yld},${7: redemption},${8: frequency}${9:,${10: [basis]}})", + "req_param": [ + "settlement", + "maturity", + "issue", + "first_coupon", + "rate", + "yld", + "redemption", + "frequency" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -2723,6 +4682,19 @@ "func_desc": "Returns the yield of a security with an odd first period.", "is_nullary": false, "comp_str": "ODDFYIELD(${1:settlement},${2: maturity},${3: issue},${4: first_coupon},${5: rate},${6: pr},${7: redemption},${8: frequency}${9:,${10: [basis]}})", + "req_param": [ + "settlement", + "maturity", + "issue", + "first_coupon", + "rate", + "pr", + "redemption", + "frequency" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -2731,6 +4703,18 @@ "func_desc": "Returns the price per $100 face value of a security with an odd last period.", "is_nullary": false, "comp_str": "ODDLPRICE(${1:settlement},${2: maturity},${3: last_interest},${4: rate},${5: yld},${6: redemption},${7: frequency}${8:,${9: [basis]}})", + "req_param": [ + "settlement", + "maturity", + "last_interest", + "rate", + "yld", + "redemption", + "frequency" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -2739,6 +4723,18 @@ "func_desc": "Returns the yield of a security with an odd last period.", "is_nullary": false, "comp_str": "ODDLYIELD(${1:settlement},${2: maturity},${3: last_interest},${4: rate},${5: pr},${6: redemption},${7: frequency}${8:,${9: [basis]}})", + "req_param": [ + "settlement", + "maturity", + "last_interest", + "rate", + "pr", + "redemption", + "frequency" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -2747,6 +4743,15 @@ "func_desc": "Returns a reference offset from a given reference.", "is_nullary": false, "comp_str": "OFFSET(${1:reference},${2: rows},${3: cols}${4:,${5: [height]},${6: [width]}})", + "req_param": [ + "reference", + "rows", + "cols" + ], + "opt_param": [ + "height", + "width" + ], "ellipsis": false }, { @@ -2755,6 +4760,12 @@ "func_desc": "Returns TRUE if any argument is TRUE.", "is_nullary": false, "comp_str": "OR(${1:logical1}${2:,${3: [logical2], ...}})", + "req_param": [ + "logical1" + ], + "opt_param": [ + "logical2" + ], "ellipsis": true }, { @@ -2763,6 +4774,12 @@ "func_desc": "Returns the number of periods required by an investment to reach a specified value.", "is_nullary": false, "comp_str": "PDURATION(${1:rate},${2: py},${3: fv})", + "req_param": [ + "rate", + "py", + "fv" + ], + "opt_param": [], "ellipsis": false }, { @@ -2771,6 +4788,11 @@ "func_desc": "Returns the Pearson product moment correlation coefficient.", "is_nullary": false, "comp_str": "PEARSON(${1:array1},${2: array2})", + "req_param": [ + "array1", + "array2" + ], + "opt_param": [], "ellipsis": false }, { @@ -2779,6 +4801,11 @@ "func_desc": "Returns the k-th percentile of values in a range. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "PERCENTILE(${1:array},${2: k})", + "req_param": [ + "array", + "k" + ], + "opt_param": [], "ellipsis": false }, { @@ -2787,6 +4814,11 @@ "func_desc": "Returns the k-th percentile of values in a range, where k is in the range 0..1, exclusive.", "is_nullary": false, "comp_str": "PERCENTILE.EXC(${1:array},${2: k})", + "req_param": [ + "array", + "k" + ], + "opt_param": [], "ellipsis": false }, { @@ -2795,6 +4827,11 @@ "func_desc": "Returns the k-th percentile of values in a range.", "is_nullary": false, "comp_str": "PERCENTILE.INC(${1:array},${2: k})", + "req_param": [ + "array", + "k" + ], + "opt_param": [], "ellipsis": false }, { @@ -2803,6 +4840,13 @@ "func_desc": "Returns the percentage rank of a value in a data set. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "PERCENTRANK(${1:array},${2: x}${3:,${4: [significance]}})", + "req_param": [ + "array", + "x" + ], + "opt_param": [ + "significance" + ], "ellipsis": false }, { @@ -2811,6 +4855,13 @@ "func_desc": "Returns the rank of a value in a data set as a percentage (0..1, exclusive) of the data set.", "is_nullary": false, "comp_str": "PERCENTRANK.EXC(${1:array},${2: x}${3:,${4: [significance]}})", + "req_param": [ + "array", + "x" + ], + "opt_param": [ + "significance" + ], "ellipsis": false }, { @@ -2819,6 +4870,13 @@ "func_desc": "Returns the percentage rank of a value in a data set.", "is_nullary": false, "comp_str": "PERCENTRANK.INC(${1:array},${2: x}${3:,${4: [significance]}})", + "req_param": [ + "array", + "x" + ], + "opt_param": [ + "significance" + ], "ellipsis": false }, { @@ -2827,6 +4885,11 @@ "func_desc": "Returns the number of permutations for a given number of objects.", "is_nullary": false, "comp_str": "PERMUT(${1:number},${2: number_chosen})", + "req_param": [ + "number", + "number_chosen" + ], + "opt_param": [], "ellipsis": false }, { @@ -2835,6 +4898,11 @@ "func_desc": "Returns the number of permutations for a given number of objects (with repetitions) that can be selected from the total objects.", "is_nullary": false, "comp_str": "PERMUTATIONA(${1:number},${2: number_chosen})", + "req_param": [ + "number", + "number_chosen" + ], + "opt_param": [], "ellipsis": false }, { @@ -2843,6 +4911,10 @@ "func_desc": "Returns the value of the density function for a standard normal distribution.", "is_nullary": false, "comp_str": "PHI(${1:x})", + "req_param": [ + "x" + ], + "opt_param": [], "ellipsis": false }, { @@ -2851,6 +4923,10 @@ "func_desc": "Extracts the phonetic (furigana) characters from a text string.", "is_nullary": false, "comp_str": "PHONETIC(${1:reference})", + "req_param": [ + "reference" + ], + "opt_param": [], "ellipsis": false }, { @@ -2858,7 +4934,8 @@ "func_cat": "Math and trigonometry", "func_desc": "Returns the value of pi.", "is_nullary": true, - "comp_str": "=PI()" + "comp_str": "PI()", + "ellipsis": false }, { "func_name": "PMT", @@ -2866,6 +4943,15 @@ "func_desc": "Returns the periodic payment for an annuity.", "is_nullary": false, "comp_str": "PMT(${1:rate},${2: nper},${3: pv}${4:,${5: [fv]},${6: [type]}})", + "req_param": [ + "rate", + "nper", + "pv" + ], + "opt_param": [ + "fv", + "type" + ], "ellipsis": false }, { @@ -2874,6 +4960,12 @@ "func_desc": "Returns the Poisson. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "POISSON(${1:x},${2: mean},${3: cumulative})", + "req_param": [ + "x", + "mean", + "cumulative" + ], + "opt_param": [], "ellipsis": false }, { @@ -2882,6 +4974,12 @@ "func_desc": "Returns the Poisson distribution.", "is_nullary": false, "comp_str": "POISSON.DIST(${1:x},${2: mean},${3: cumulative})", + "req_param": [ + "x", + "mean", + "cumulative" + ], + "opt_param": [], "ellipsis": false }, { @@ -2890,6 +4988,11 @@ "func_desc": "Returns the result of a number raised to a power.", "is_nullary": false, "comp_str": "POWER(${1:number},${2: power})", + "req_param": [ + "number", + "power" + ], + "opt_param": [], "ellipsis": false }, { @@ -2898,6 +5001,16 @@ "func_desc": "Returns the payment on the principal for an investment for a given period.", "is_nullary": false, "comp_str": "PPMT(${1:rate},${2: per},${3: nper},${4: pv}${5:,${6: [fv]},${7: [type]}})", + "req_param": [ + "rate", + "per", + "nper", + "pv" + ], + "opt_param": [ + "fv", + "type" + ], "ellipsis": false }, { @@ -2906,6 +5019,17 @@ "func_desc": "Returns the price per $100 face value of a security that pays periodic interest.", "is_nullary": false, "comp_str": "PRICE(${1:settlement},${2: maturity},${3: rate},${4: yld},${5: redemption},${6: frequency}${7:,${8: [basis]}})", + "req_param": [ + "settlement", + "maturity", + "rate", + "yld", + "redemption", + "frequency" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -2914,6 +5038,15 @@ "func_desc": "Returns the price per $100 face value of a discounted security.", "is_nullary": false, "comp_str": "PRICEDISC(${1:settlement},${2: maturity},${3: discount},${4: redemption}${5:,${6: [basis]}})", + "req_param": [ + "settlement", + "maturity", + "discount", + "redemption" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -2922,6 +5055,16 @@ "func_desc": "Returns the price per $100 face value of a security that pays interest at maturity.", "is_nullary": false, "comp_str": "PRICEMAT(${1:settlement},${2: maturity},${3: issue},${4: rate},${5: yld}${6:,${7: [basis]}})", + "req_param": [ + "settlement", + "maturity", + "issue", + "rate", + "yld" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -2930,6 +5073,14 @@ "func_desc": "Returns the probability that values in a range are between two limits.", "is_nullary": false, "comp_str": "PROB(${1:x_range},${2: prob_range},${3: lower_limit}${4:,${5: [upper_limit]}})", + "req_param": [ + "x_range", + "prob_range", + "lower_limit" + ], + "opt_param": [ + "upper_limit" + ], "ellipsis": false }, { @@ -2938,6 +5089,12 @@ "func_desc": "Multiplies its arguments.", "is_nullary": false, "comp_str": "PRODUCT(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -2946,6 +5103,10 @@ "func_desc": "Capitalizes the first letter in each word of a text value.", "is_nullary": false, "comp_str": "PROPER(${1:text})", + "req_param": [ + "text" + ], + "opt_param": [], "ellipsis": false }, { @@ -2954,6 +5115,15 @@ "func_desc": "Returns the present value of an investment.", "is_nullary": false, "comp_str": "PV(${1:rate},${2: nper},${3: pmt}${4:,${5: [fv]},${6: [typel]}})", + "req_param": [ + "rate", + "nper", + "pmt" + ], + "opt_param": [ + "fv", + "typel" + ], "ellipsis": false }, { @@ -2962,6 +5132,11 @@ "func_desc": "Returns the quartile of a data set. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "QUARTILE(${1:array},${2: quart})", + "req_param": [ + "array", + "quart" + ], + "opt_param": [], "ellipsis": false }, { @@ -2970,6 +5145,11 @@ "func_desc": "Returns the quartile of the data set, based on percentile values from 0..1, exclusive.", "is_nullary": false, "comp_str": "QUARTILE.EXC(${1:array},${2: quart})", + "req_param": [ + "array", + "quart" + ], + "opt_param": [], "ellipsis": false }, { @@ -2978,6 +5158,11 @@ "func_desc": "Returns the quartile of a data set.", "is_nullary": false, "comp_str": "QUARTILE.INC(${1:array},${2: quart})", + "req_param": [ + "array", + "quart" + ], + "opt_param": [], "ellipsis": false }, { @@ -2986,6 +5171,11 @@ "func_desc": "Returns the integer portion of a division.", "is_nullary": false, "comp_str": "QUOTIENT(${1:numerator},${2: denominator})", + "req_param": [ + "numerator", + "denominator" + ], + "opt_param": [], "ellipsis": false }, { @@ -2994,6 +5184,10 @@ "func_desc": "Converts degrees to radians.", "is_nullary": false, "comp_str": "RADIANS(${1:angle})", + "req_param": [ + "angle" + ], + "opt_param": [], "ellipsis": false }, { @@ -3001,7 +5195,8 @@ "func_cat": "Math and trigonometry", "func_desc": "Returns a random number between 0 and 1.", "is_nullary": true, - "comp_str": "=RAND()" + "comp_str": "RAND()", + "ellipsis": false }, { "func_name": "RANDARRAY", @@ -3009,6 +5204,14 @@ "func_desc": "Returns an array of random numbers between 0 and 1. However, you can specify the number of rows and columns to fill, minimum and maximum values, and whether to return whole numbers or decimal values.", "is_nullary": false, "comp_str": "RANDARRAY(${1:,${2: [rows]},${3: [columns]},${4: [min]},${5: [max]},${6: [integer]}})", + "req_param": [], + "opt_param": [ + "rows", + "columns", + "min", + "max", + "integer" + ], "ellipsis": false }, { @@ -3017,6 +5220,11 @@ "func_desc": "Returns a random number between the numbers you specify.", "is_nullary": false, "comp_str": "RANDBETWEEN(${1:bottom},${2: top})", + "req_param": [ + "bottom", + "top" + ], + "opt_param": [], "ellipsis": false }, { @@ -3025,6 +5233,13 @@ "func_desc": "Returns the rank of a number in a list of numbers. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "RANK(${1:number},${2: ref}${3:,${4: [order]}})", + "req_param": [ + "number", + "ref" + ], + "opt_param": [ + "order" + ], "ellipsis": false }, { @@ -3033,6 +5248,13 @@ "func_desc": "Returns the rank of a number in a list of numbers. Ties take the average rank.", "is_nullary": false, "comp_str": "RANK.AVG(${1:number},${2: ref}${3:,${4: [order]}})", + "req_param": [ + "number", + "ref" + ], + "opt_param": [ + "order" + ], "ellipsis": false }, { @@ -3041,6 +5263,13 @@ "func_desc": "Returns the rank of a number in a list of numbers. Ties take the top rank.", "is_nullary": false, "comp_str": "RANK.EQ(${1:number},${2: ref}${3:,${4: [order]}})", + "req_param": [ + "number", + "ref" + ], + "opt_param": [ + "order" + ], "ellipsis": false }, { @@ -3049,6 +5278,16 @@ "func_desc": "Returns the interest rate per period of an annuity.", "is_nullary": false, "comp_str": "RATE(${1:nper},${2: pmt},${3: pv}${4:,${5: [fv]},${6: [type]},${7: [guess]}})", + "req_param": [ + "nper", + "pmt", + "pv" + ], + "opt_param": [ + "fv", + "type", + "guess" + ], "ellipsis": false }, { @@ -3057,6 +5296,15 @@ "func_desc": "Returns the amount received at maturity for a fully invested security.", "is_nullary": false, "comp_str": "RECEIVED(${1:settlement},${2: maturity},${3: investment},${4: discount}${5:,${6: [basis]}})", + "req_param": [ + "settlement", + "maturity", + "investment", + "discount" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -3065,6 +5313,12 @@ "func_desc": "Reduces an array to an accumulated value by applying a LAMBDA function to each value and returning the total value in the accumulator.", "is_nullary": false, "comp_str": "REDUCE(${1:initial_value},${2: array},${3: function})", + "req_param": [ + "initial_value", + "array", + "function" + ], + "opt_param": [], "ellipsis": false }, { @@ -3073,6 +5327,14 @@ "func_desc": "Returns a reference to the spcified DLL or code resource.", "is_nullary": false, "comp_str": "REGISTER(${1:module_text},${2: procedure},${3: type_text}${4:,${5: [argument1], ...}})", + "req_param": [ + "module_text", + "procedure", + "type_text" + ], + "opt_param": [ + "argument1" + ], "ellipsis": true }, { @@ -3081,6 +5343,13 @@ "func_desc": "Returns the register ID of the specified DLL or code resource.", "is_nullary": false, "comp_str": "REGISTER.ID(${1:module_text},${2: procedure}${3:,${4: [type_text]}})", + "req_param": [ + "module_text", + "procedure" + ], + "opt_param": [ + "type_text" + ], "ellipsis": false }, { @@ -3089,6 +5358,13 @@ "func_desc": "Replaces part of a text string with another string, based on a given start position and length.", "is_nullary": false, "comp_str": "REPLACE(${1:old_text},${2: start_num},${3: num_chars},${4: new_text})", + "req_param": [ + "old_text", + "start_num", + "num_chars", + "new_text" + ], + "opt_param": [], "ellipsis": false }, { @@ -3097,6 +5373,13 @@ "func_desc": "Replaces a specified number of bytes in a text string with another text string.", "is_nullary": false, "comp_str": "REPLACEB(${1:old_text},${2: start_num},${3: num_bytes},${4: new_text})", + "req_param": [ + "old_text", + "start_num", + "num_bytes", + "new_text" + ], + "opt_param": [], "ellipsis": false }, { @@ -3105,6 +5388,11 @@ "func_desc": "Repeats text a given number of times.", "is_nullary": false, "comp_str": "REPT(${1:text},${2: number_times})", + "req_param": [ + "text", + "number_times" + ], + "opt_param": [], "ellipsis": false }, { @@ -3113,6 +5401,12 @@ "func_desc": "Extracts a specified number of characters from the end (right) of a text string.", "is_nullary": false, "comp_str": "RIGHT(${1:text}${2:,${3: [num_chars]}})", + "req_param": [ + "text" + ], + "opt_param": [ + "num_chars" + ], "ellipsis": false }, { @@ -3121,6 +5415,12 @@ "func_desc": "Returns the last character or characters in a text string based on bytes.", "is_nullary": false, "comp_str": "RIGHTB(${1:text}${2:,${3: [num_bytes]}})", + "req_param": [ + "text" + ], + "opt_param": [ + "num_bytes" + ], "ellipsis": false }, { @@ -3129,6 +5429,12 @@ "func_desc": "Converts an arabic numeral to roman, as text.", "is_nullary": false, "comp_str": "ROMAN(${1:number}${2:,${3: [form]}})", + "req_param": [ + "number" + ], + "opt_param": [ + "form" + ], "ellipsis": false }, { @@ -3137,6 +5443,11 @@ "func_desc": "Rounds a number to a specified number of digits.", "is_nullary": false, "comp_str": "ROUND(${1:number},${2: num_digits})", + "req_param": [ + "number", + "num_digits" + ], + "opt_param": [], "ellipsis": false }, { @@ -3145,6 +5456,11 @@ "func_desc": "Rounds a number down, toward zero.", "is_nullary": false, "comp_str": "ROUNDDOWN(${1:number},${2: num_digits})", + "req_param": [ + "number", + "num_digits" + ], + "opt_param": [], "ellipsis": false }, { @@ -3153,6 +5469,11 @@ "func_desc": "Rounds a number up, away from zero.", "is_nullary": false, "comp_str": "ROUNDUP(${1:number},${2: num_digits})", + "req_param": [ + "number", + "num_digits" + ], + "opt_param": [], "ellipsis": false }, { @@ -3161,6 +5482,10 @@ "func_desc": "Returns the row number of a reference.", "is_nullary": false, "comp_str": "ROW(${1:,${2: [reference]}})", + "req_param": [], + "opt_param": [ + "reference" + ], "ellipsis": false }, { @@ -3169,6 +5494,10 @@ "func_desc": "Returns the number of rows in a reference.", "is_nullary": false, "comp_str": "ROWS(${1:array})", + "req_param": [ + "array" + ], + "opt_param": [], "ellipsis": false }, { @@ -3177,6 +5506,12 @@ "func_desc": "Returns an equivalent interest rate for the growth of an investment.", "is_nullary": false, "comp_str": "RRI(${1:nper},${2: pv},${3: fv})", + "req_param": [ + "nper", + "pv", + "fv" + ], + "opt_param": [], "ellipsis": false }, { @@ -3185,6 +5520,11 @@ "func_desc": "Returns the square of the Pearson product moment correlation coefficient.", "is_nullary": false, "comp_str": "RSQ(${1:known_ys},${2: known_xs})", + "req_param": [ + "known_ys", + "known_xs" + ], + "opt_param": [], "ellipsis": false }, { @@ -3193,6 +5533,14 @@ "func_desc": "Retrieves real-time data from a program that supports COM automation.", "is_nullary": false, "comp_str": "RTD(${1:progID},${2: server},${3: topic1}${4:,${5: [topic2], ...}})", + "req_param": [ + "progID", + "server", + "topic1" + ], + "opt_param": [ + "topic2" + ], "ellipsis": true }, { @@ -3201,6 +5549,12 @@ "func_desc": "Scans an array by applying a LAMBDA to each value and returns an array that has each intermediate value.", "is_nullary": false, "comp_str": "SCAN(${1:initial_value},${2: array},${3: function})", + "req_param": [ + "initial_value", + "array", + "function" + ], + "opt_param": [], "ellipsis": false }, { @@ -3209,6 +5563,13 @@ "func_desc": "Finds the position of a substring within a text string, case-insensitive.", "is_nullary": false, "comp_str": "SEARCH(${1:find_text},${2: within_text}${3:,${4: [start_num]}})", + "req_param": [ + "find_text", + "within_text" + ], + "opt_param": [ + "start_num" + ], "ellipsis": false }, { @@ -3217,6 +5578,13 @@ "func_desc": "Returns the position of a specified substring within a text string, counting by bytes.", "is_nullary": false, "comp_str": "SEARCHB(${1:find_text},${2: within_text}${3:,${4: [start_num]}})", + "req_param": [ + "find_text", + "within_text" + ], + "opt_param": [ + "start_num" + ], "ellipsis": false }, { @@ -3225,6 +5593,10 @@ "func_desc": "Returns the secant of an angle.", "is_nullary": false, "comp_str": "SEC(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -3233,6 +5605,10 @@ "func_desc": "Returns the hyperbolic secant of an angle.", "is_nullary": false, "comp_str": "SECH(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -3241,6 +5617,10 @@ "func_desc": "Converts a serial number to a second.", "is_nullary": false, "comp_str": "SECOND(${1:serial_number})", + "req_param": [ + "serial_number" + ], + "opt_param": [], "ellipsis": false }, { @@ -3249,6 +5629,14 @@ "func_desc": "Generates a list of sequential numbers in an array, such as 1, 2, 3, 4", "is_nullary": false, "comp_str": "SEQUENCE(${1:rows}${2:,${3: [columns]},${4: [start]},${5: [step]}})", + "req_param": [ + "rows" + ], + "opt_param": [ + "columns", + "start", + "step" + ], "ellipsis": false }, { @@ -3257,6 +5645,13 @@ "func_desc": "Returns the sum of a power series based on the formula.", "is_nullary": false, "comp_str": "SERIESSUM(${1:x},${2: n},${3: m},${4: coefficients})", + "req_param": [ + "x", + "n", + "m", + "coefficients" + ], + "opt_param": [], "ellipsis": false }, { @@ -3265,6 +5660,10 @@ "func_desc": "Returns the sheet number of the referenced sheet.", "is_nullary": false, "comp_str": "SHEET(${1:,${2: [value]}})", + "req_param": [], + "opt_param": [ + "value" + ], "ellipsis": false }, { @@ -3273,6 +5672,10 @@ "func_desc": "Returns the number of sheets in a reference.", "is_nullary": false, "comp_str": "SHEETS(${1:,${2: [reference]}})", + "req_param": [], + "opt_param": [ + "reference" + ], "ellipsis": false }, { @@ -3281,6 +5684,10 @@ "func_desc": "Returns the sign of a number.", "is_nullary": false, "comp_str": "SIGN(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -3289,6 +5696,10 @@ "func_desc": "Returns the sine of the given angle.", "is_nullary": false, "comp_str": "SIN(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -3297,6 +5708,10 @@ "func_desc": "Returns the hyperbolic sine of a number.", "is_nullary": false, "comp_str": "SINH(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -3305,6 +5720,12 @@ "func_desc": "Returns the skewness of a distribution.", "is_nullary": false, "comp_str": "SKEW(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -3313,6 +5734,12 @@ "func_desc": "Returns the skewness of a distribution based on a population.", "is_nullary": false, "comp_str": "SKEW.P(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -3321,6 +5748,12 @@ "func_desc": "Returns the straight-line depreciation of an asset for one period.", "is_nullary": false, "comp_str": "SLN(${1:cost},${2: salvage},${3: life})", + "req_param": [ + "cost", + "salvage", + "life" + ], + "opt_param": [], "ellipsis": false }, { @@ -3329,6 +5762,11 @@ "func_desc": "Returns the slope of the linear regression line.", "is_nullary": false, "comp_str": "SLOPE(${1:known_ys},${2: known_xs})", + "req_param": [ + "known_ys", + "known_xs" + ], + "opt_param": [], "ellipsis": false }, { @@ -3337,6 +5775,11 @@ "func_desc": "Returns the k-th smallest value in a data set.", "is_nullary": false, "comp_str": "SMALL(${1:array},${2: k})", + "req_param": [ + "array", + "k" + ], + "opt_param": [], "ellipsis": false }, { @@ -3345,6 +5788,14 @@ "func_desc": "Sorts the contents of a range or array", "is_nullary": false, "comp_str": "SORT(${1:array}${2:,${3: [sort_index]},${4: [sort_order]},${5: [by_col]}})", + "req_param": [ + "array" + ], + "opt_param": [ + "sort_index", + "sort_order", + "by_col" + ], "ellipsis": false }, { @@ -3353,6 +5804,13 @@ "func_desc": "Sorts the contents of a range or array based on the values in a corresponding range or array", "is_nullary": false, "comp_str": "SORTBY(${1:array},${2: by_array1}${3:,${4: [sort_order1], ...}})", + "req_param": [ + "array", + "by_array1" + ], + "opt_param": [ + "sort_order1" + ], "ellipsis": true }, { @@ -3361,6 +5819,10 @@ "func_desc": "Returns a positive square root.", "is_nullary": false, "comp_str": "SQRT(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -3369,6 +5831,10 @@ "func_desc": "Returns the square root of (number * pi).", "is_nullary": false, "comp_str": "SQRTPI(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -3377,6 +5843,12 @@ "func_desc": "Returns a normalized value.", "is_nullary": false, "comp_str": "STANDARDIZE(${1:x},${2: mean},${3: standard_dev})", + "req_param": [ + "x", + "mean", + "standard_dev" + ], + "opt_param": [], "ellipsis": false }, { @@ -3385,6 +5857,12 @@ "func_desc": "Estimates standard deviation based on a sample. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "STDEV(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -3393,6 +5871,12 @@ "func_desc": "Calculates standard deviation based on the entire population.", "is_nullary": false, "comp_str": "STDEV.P(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -3401,6 +5885,12 @@ "func_desc": "Estimates standard deviation based on a sample.", "is_nullary": false, "comp_str": "STDEV.S(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -3409,6 +5899,12 @@ "func_desc": "Estimates standard deviation based on a sample, including numbers, text, and logical values.", "is_nullary": false, "comp_str": "STDEVA(${1:value1}${2:,${3: [value2], ...}})", + "req_param": [ + "value1" + ], + "opt_param": [ + "value2" + ], "ellipsis": true }, { @@ -3417,6 +5913,12 @@ "func_desc": "Calculates standard deviation based on the entire population. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "STDEVP(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -3425,6 +5927,12 @@ "func_desc": "Calculates standard deviation based on the entire population, including numbers, text, and logical values.", "is_nullary": false, "comp_str": "STDEVPA(${1:value1}${2:,${3: [value2], ...}})", + "req_param": [ + "value1" + ], + "opt_param": [ + "value2" + ], "ellipsis": true }, { @@ -3433,6 +5941,11 @@ "func_desc": "Returns the standard error of the predicted y-value for each x in the regression.", "is_nullary": false, "comp_str": "STEYX(${1:known_ys},${2: known_xs})", + "req_param": [ + "known_ys", + "known_xs" + ], + "opt_param": [], "ellipsis": false }, { @@ -3441,6 +5954,16 @@ "func_desc": "Retrieves historical data about a financial instrument.", "is_nullary": false, "comp_str": "STOCKHISTORY(${1:stock},${2: start_date}${3:,${4: [end_date]},${5: [interval]},${6: [headers]},${7: [properties], ...}})", + "req_param": [ + "stock", + "start_date" + ], + "opt_param": [ + "end_date", + "interval", + "headers", + "properties" + ], "ellipsis": true }, { @@ -3449,6 +5972,14 @@ "func_desc": "Substitutes new text for old text in a text string.", "is_nullary": false, "comp_str": "SUBSTITUTE(${1:text},${2: old_text},${3: new_text}${4:,${5: [instance_num]}})", + "req_param": [ + "text", + "old_text", + "new_text" + ], + "opt_param": [ + "instance_num" + ], "ellipsis": false }, { @@ -3457,6 +5988,13 @@ "func_desc": "Returns a subtotal in a list or database.", "is_nullary": false, "comp_str": "SUBTOTAL(${1:function_num},${2: ref1}${3:,${4: [ref2], ...}})", + "req_param": [ + "function_num", + "ref1" + ], + "opt_param": [ + "ref2" + ], "ellipsis": true }, { @@ -3465,6 +6003,12 @@ "func_desc": "Adds its arguments.", "is_nullary": false, "comp_str": "SUM(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -3473,6 +6017,13 @@ "func_desc": "Adds the cells specified by a given criteria.", "is_nullary": false, "comp_str": "SUMIF(${1:range},${2: criteria}${3:,${4: [sum_range]}})", + "req_param": [ + "range", + "criteria" + ], + "opt_param": [ + "sum_range" + ], "ellipsis": false }, { @@ -3481,6 +6032,15 @@ "func_desc": "Adds the cells in a range that meet multiple criteria.", "is_nullary": false, "comp_str": "SUMIFS(${1:sum_range},${2: criteria_range1},${3: criteria1}${4:,${5: [criteria_range2]},${6: [criteria2], ...}})", + "req_param": [ + "sum_range", + "criteria_range1", + "criteria1" + ], + "opt_param": [ + "criteria_range2", + "criteria2" + ], "ellipsis": true }, { @@ -3489,6 +6049,13 @@ "func_desc": "Returns the sum of the products of corresponding array components.", "is_nullary": false, "comp_str": "SUMPRODUCT(${1:array1}${2:,${3: [array2]},${4: [array3], ...}})", + "req_param": [ + "array1" + ], + "opt_param": [ + "array2", + "array3" + ], "ellipsis": true }, { @@ -3497,6 +6064,12 @@ "func_desc": "Returns the sum of the squares of the arguments.", "is_nullary": false, "comp_str": "SUMSQ(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -3505,6 +6078,11 @@ "func_desc": "Returns the sum of the difference of squares of corresponding values in two arrays.", "is_nullary": false, "comp_str": "SUMX2MY2(${1:array_x},${2: array_y})", + "req_param": [ + "array_x", + "array_y" + ], + "opt_param": [], "ellipsis": false }, { @@ -3513,6 +6091,11 @@ "func_desc": "Returns the sum of the sum of squares of corresponding values in two arrays.", "is_nullary": false, "comp_str": "SUMX2PY2(${1:array_x},${2: array_y})", + "req_param": [ + "array_x", + "array_y" + ], + "opt_param": [], "ellipsis": false }, { @@ -3521,6 +6104,11 @@ "func_desc": "Returns the sum of squares of differences of corresponding values in two arrays.", "is_nullary": false, "comp_str": "SUMXMY2(${1:array_x},${2: array_y})", + "req_param": [ + "array_x", + "array_y" + ], + "opt_param": [], "ellipsis": false }, { @@ -3529,6 +6117,15 @@ "func_desc": "Evaluates an expression against a list of values and returns the result corresponding to the first matching value. If there is no match, an optional default value may be returned. This function isn't available in Excel 2016 for Mac.", "is_nullary": false, "comp_str": "SWITCH(${1:expression},${2: value1},${3: result1}${4:,${5: [default_or_value2]},${6: [result2], ...}})", + "req_param": [ + "expression", + "value1", + "result1" + ], + "opt_param": [ + "default_or_value2", + "result2" + ], "ellipsis": true }, { @@ -3537,6 +6134,13 @@ "func_desc": "Returns the sum-of-years' digits depreciation of an asset for a specified period.", "is_nullary": false, "comp_str": "SYD(${1:cost},${2: salvage},${3: life},${4: per})", + "req_param": [ + "cost", + "salvage", + "life", + "per" + ], + "opt_param": [], "ellipsis": false }, { @@ -3545,6 +6149,10 @@ "func_desc": "Converts its arguments to text.", "is_nullary": false, "comp_str": "T(${1:value})", + "req_param": [ + "value" + ], + "opt_param": [], "ellipsis": false }, { @@ -3553,6 +6161,12 @@ "func_desc": "Returns the left-tailed Student t-distribution.", "is_nullary": false, "comp_str": "T.DIST(${1:x},${2: deg_freedom},${3: cumulative})", + "req_param": [ + "x", + "deg_freedom", + "cumulative" + ], + "opt_param": [], "ellipsis": false }, { @@ -3561,6 +6175,11 @@ "func_desc": "Returns the two-tailed Student t-distribution.", "is_nullary": false, "comp_str": "T.DIST.2T(${1:x},${2: deg_freedom})", + "req_param": [ + "x", + "deg_freedom" + ], + "opt_param": [], "ellipsis": false }, { @@ -3569,6 +6188,11 @@ "func_desc": "Returns the right-tailed Student's t-distribution.", "is_nullary": false, "comp_str": "T.DIST.RT(${1:x},${2: deg_freedom})", + "req_param": [ + "x", + "deg_freedom" + ], + "opt_param": [], "ellipsis": false }, { @@ -3577,6 +6201,11 @@ "func_desc": "Returns the left-tailed inverse of the Student's t-distribution.", "is_nullary": false, "comp_str": "T.INV(${1:probability},${2: deg_freedom})", + "req_param": [ + "probability", + "deg_freedom" + ], + "opt_param": [], "ellipsis": false }, { @@ -3585,6 +6214,11 @@ "func_desc": "Returns the two-tailed inverse of the Student's t-distribution.", "is_nullary": false, "comp_str": "T.INV.2T(${1:probability},${2: deg_freedom})", + "req_param": [ + "probability", + "deg_freedom" + ], + "opt_param": [], "ellipsis": false }, { @@ -3593,6 +6227,13 @@ "func_desc": "Returns the probability associated with a Student's t-test.", "is_nullary": false, "comp_str": "T.TEST(${1:array1},${2: array2},${3: tails},${4: type})", + "req_param": [ + "array1", + "array2", + "tails", + "type" + ], + "opt_param": [], "ellipsis": false }, { @@ -3601,6 +6242,13 @@ "func_desc": "Returns rows or columns from the start or end of an array.", "is_nullary": false, "comp_str": "TAKE(${1:array},${2: rows}${3:,${4: [columns]}})", + "req_param": [ + "array", + "rows" + ], + "opt_param": [ + "columns" + ], "ellipsis": false }, { @@ -3609,6 +6257,10 @@ "func_desc": "Returns the tangent of a number.", "is_nullary": false, "comp_str": "TAN(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -3617,6 +6269,10 @@ "func_desc": "Returns the hyperbolic tangent of a number.", "is_nullary": false, "comp_str": "TANH(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -3625,6 +6281,12 @@ "func_desc": "Returns the bond-equivalent yield for a Treasury bill.", "is_nullary": false, "comp_str": "TBILLEQ(${1:settlement},${2: maturity},${3: discount})", + "req_param": [ + "settlement", + "maturity", + "discount" + ], + "opt_param": [], "ellipsis": false }, { @@ -3633,6 +6295,12 @@ "func_desc": "Returns the price per $100 face value for a Treasury bill.", "is_nullary": false, "comp_str": "TBILLPRICE(${1:settlement},${2: maturity},${3: discount})", + "req_param": [ + "settlement", + "maturity", + "discount" + ], + "opt_param": [], "ellipsis": false }, { @@ -3641,6 +6309,12 @@ "func_desc": "Returns the yield for a Treasury bill.", "is_nullary": false, "comp_str": "TBILLYIELD(${1:settlement},${2: maturity},${3: pr})", + "req_param": [ + "settlement", + "maturity", + "pr" + ], + "opt_param": [], "ellipsis": false }, { @@ -3649,6 +6323,12 @@ "func_desc": "Returns the Student's t-distribution. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "TDIST(${1:x},${2: deg_freedom},${3: tails})", + "req_param": [ + "x", + "deg_freedom", + "tails" + ], + "opt_param": [], "ellipsis": false }, { @@ -3657,6 +6337,11 @@ "func_desc": "Formats a number and converts it to text.", "is_nullary": false, "comp_str": "TEXT(${1:value},${2: format_text})", + "req_param": [ + "value", + "format_text" + ], + "opt_param": [], "ellipsis": false }, { @@ -3665,6 +6350,16 @@ "func_desc": "Returns text that's after delimiting characters.", "is_nullary": false, "comp_str": "TEXTAFTER(${1:text},${2: delimiter}${3:,${4: [instance_num]},${5: [match_mode]},${6: [match_end]},${7: [if_not_found]}})", + "req_param": [ + "text", + "delimiter" + ], + "opt_param": [ + "instance_num", + "match_mode", + "match_end", + "if_not_found" + ], "ellipsis": false }, { @@ -3673,6 +6368,16 @@ "func_desc": "Returns text that's before delimiting characters.", "is_nullary": false, "comp_str": "TEXTBEFORE(${1:text},${2: delimiter}${3:,${4: [instance_num]},${5: [match_mode]},${6: [match_end]},${7: [if_not_found]}})", + "req_param": [ + "text", + "delimiter" + ], + "opt_param": [ + "instance_num", + "match_mode", + "match_end", + "if_not_found" + ], "ellipsis": false }, { @@ -3681,6 +6386,14 @@ "func_desc": "Combines the text from multiple ranges and/or strings, and includes a delimiter you specify between each text value that will be combined. If the delimiter is an empty text string, this function will effectively concatenate the ranges. This function isn't available in Excel 2016 for Mac.", "is_nullary": false, "comp_str": "TEXTJOIN(${1:delimiter},${2: ignore_empty},${3: text1}${4:,${5: [text2], ...}})", + "req_param": [ + "delimiter", + "ignore_empty", + "text1" + ], + "opt_param": [ + "text2" + ], "ellipsis": true }, { @@ -3689,6 +6402,16 @@ "func_desc": "Splits text into rows or columns using delimiters.", "is_nullary": false, "comp_str": "TEXTSPLIT(${1:text},${2: col_delimiter}${3:,${4: [row_delimiter]},${5: [ignore_empty]},${6: [match_mode]},${7: [pad_with]}})", + "req_param": [ + "text", + "col_delimiter" + ], + "opt_param": [ + "row_delimiter", + "ignore_empty", + "match_mode", + "pad_with" + ], "ellipsis": false }, { @@ -3697,6 +6420,12 @@ "func_desc": "Returns the serial number of a particular time.", "is_nullary": false, "comp_str": "TIME(${1:hour},${2: minute},${3: second})", + "req_param": [ + "hour", + "minute", + "second" + ], + "opt_param": [], "ellipsis": false }, { @@ -3705,6 +6434,10 @@ "func_desc": "Converts a time in the form of text to a serial number.", "is_nullary": false, "comp_str": "TIMEVALUE(${1:time_text})", + "req_param": [ + "time_text" + ], + "opt_param": [], "ellipsis": false }, { @@ -3713,6 +6446,11 @@ "func_desc": "Returns the inverse of the Student's t-distribution. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "TINV(${1:probability},${2: deg_freedom})", + "req_param": [ + "probability", + "deg_freedom" + ], + "opt_param": [], "ellipsis": false }, { @@ -3721,6 +6459,13 @@ "func_desc": "Returns the array as a column.", "is_nullary": false, "comp_str": "TOCOL(${1:array}${2:,${3: [ignore]},${4: [scan_by_column]}})", + "req_param": [ + "array" + ], + "opt_param": [ + "ignore", + "scan_by_column" + ], "ellipsis": false }, { @@ -3728,7 +6473,8 @@ "func_cat": "Date and time", "func_desc": "Returns the serial number of today's date.", "is_nullary": true, - "comp_str": "=TODAY()" + "comp_str": "TODAY()", + "ellipsis": false }, { "func_name": "TOROW", @@ -3736,6 +6482,13 @@ "func_desc": "Returns the array as a row.", "is_nullary": false, "comp_str": "TOROW(${1:array}${2:,${3: [ignore]},${4: [scan_by_column]}})", + "req_param": [ + "array" + ], + "opt_param": [ + "ignore", + "scan_by_column" + ], "ellipsis": false }, { @@ -3744,6 +6497,10 @@ "func_desc": "Returns the transpose of an array.", "is_nullary": false, "comp_str": "TRANSPOSE(${1:array})", + "req_param": [ + "array" + ], + "opt_param": [], "ellipsis": false }, { @@ -3752,6 +6509,14 @@ "func_desc": "Returns values along a linear trend.", "is_nullary": false, "comp_str": "TREND(${1:known_ys}${2:,${3: [known_xs]},${4: [new_xs]},${5: [const]}})", + "req_param": [ + "known_ys" + ], + "opt_param": [ + "known_xs", + "new_xs", + "const" + ], "ellipsis": false }, { @@ -3760,6 +6525,10 @@ "func_desc": "Removes spaces from text.", "is_nullary": false, "comp_str": "TRIM(${1:text})", + "req_param": [ + "text" + ], + "opt_param": [], "ellipsis": false }, { @@ -3768,6 +6537,11 @@ "func_desc": "Returns the mean of the interior of a data set.", "is_nullary": false, "comp_str": "TRIMMEAN(${1:array},${2: percent})", + "req_param": [ + "array", + "percent" + ], + "opt_param": [], "ellipsis": false }, { @@ -3776,6 +6550,12 @@ "func_desc": "Truncates a number to an integer.", "is_nullary": false, "comp_str": "TRUNC(${1:number}${2:,${3: [num_digits]}})", + "req_param": [ + "number" + ], + "opt_param": [ + "num_digits" + ], "ellipsis": false }, { @@ -3784,6 +6564,13 @@ "func_desc": "Returns the probability associated with a Student's t-test. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "TTEST(${1:array1},${2: array2},${3: tails},${4: type})", + "req_param": [ + "array1", + "array2", + "tails", + "type" + ], + "opt_param": [], "ellipsis": false }, { @@ -3792,6 +6579,10 @@ "func_desc": "Returns a number indicating the data type of a value.", "is_nullary": false, "comp_str": "TYPE(${1:value})", + "req_param": [ + "value" + ], + "opt_param": [], "ellipsis": false }, { @@ -3800,6 +6591,10 @@ "func_desc": "Returns the Unicode character that is references by the given numeric value.", "is_nullary": false, "comp_str": "UNICHAR(${1:number})", + "req_param": [ + "number" + ], + "opt_param": [], "ellipsis": false }, { @@ -3808,6 +6603,10 @@ "func_desc": "Returns the number (code point) that corresponds to the first character of the text.", "is_nullary": false, "comp_str": "UNICODE(${1:text})", + "req_param": [ + "text" + ], + "opt_param": [], "ellipsis": false }, { @@ -3816,6 +6615,13 @@ "func_desc": "Returns a list of unique values in a list or range", "is_nullary": false, "comp_str": "UNIQUE(${1:array}${2:,${3: [by_col]},${4: [exactly_once]}})", + "req_param": [ + "array" + ], + "opt_param": [ + "by_col", + "exactly_once" + ], "ellipsis": false }, { @@ -3824,6 +6630,10 @@ "func_desc": "Removes the registration of a DLL or code resource.", "is_nullary": false, "comp_str": "UNREGISTER(${1:register_id})", + "req_param": [ + "register_id" + ], + "opt_param": [], "ellipsis": false }, { @@ -3832,6 +6642,10 @@ "func_desc": "Converts text to uppercase.", "is_nullary": false, "comp_str": "UPPER(${1:text})", + "req_param": [ + "text" + ], + "opt_param": [], "ellipsis": false }, { @@ -3840,6 +6654,10 @@ "func_desc": "Converts a text argument to a number.", "is_nullary": false, "comp_str": "VALUE(${1:text})", + "req_param": [ + "text" + ], + "opt_param": [], "ellipsis": false }, { @@ -3848,6 +6666,12 @@ "func_desc": "Returns text from any specified value", "is_nullary": false, "comp_str": "VALUETOTEXT(${1:value}${2:,${3: [format]}})", + "req_param": [ + "value" + ], + "opt_param": [ + "format" + ], "ellipsis": false }, { @@ -3856,6 +6680,12 @@ "func_desc": "Estimates variance based on a sample. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "VAR(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -3864,6 +6694,12 @@ "func_desc": "Calculates variance based on the entire population.", "is_nullary": false, "comp_str": "VAR.P(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -3872,6 +6708,12 @@ "func_desc": "Estimates variance based on a sample.", "is_nullary": false, "comp_str": "VAR.S(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -3880,6 +6722,12 @@ "func_desc": "Estimates variance based on a sample, including numbers, text, and logical values.", "is_nullary": false, "comp_str": "VARA(${1:value1}${2:,${3: [value2], ...}})", + "req_param": [ + "value1" + ], + "opt_param": [ + "value2" + ], "ellipsis": true }, { @@ -3888,6 +6736,12 @@ "func_desc": "Calculates variance based on the entire population. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "VARP(${1:number1}${2:,${3: [number2], ...}})", + "req_param": [ + "number1" + ], + "opt_param": [ + "number2" + ], "ellipsis": true }, { @@ -3896,6 +6750,12 @@ "func_desc": "Calculates variance based on the entire population, including numbers, text, and logical values.", "is_nullary": false, "comp_str": "VARPA(${1:value1}${2:,${3: [value2], ...}})", + "req_param": [ + "value1" + ], + "opt_param": [ + "value2" + ], "ellipsis": true }, { @@ -3904,6 +6764,17 @@ "func_desc": "Returns the depreciation of an asset for a specified or partial period by using a declining balance method.", "is_nullary": false, "comp_str": "VDB(${1:cost},${2: salvage},${3: life},${4: start_period},${5: end_period}${6:,${7: [factor]},${8: [no_switch]}})", + "req_param": [ + "cost", + "salvage", + "life", + "start_period", + "end_period" + ], + "opt_param": [ + "factor", + "no_switch" + ], "ellipsis": false }, { @@ -3912,6 +6783,14 @@ "func_desc": "Looks in the first column of an array and moves across the row to return the value of a cell.", "is_nullary": false, "comp_str": "VLOOKUP(${1:lookup_value},${2: table_array},${3: col_index_num}${4:,${5: [range_lookup]}})", + "req_param": [ + "lookup_value", + "table_array", + "col_index_num" + ], + "opt_param": [ + "range_lookup" + ], "ellipsis": false }, { @@ -3920,6 +6799,12 @@ "func_desc": "Vertically combine arrays into one array.", "is_nullary": false, "comp_str": "VSTACK(${1:array1}${2:,${3: [array2], ...}})", + "req_param": [ + "array1" + ], + "opt_param": [ + "array2" + ], "ellipsis": true }, { @@ -3928,6 +6813,10 @@ "func_desc": "Returns data from a web service. This function is not available in Excel Online.", "is_nullary": false, "comp_str": "WEBSERVICE(${1:url})", + "req_param": [ + "url" + ], + "opt_param": [], "ellipsis": false }, { @@ -3936,6 +6825,12 @@ "func_desc": "Converts a serial number to a day of the week.", "is_nullary": false, "comp_str": "WEEKDAY(${1:serial_number}${2:,${3: [return_type]}})", + "req_param": [ + "serial_number" + ], + "opt_param": [ + "return_type" + ], "ellipsis": false }, { @@ -3944,6 +6839,12 @@ "func_desc": "Converts a serial number to a number representing where the week falls numerically with a year.", "is_nullary": false, "comp_str": "WEEKNUM(${1:serial_number}${2:,${3: [return_type]}})", + "req_param": [ + "serial_number" + ], + "opt_param": [ + "return_type" + ], "ellipsis": false }, { @@ -3952,6 +6853,13 @@ "func_desc": "Calculates variance based on the entire population, including numbers, text, and logical values. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "WEIBULL(${1:x},${2: alpha},${3: beta},${4: cumulative})", + "req_param": [ + "x", + "alpha", + "beta", + "cumulative" + ], + "opt_param": [], "ellipsis": false }, { @@ -3960,6 +6868,13 @@ "func_desc": "Returns the Weibull distribution.", "is_nullary": false, "comp_str": "WEIBULL.DIST(${1:x},${2: alpha},${3: beta},${4: cumulative})", + "req_param": [ + "x", + "alpha", + "beta", + "cumulative" + ], + "opt_param": [], "ellipsis": false }, { @@ -3968,6 +6883,13 @@ "func_desc": "Returns the serial number of the date before or after a specified number of workdays.", "is_nullary": false, "comp_str": "WORKDAY(${1:start_date},${2: days}${3:,${4: [holidays]}})", + "req_param": [ + "start_date", + "days" + ], + "opt_param": [ + "holidays" + ], "ellipsis": false }, { @@ -3976,6 +6898,14 @@ "func_desc": "Returns the serial number of the date before or after a specified number of workdays using parameters to indicate which and how many days are weekend days.", "is_nullary": false, "comp_str": "WORKDAY.INTL(${1:start_date},${2: days}${3:,${4: [weekend]},${5: [holidays]}})", + "req_param": [ + "start_date", + "days" + ], + "opt_param": [ + "weekend", + "holidays" + ], "ellipsis": false }, { @@ -3984,6 +6914,13 @@ "func_desc": "Wraps a row or column to a specified height.", "is_nullary": false, "comp_str": "WRAPCOLS(${1:vector},${2: wrap_count}${3:,${4: [pad_with]}})", + "req_param": [ + "vector", + "wrap_count" + ], + "opt_param": [ + "pad_with" + ], "ellipsis": false }, { @@ -3992,6 +6929,13 @@ "func_desc": "Wraps a row or column to a specified width.", "is_nullary": false, "comp_str": "WRAPROWS(${1:vector},${2: wrap_count}${3:,${4: [pad_with]}})", + "req_param": [ + "vector", + "wrap_count" + ], + "opt_param": [ + "pad_with" + ], "ellipsis": false }, { @@ -4000,6 +6944,13 @@ "func_desc": "Returns the internal rate of return for a schedule of cash flows that is not necessarily periodic.", "is_nullary": false, "comp_str": "XIRR(${1:values},${2: dates}${3:,${4: [guess]}})", + "req_param": [ + "values", + "dates" + ], + "opt_param": [ + "guess" + ], "ellipsis": false }, { @@ -4008,6 +6959,16 @@ "func_desc": "Searches a range or an array, and returns an item corresponding to the first match it finds. If a match doesn't exist,then XLOOKUP can return the closest (approximate) match.", "is_nullary": false, "comp_str": "XLOOKUP(${1:lookup_value},${2: lookup_array},${3: return_array}${4:,${5: [if_not_found]},${6: [match_mode]},${7: [search_mode]}})", + "req_param": [ + "lookup_value", + "lookup_array", + "return_array" + ], + "opt_param": [ + "if_not_found", + "match_mode", + "search_mode" + ], "ellipsis": false }, { @@ -4016,6 +6977,14 @@ "func_desc": "Returns the relative position of an item in an array or range of cells.", "is_nullary": false, "comp_str": "XMATCH(${1:lookup_value},${2: lookup_array}${3:,${4: [match_mode]},${5: [search_mode]}})", + "req_param": [ + "lookup_value", + "lookup_array" + ], + "opt_param": [ + "match_mode", + "search_mode" + ], "ellipsis": false }, { @@ -4024,6 +6993,12 @@ "func_desc": "Returns the net present value for a schedule of cash flows that is not necessarily periodic.", "is_nullary": false, "comp_str": "XNPV(${1:rate},${2: values},${3: dates})", + "req_param": [ + "rate", + "values", + "dates" + ], + "opt_param": [], "ellipsis": false }, { @@ -4032,6 +7007,12 @@ "func_desc": "Returns a logical exclusive OR of all arguments.", "is_nullary": false, "comp_str": "XOR(${1:logical1}${2:,${3: [logical2], ...}})", + "req_param": [ + "logical1" + ], + "opt_param": [ + "logical2" + ], "ellipsis": true }, { @@ -4040,6 +7021,10 @@ "func_desc": "Converts a serial number to a year.", "is_nullary": false, "comp_str": "YEAR(${1:serial_number})", + "req_param": [ + "serial_number" + ], + "opt_param": [], "ellipsis": false }, { @@ -4048,6 +7033,13 @@ "func_desc": "Returns the year fraction representing the number of whole days between start_date and end_date.", "is_nullary": false, "comp_str": "YEARFRAC(${1:start_date},${2: end_date}${3:,${4: [basis]}})", + "req_param": [ + "start_date", + "end_date" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -4056,6 +7048,17 @@ "func_desc": "Returns the yield on a security that pays periodic interest.", "is_nullary": false, "comp_str": "YIELD(${1:settlement},${2: maturity},${3: rate},${4: pr},${5: redemption},${6: frequency}${7:,${8: [basis]}})", + "req_param": [ + "settlement", + "maturity", + "rate", + "pr", + "redemption", + "frequency" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -4064,6 +7067,15 @@ "func_desc": "Returns the annual yield for a discounted security.", "is_nullary": false, "comp_str": "YIELDDISC(${1:settlement},${2: maturity},${3: pr},${4: redemption}${5:,${6: [basis]}})", + "req_param": [ + "settlement", + "maturity", + "pr", + "redemption" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -4072,6 +7084,16 @@ "func_desc": "Returns the annual yield of a security that pays interest at maturity.", "is_nullary": false, "comp_str": "YIELDMAT(${1:settlement},${2: maturity},${3: issue},${4: rate},${5: pr}${6:,${7: [basis]}})", + "req_param": [ + "settlement", + "maturity", + "issue", + "rate", + "pr" + ], + "opt_param": [ + "basis" + ], "ellipsis": false }, { @@ -4080,6 +7102,13 @@ "func_desc": "Returns the one-tailed probability-value of a z-test.", "is_nullary": false, "comp_str": "Z.TEST(${1:array},${2: x}${3:,${4: [sigma]}})", + "req_param": [ + "array", + "x" + ], + "opt_param": [ + "sigma" + ], "ellipsis": false }, { @@ -4088,6 +7117,13 @@ "func_desc": "Returns the one-tailed probability-value of a z-test. In Excel 2007, this is a Statistical function.", "is_nullary": false, "comp_str": "ZTEST(${1:array},${2: x}${3:,${4: [sigma]}})", + "req_param": [ + "array", + "x" + ], + "opt_param": [ + "sigma" + ], "ellipsis": false } ] \ No newline at end of file