From 267c6f2ac71f92999e969232431ba04678e7437e Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Mon, 15 Apr 2024 07:54:39 +0200 Subject: Adding upstream version 4:24.2.0. Signed-off-by: Daniel Baumann --- scaddins/inc/analysis.hrc | 1105 +++++++++++++++++++++++++++++++++++++++++++++ scaddins/inc/datefunc.hrc | 94 ++++ scaddins/inc/pricing.hrc | 123 +++++ scaddins/inc/strings.hrc | 141 ++++++ 4 files changed, 1463 insertions(+) create mode 100644 scaddins/inc/analysis.hrc create mode 100644 scaddins/inc/datefunc.hrc create mode 100644 scaddins/inc/pricing.hrc create mode 100644 scaddins/inc/strings.hrc (limited to 'scaddins/inc') diff --git a/scaddins/inc/analysis.hrc b/scaddins/inc/analysis.hrc new file mode 100644 index 0000000000..7a7aa5f7c0 --- /dev/null +++ b/scaddins/inc/analysis.hrc @@ -0,0 +1,1105 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include + +#define NC_(Context, String) TranslateId(Context, u8##String) + +const TranslateId ANALYSIS_Workday[] = +{ + NC_("ANALYSIS_Workday", "Returns the serial number of the date before or after a specified number of workdays"), + NC_("ANALYSIS_Workday", "Start date"), + NC_("ANALYSIS_Workday", "The start date"), + NC_("ANALYSIS_Workday", "Days"), + NC_("ANALYSIS_Workday", "The number of workdays before or after the start date"), + NC_("ANALYSIS_Workday", "Holidays"), + NC_("ANALYSIS_Workday", "List of date values of days off (vacation, holidays, etc.)") +}; + +const TranslateId ANALYSIS_Yearfrac[] = +{ + NC_("ANALYSIS_Yearfrac", "Returns the number of years (including fractional part) between two dates"), + NC_("ANALYSIS_Yearfrac", "Start date"), + NC_("ANALYSIS_Yearfrac", "The start date"), + NC_("ANALYSIS_Yearfrac", "End date"), + NC_("ANALYSIS_Yearfrac", "The end date"), + NC_("ANALYSIS_Yearfrac", "Basis"), + NC_("ANALYSIS_Yearfrac", "Basis indicates the day-count convention to use in the calculation") +}; + +const TranslateId ANALYSIS_Edate[] = +{ + NC_("ANALYSIS_Edate", "Returns the serial number of the date that is a specified number of months before or after the start date"), + NC_("ANALYSIS_Edate", "Start date"), + NC_("ANALYSIS_Edate", "The start date"), + NC_("ANALYSIS_Edate", "Months"), + NC_("ANALYSIS_Edate", "Number of months before or after the start date") +}; + +const TranslateId ANALYSIS_Weeknum[] = +{ + NC_("ANALYSIS_Weeknum", "Returns the number of the calendar week in which the specified date occurs.\nThis function exists for interoperability with older Microsoft Excel documents, for new documents use WEEKNUM instead."), + NC_("ANALYSIS_Weeknum", "Date"), + NC_("ANALYSIS_Weeknum", "The date or date serial number"), + NC_("ANALYSIS_Weeknum", "Return type"), + NC_("ANALYSIS_Weeknum", "Indicates the first day of the week (1 = Sunday, 2 = Monday)") +}; + +const TranslateId ANALYSIS_Eomonth[] = +{ + NC_("ANALYSIS_Eomonth", "Returns the serial number of the last day of the month that comes a certain number of months before or after the start date"), + NC_("ANALYSIS_Eomonth", "Start date"), + NC_("ANALYSIS_Eomonth", "The start date"), + NC_("ANALYSIS_Eomonth", "Months"), + NC_("ANALYSIS_Eomonth", "Number of months before or after the start date") +}; + +const TranslateId ANALYSIS_Networkdays[] = +{ + NC_("ANALYSIS_Networkdays", "Returns the number of workdays between two dates.\nThis function exists for interoperability with older Microsoft Excel documents, for new documents use NETWORKDAYS instead."), + NC_("ANALYSIS_Networkdays", "Start date"), + NC_("ANALYSIS_Networkdays", "The start date"), + NC_("ANALYSIS_Networkdays", "End date"), + NC_("ANALYSIS_Networkdays", "The end date"), + NC_("ANALYSIS_Networkdays", "Holidays"), + NC_("ANALYSIS_Networkdays", "List of date values representing days off (vacation, holidays, etc.)") +}; + +const TranslateId ANALYSIS_Iseven[] = +{ + NC_("ANALYSIS_Iseven", "Returns the value 'true' if the number truncated to integer is even"), + NC_("ANALYSIS_Iseven", "Number"), + NC_("ANALYSIS_Iseven", "The number") +}; + +const TranslateId ANALYSIS_Isodd[] = +{ + NC_("ANALYSIS_Isodd", "Returns the value 'true' if the number truncated to integer is odd"), + NC_("ANALYSIS_Isodd", "Number"), + NC_("ANALYSIS_Isodd", "The number") +}; + +const TranslateId ANALYSIS_Multinomial[] = +{ + NC_("ANALYSIS_Multinomial", "Returns the multinomial coefficient of a set of numbers"), + NC_("ANALYSIS_Multinomial", "Number"), + NC_("ANALYSIS_Multinomial", "Number or list of numbers for which you want the multinomial coefficient") +}; + +const TranslateId ANALYSIS_Seriessum[] = +{ + NC_("ANALYSIS_Seriessum", "Returns the sum of a power series"), + NC_("ANALYSIS_Seriessum", "X"), + NC_("ANALYSIS_Seriessum", "The independent variable of the power series"), + NC_("ANALYSIS_Seriessum", "N"), + NC_("ANALYSIS_Seriessum", "The initial power to which x is to be raised"), + NC_("ANALYSIS_Seriessum", "M"), + NC_("ANALYSIS_Seriessum", "The increment by which to increase n for each term in the series"), + NC_("ANALYSIS_Seriessum", "Coefficients"), + NC_("ANALYSIS_Seriessum", "Set of coefficients by which each successive power of the variable x is multiplied") +}; + +const TranslateId ANALYSIS_Quotient[] = +{ + NC_("ANALYSIS_Quotient", "Returns the integer portion of a division"), + NC_("ANALYSIS_Quotient", "Numerator"), + NC_("ANALYSIS_Quotient", "The dividend"), + NC_("ANALYSIS_Quotient", "Denominator"), + NC_("ANALYSIS_Quotient", "The divisor") +}; + +const TranslateId ANALYSIS_Mround[] = +{ + NC_("ANALYSIS_Mround", "Returns a number rounded to a specified multiple"), + NC_("ANALYSIS_Mround", "Number"), + NC_("ANALYSIS_Mround", "The number to round off"), + NC_("ANALYSIS_Mround", "Multiple"), + NC_("ANALYSIS_Mround", "The multiple to which you want to round number") +}; + +const TranslateId ANALYSIS_Sqrtpi[] = +{ + NC_("ANALYSIS_Sqrtpi", "Returns the square root of a number which has been multiplied by pi"), + NC_("ANALYSIS_Sqrtpi", "Number"), + NC_("ANALYSIS_Sqrtpi", "The number by which pi is multiplied") +}; + +const TranslateId ANALYSIS_Randbetween[] = +{ + NC_("ANALYSIS_Randbetween", "Returns a random integer between the specified Bottom and Top values (both inclusive)"), + NC_("ANALYSIS_Randbetween", "Bottom"), + NC_("ANALYSIS_Randbetween", "The smallest integer that can be returned"), + NC_("ANALYSIS_Randbetween", "Top"), + NC_("ANALYSIS_Randbetween", "The largest integer that can be returned") +}; + +const TranslateId ANALYSIS_Gcd[] = +{ + NC_("ANALYSIS_Gcd", "Returns the greatest common divisor.\nThis function exists for interoperability with older Microsoft Excel documents, for new documents use GCD instead."), + NC_("ANALYSIS_Gcd", "Number"), + NC_("ANALYSIS_Gcd", "Number or list of numbers") +}; + +const TranslateId ANALYSIS_Lcm[] = +{ + NC_("ANALYSIS_Lcm", "Returns the least common multiple.\nThis function exists for interoperability with older Microsoft Excel documents, for new documents use LCM instead."), + NC_("ANALYSIS_Lcm", "Number"), + NC_("ANALYSIS_Lcm", "Number or list of numbers") +}; + +const TranslateId ANALYSIS_Besseli[] = +{ + NC_("ANALYSIS_Besseli", "Returns the modified Bessel function In(x)"), + NC_("ANALYSIS_Besseli", "X"), + NC_("ANALYSIS_Besseli", "The value at which the function is to be evaluated"), + NC_("ANALYSIS_Besseli", "N"), + NC_("ANALYSIS_Besseli", "The order of the Bessel function") +}; + +const TranslateId ANALYSIS_Besselj[] = +{ + NC_("ANALYSIS_Besselj", "Returns the Bessel function Jn(x)"), + NC_("ANALYSIS_Besselj", "X"), + NC_("ANALYSIS_Besselj", "The value at which the function is to be evaluated"), + NC_("ANALYSIS_Besselj", "N"), + NC_("ANALYSIS_Besselj", "The order of the Bessel function") +}; + +const TranslateId ANALYSIS_Besselk[] = +{ + NC_("ANALYSIS_Besselk", "Returns the Bessel function Kn(x)"), + NC_("ANALYSIS_Besselk", "X"), + NC_("ANALYSIS_Besselk", "The value at which the function is to be evaluated"), + NC_("ANALYSIS_Besselk", "N"), + NC_("ANALYSIS_Besselk", "The order of the Bessel function") +}; + +const TranslateId ANALYSIS_Bessely[] = +{ + NC_("ANALYSIS_Bessely", "Returns the Bessel function Yn(x)"), + NC_("ANALYSIS_Bessely", "X"), + NC_("ANALYSIS_Bessely", "The value at which the function is to be evaluated"), + NC_("ANALYSIS_Bessely", "N"), + NC_("ANALYSIS_Bessely", "The order of the Bessel function") +}; + +const TranslateId ANALYSIS_Bin2Oct[] = +{ + NC_("ANALYSIS_Bin2Oct", "Converts a binary number to an octal number"), + NC_("ANALYSIS_Bin2Oct", "Number"), + NC_("ANALYSIS_Bin2Oct", "The binary number to be converted (as text)"), + NC_("ANALYSIS_Bin2Oct", "Places"), + NC_("ANALYSIS_Bin2Oct", "Number of places used") +}; + +const TranslateId ANALYSIS_Bin2Dec[] = +{ + NC_("ANALYSIS_Bin2Dec", "Converts a binary number to a decimal number"), + NC_("ANALYSIS_Bin2Dec", "Number"), + NC_("ANALYSIS_Bin2Dec", "The binary number to be converted (as text)") +}; + +const TranslateId ANALYSIS_Bin2Hex[] = +{ + NC_("ANALYSIS_Bin2Hex", "Converts a binary number to a hexadecimal number"), + NC_("ANALYSIS_Bin2Hex", "Number"), + NC_("ANALYSIS_Bin2Hex", "The binary number to be converted (as text)"), + NC_("ANALYSIS_Bin2Hex", "Places"), + NC_("ANALYSIS_Bin2Hex", "Number of places used.") +}; + +const TranslateId ANALYSIS_Oct2Bin[] = +{ + NC_("ANALYSIS_Oct2Bin", "Converts an octal number to a binary number"), + NC_("ANALYSIS_Oct2Bin", "Number"), + NC_("ANALYSIS_Oct2Bin", "The octal number to be converted (as text)"), + NC_("ANALYSIS_Oct2Bin", "Places"), + NC_("ANALYSIS_Oct2Bin", "Number of places used") +}; + +const TranslateId ANALYSIS_Oct2Dec[] = +{ + NC_("ANALYSIS_Oct2Dec", "Converts an octal number to a decimal number"), + NC_("ANALYSIS_Oct2Dec", "Number"), + NC_("ANALYSIS_Oct2Dec", "The octal number to be converted (as text)") +}; + +const TranslateId ANALYSIS_Oct2Hex[] = +{ + NC_("ANALYSIS_Oct2Hex", "Converts an octal number to a hexadecimal number"), + NC_("ANALYSIS_Oct2Hex", "Number"), + NC_("ANALYSIS_Oct2Hex", "The octal number to be converted (as text)"), + NC_("ANALYSIS_Oct2Hex", "Places"), + NC_("ANALYSIS_Oct2Hex", "Number of places used") +}; + +const TranslateId ANALYSIS_Dec2Bin[] = +{ + NC_("ANALYSIS_Dec2Bin", "Converts a decimal number to a binary number"), + NC_("ANALYSIS_Dec2Bin", "Number"), + NC_("ANALYSIS_Dec2Bin", "The decimal integer to be converted"), + NC_("ANALYSIS_Dec2Bin", "Places"), + NC_("ANALYSIS_Dec2Bin", "Number of places used") +}; + +const TranslateId ANALYSIS_Dec2Hex[] = +{ + NC_("ANALYSIS_Dec2Hex", "Converts a decimal number to a hexadecimal number"), + NC_("ANALYSIS_Dec2Hex", "Number"), + NC_("ANALYSIS_Dec2Hex", "The decimal integer to be converted"), + NC_("ANALYSIS_Dec2Hex", "Places"), + NC_("ANALYSIS_Dec2Hex", "Number of places used") +}; + +const TranslateId ANALYSIS_Dec2Oct[] = +{ + NC_("ANALYSIS_Dec2Oct", "Converts a decimal number into an octal number"), + NC_("ANALYSIS_Dec2Oct", "Number"), + NC_("ANALYSIS_Dec2Oct", "The decimal number"), + NC_("ANALYSIS_Dec2Oct", "Places"), + NC_("ANALYSIS_Dec2Oct", "Number of places used") +}; + +const TranslateId ANALYSIS_Hex2Bin[] = +{ + NC_("ANALYSIS_Hex2Bin", "Converts a hexadecimal number to a binary number"), + NC_("ANALYSIS_Hex2Bin", "Number"), + NC_("ANALYSIS_Hex2Bin", "The hexadecimal number to be converted (as text)"), + NC_("ANALYSIS_Hex2Bin", "Places"), + NC_("ANALYSIS_Hex2Bin", "Number of places used") +}; + +const TranslateId ANALYSIS_Hex2Dec[] = +{ + NC_("ANALYSIS_Hex2Dec", "Converts a hexadecimal number to a decimal number"), + NC_("ANALYSIS_Hex2Dec", "Number"), + NC_("ANALYSIS_Hex2Dec", "The hexadecimal number to be converted (as text)") +}; + +const TranslateId ANALYSIS_Hex2Oct[] = +{ + NC_("ANALYSIS_Hex2Oct", "Converts a hexadecimal number to an octal number"), + NC_("ANALYSIS_Hex2Oct", "Number"), + NC_("ANALYSIS_Hex2Oct", "The hexadecimal number to be converted (as text)"), + NC_("ANALYSIS_Hex2Oct", "Places"), + NC_("ANALYSIS_Hex2Oct", "Number of places used") +}; + +const TranslateId ANALYSIS_Delta[] = +{ + NC_("ANALYSIS_Delta", "Tests whether two values are equal"), + NC_("ANALYSIS_Delta", "Number 1"), + NC_("ANALYSIS_Delta", "The first number"), + NC_("ANALYSIS_Delta", "Number 2"), + NC_("ANALYSIS_Delta", "The second number") +}; + +const TranslateId ANALYSIS_Erf[] = +{ + NC_("ANALYSIS_Erf", "Returns the error function"), + NC_("ANALYSIS_Erf", "Lower limit"), + NC_("ANALYSIS_Erf", "The lower limit for integration"), + NC_("ANALYSIS_Erf", "Upper limit"), + NC_("ANALYSIS_Erf", "The upper limit for integration") +}; + +const TranslateId ANALYSIS_Erfc[] = +{ + NC_("ANALYSIS_Erfc", "Returns the complementary error function"), + NC_("ANALYSIS_Erfc", "Lower limit"), + NC_("ANALYSIS_Erfc", "The lower limit for integration") +}; + +const TranslateId ANALYSIS_Gestep[] = +{ + NC_("ANALYSIS_Gestep", "Tests whether a number is greater than a threshold value"), + NC_("ANALYSIS_Gestep", "Number"), + NC_("ANALYSIS_Gestep", "The value to test against step"), + NC_("ANALYSIS_Gestep", "Step"), + NC_("ANALYSIS_Gestep", "The threshold value") +}; + +const TranslateId ANALYSIS_Factdouble[] = +{ + NC_("ANALYSIS_Factdouble", "Returns the double factorial of Number"), + NC_("ANALYSIS_Factdouble", "Number"), + NC_("ANALYSIS_Factdouble", "The number") +}; + +const TranslateId ANALYSIS_Imabs[] = +{ + NC_("ANALYSIS_Imabs", "Returns the absolute value (modulus) of a complex number"), + NC_("ANALYSIS_Imabs", "Complex number"), + NC_("ANALYSIS_Imabs", "The complex number") +}; + +const TranslateId ANALYSIS_Imaginary[] = +{ + NC_("ANALYSIS_Imaginary", "Returns the imaginary coefficient of a complex number"), + NC_("ANALYSIS_Imaginary", "Complex number"), + NC_("ANALYSIS_Imaginary", "The complex number") +}; + +const TranslateId ANALYSIS_Impower[] = +{ + NC_("ANALYSIS_Impower", "Returns a complex number raised to a real power"), + NC_("ANALYSIS_Impower", "Complex number"), + NC_("ANALYSIS_Impower", "The complex number"), + NC_("ANALYSIS_Impower", "Number"), + NC_("ANALYSIS_Impower", "Power to which the complex number is raised") +}; + +const TranslateId ANALYSIS_Imargument[] = +{ + NC_("ANALYSIS_Imargument", "Returns the argument theta, an angle expressed in radians"), + NC_("ANALYSIS_Imargument", "Complex number"), + NC_("ANALYSIS_Imargument", "A complex number") +}; + +const TranslateId ANALYSIS_Imcos[] = +{ + NC_("ANALYSIS_Imcos", "Returns the cosine of a complex number"), + NC_("ANALYSIS_Imcos", "Complex number"), + NC_("ANALYSIS_Imcos", "A complex number") +}; + +const TranslateId ANALYSIS_Imdiv[] = +{ + NC_("ANALYSIS_Imdiv", "Returns the quotient of two complex numbers"), + NC_("ANALYSIS_Imdiv", "Numerator"), + NC_("ANALYSIS_Imdiv", "The dividend"), + NC_("ANALYSIS_Imdiv", "Denominator"), + NC_("ANALYSIS_Imdiv", "The divisor") +}; + +const TranslateId ANALYSIS_Imexp[] = +{ + NC_("ANALYSIS_Imexp", "Returns the algebraic form of the exponential of a complex number"), + NC_("ANALYSIS_Imexp", "Complex number"), + NC_("ANALYSIS_Imexp", "The complex number") +}; + +const TranslateId ANALYSIS_Imconjugate[] = +{ + NC_("ANALYSIS_Imconjugate", "Returns the complex conjugate of a complex number"), + NC_("ANALYSIS_Imconjugate", "Complex number"), + NC_("ANALYSIS_Imconjugate", "The complex number") +}; + +const TranslateId ANALYSIS_Imln[] = +{ + NC_("ANALYSIS_Imln", "Returns the natural logarithm of a complex number"), + NC_("ANALYSIS_Imln", "Complex number"), + NC_("ANALYSIS_Imln", "The complex number") +}; + +const TranslateId ANALYSIS_Imlog10[] = +{ + NC_("ANALYSIS_Imlog10", "Returns the base-10 logarithm of a complex number"), + NC_("ANALYSIS_Imlog10", "Complex number"), + NC_("ANALYSIS_Imlog10", "The complex number") +}; + +const TranslateId ANALYSIS_Imlog2[] = +{ + NC_("ANALYSIS_Imlog2", "Returns the base-2 logarithm of a complex number"), + NC_("ANALYSIS_Imlog2", "Complex number"), + NC_("ANALYSIS_Imlog2", "The complex number") +}; + +const TranslateId ANALYSIS_Improduct[] = +{ + NC_("ANALYSIS_Improduct", "Returns the product of several complex numbers"), + NC_("ANALYSIS_Improduct", "Complex number"), + NC_("ANALYSIS_Improduct", "The first complex number"), + NC_("ANALYSIS_Improduct", "Complex number"), + NC_("ANALYSIS_Improduct", "Another complex number") +}; + +const TranslateId ANALYSIS_Imreal[] = +{ + NC_("ANALYSIS_Imreal", "Returns the real coefficient of a complex number"), + NC_("ANALYSIS_Imreal", "Complex number"), + NC_("ANALYSIS_Imreal", "The complex number") +}; + +const TranslateId ANALYSIS_Imsin[] = +{ + NC_("ANALYSIS_Imsin", "Returns the sine of a complex number"), + NC_("ANALYSIS_Imsin", "Complex number"), + NC_("ANALYSIS_Imsin", "The complex number") +}; + +const TranslateId ANALYSIS_Imsub[] = +{ + NC_("ANALYSIS_Imsub", "Returns the difference of two complex numbers"), + NC_("ANALYSIS_Imsub", "Complex number 1"), + NC_("ANALYSIS_Imsub", "Complex number 1"), + NC_("ANALYSIS_Imsub", "Complex number 2"), + NC_("ANALYSIS_Imsub", "Complex number 2") +}; + +const TranslateId ANALYSIS_Imsqrt[] = +{ + NC_("ANALYSIS_Imsqrt", "Returns the square root of a complex number"), + NC_("ANALYSIS_Imsqrt", "Complex number"), + NC_("ANALYSIS_Imsqrt", "The complex number") +}; + +const TranslateId ANALYSIS_Imsum[] = +{ + NC_("ANALYSIS_Imsum", "Returns the sum of complex numbers"), + NC_("ANALYSIS_Imsum", "Complex number"), + NC_("ANALYSIS_Imsum", "The complex number") +}; + +const TranslateId ANALYSIS_Imtan[] = +{ + NC_("ANALYSIS_Imtan", "Returns the tangent of a complex number"), + NC_("ANALYSIS_Imtan", "Complex number"), + NC_("ANALYSIS_Imtan", "A complex number") +}; + +const TranslateId ANALYSIS_Imsec[] = +{ + NC_("ANALYSIS_Imsec", "Returns the secant of a complex number"), + NC_("ANALYSIS_Imsec", "Complex number"), + NC_("ANALYSIS_Imsec", "A complex number") +}; + +const TranslateId ANALYSIS_Imcsc[] = +{ + NC_("ANALYSIS_Imcsc", "Returns the cosecant of a complex number"), + NC_("ANALYSIS_Imcsc", "Complex number"), + NC_("ANALYSIS_Imcsc", "A complex number") +}; + +const TranslateId ANALYSIS_Imcot[] = +{ + NC_("ANALYSIS_Imcot", "Returns the cotangent of a complex number"), + NC_("ANALYSIS_Imcot", "Complex number"), + NC_("ANALYSIS_Imcot", "A complex number") +}; + +const TranslateId ANALYSIS_Imsinh[] = +{ + NC_("ANALYSIS_Imsinh", "Returns the hyperbolic sine of a complex number"), + NC_("ANALYSIS_Imsinh", "Complex number"), + NC_("ANALYSIS_Imsinh", "A complex number") +}; + +const TranslateId ANALYSIS_Imcosh[] = +{ + NC_("ANALYSIS_Imcosh", "Returns the hyperbolic cosine of a complex number"), + NC_("ANALYSIS_Imcosh", "Complex number"), + NC_("ANALYSIS_Imcosh", "A complex number") +}; + +const TranslateId ANALYSIS_Imsech[] = +{ + NC_("ANALYSIS_Imsech", "Returns the hyperbolic secant of a complex number"), + NC_("ANALYSIS_Imsech", "Complex number"), + NC_("ANALYSIS_Imsech", "A complex number") +}; + +const TranslateId ANALYSIS_Imcsch[] = +{ + NC_("ANALYSIS_Imcsch", "Returns the hyperbolic cosecant of a complex number"), + NC_("ANALYSIS_Imcsch", "Complex number"), + NC_("ANALYSIS_Imcsch", "A complex number") +}; + +const TranslateId ANALYSIS_Complex[] = +{ + NC_("ANALYSIS_Complex", "Converts real and imaginary coefficients into a complex number"), + NC_("ANALYSIS_Complex", "Real num"), + NC_("ANALYSIS_Complex", "The real coefficient"), + NC_("ANALYSIS_Complex", "I num"), + NC_("ANALYSIS_Complex", "The imaginary coefficient"), + NC_("ANALYSIS_Complex", "Suffix"), + NC_("ANALYSIS_Complex", "The suffix") +}; + +const TranslateId ANALYSIS_Convert[] = +{ + NC_("ANALYSIS_Convert", "Converts a number from one measurement system to another"), + NC_("ANALYSIS_Convert", "Number"), + NC_("ANALYSIS_Convert", "The number"), + NC_("ANALYSIS_Convert", "From unit"), + NC_("ANALYSIS_Convert", "Unit of measure for number"), + NC_("ANALYSIS_Convert", "To unit"), + NC_("ANALYSIS_Convert", "Unit of measure for the result") +}; + +const TranslateId ANALYSIS_Amordegrc[] = +{ + NC_("ANALYSIS_Amordegrc", "Returns the prorated linear depreciation of an asset for each accounting period"), + NC_("ANALYSIS_Amordegrc", "Cost"), + NC_("ANALYSIS_Amordegrc", "Cost of the asset"), + NC_("ANALYSIS_Amordegrc", "Date purchased"), + NC_("ANALYSIS_Amordegrc", "Purchase date of the asset"), + NC_("ANALYSIS_Amordegrc", "First period"), + NC_("ANALYSIS_Amordegrc", "Date the first period ends"), + NC_("ANALYSIS_Amordegrc", "Salvage"), + NC_("ANALYSIS_Amordegrc", "Salvage value of an asset at the end of its life"), + NC_("ANALYSIS_Amordegrc", "Period"), + NC_("ANALYSIS_Amordegrc", "The period"), + NC_("ANALYSIS_Amordegrc", "Rate"), + NC_("ANALYSIS_Amordegrc", "The rate of depreciation"), + NC_("ANALYSIS_Amordegrc", "Basis"), + NC_("ANALYSIS_Amordegrc", "The year basis to be used") +}; + +const TranslateId ANALYSIS_Amorlinc[] = +{ + NC_("ANALYSIS_Amorlinc", "Returns the prorated linear depreciation of an asset for each accounting period"), + NC_("ANALYSIS_Amorlinc", "Cost"), + NC_("ANALYSIS_Amorlinc", "Cost of the asset"), + NC_("ANALYSIS_Amorlinc", "Date purchased"), + NC_("ANALYSIS_Amorlinc", "Purchase date of the asset"), + NC_("ANALYSIS_Amorlinc", "First period"), + NC_("ANALYSIS_Amorlinc", "The date the first period ends"), + NC_("ANALYSIS_Amorlinc", "Salvage"), + NC_("ANALYSIS_Amorlinc", "The salvage value of an asset at the end of its life"), + NC_("ANALYSIS_Amorlinc", "Period"), + NC_("ANALYSIS_Amorlinc", "The period"), + NC_("ANALYSIS_Amorlinc", "Rate"), + NC_("ANALYSIS_Amorlinc", "The rate of depreciation"), + NC_("ANALYSIS_Amorlinc", "Basis"), + NC_("ANALYSIS_Amorlinc", "The year basis to be used") +}; + +const TranslateId ANALYSIS_Accrint[] = +{ + NC_("ANALYSIS_Accrint", "Returns the accrued interest for a security that pays periodic interest"), + NC_("ANALYSIS_Accrint", "Issue"), + NC_("ANALYSIS_Accrint", "Issue date of the security"), + NC_("ANALYSIS_Accrint", "First interest"), + NC_("ANALYSIS_Accrint", "First interest date of the security"), + NC_("ANALYSIS_Accrint", "Settlement"), + NC_("ANALYSIS_Accrint", "The settlement"), + NC_("ANALYSIS_Accrint", "Rate"), + NC_("ANALYSIS_Accrint", "The rate"), + NC_("ANALYSIS_Accrint", "Par"), + NC_("ANALYSIS_Accrint", "The par value"), + NC_("ANALYSIS_Accrint", "Frequency"), + NC_("ANALYSIS_Accrint", "The frequency"), + NC_("ANALYSIS_Accrint", "Basis"), + NC_("ANALYSIS_Accrint", "The basis") +}; + +const TranslateId ANALYSIS_Accrintm[] = +{ + NC_("ANALYSIS_Accrintm", "Returns the accrued interest for a security that pays interest at maturity"), + NC_("ANALYSIS_Accrintm", "Issue"), + NC_("ANALYSIS_Accrintm", "The issue date"), + NC_("ANALYSIS_Accrintm", "Settlement"), + NC_("ANALYSIS_Accrintm", "The settlement"), + NC_("ANALYSIS_Accrintm", "Rate"), + NC_("ANALYSIS_Accrintm", "The rate"), + NC_("ANALYSIS_Accrintm", "Par"), + NC_("ANALYSIS_Accrintm", "The par value"), + NC_("ANALYSIS_Accrintm", "Basis"), + NC_("ANALYSIS_Accrintm", "The basis") +}; + +const TranslateId ANALYSIS_Received[] = +{ + NC_("ANALYSIS_Received", "Returns the amount paid out at maturity for a fully invested security"), + NC_("ANALYSIS_Received", "Settlement"), + NC_("ANALYSIS_Received", "The settlement"), + NC_("ANALYSIS_Received", "Maturity"), + NC_("ANALYSIS_Received", "The maturity"), + NC_("ANALYSIS_Received", "Investment"), + NC_("ANALYSIS_Received", "The investment"), + NC_("ANALYSIS_Received", "Discount"), + NC_("ANALYSIS_Received", "The discount"), + NC_("ANALYSIS_Received", "Basis"), + NC_("ANALYSIS_Received", "The basis") +}; + +const TranslateId ANALYSIS_Disc[] = +{ + NC_("ANALYSIS_Disc", "Returns the discount rate for a security"), + NC_("ANALYSIS_Disc", "Settlement"), + NC_("ANALYSIS_Disc", "The settlement"), + NC_("ANALYSIS_Disc", "Maturity"), + NC_("ANALYSIS_Disc", "The maturity"), + NC_("ANALYSIS_Disc", "Price"), + NC_("ANALYSIS_Disc", "The price"), + NC_("ANALYSIS_Disc", "Redemption"), + NC_("ANALYSIS_Disc", "The redemption value"), + NC_("ANALYSIS_Disc", "Basis"), + NC_("ANALYSIS_Disc", "The basis") +}; + +const TranslateId ANALYSIS_Duration[] = +{ + NC_("ANALYSIS_Duration", "Returns the annual Macaulay duration of a security with periodic interest payments"), + NC_("ANALYSIS_Duration", "Settlement"), + NC_("ANALYSIS_Duration", "The settlement"), + NC_("ANALYSIS_Duration", "Maturity"), + NC_("ANALYSIS_Duration", "The maturity"), + NC_("ANALYSIS_Duration", "Coupon"), + NC_("ANALYSIS_Duration", "The coupon rate"), + NC_("ANALYSIS_Duration", "Yield"), + NC_("ANALYSIS_Duration", "The yield"), + NC_("ANALYSIS_Duration", "Frequency"), + NC_("ANALYSIS_Duration", "The frequency"), + NC_("ANALYSIS_Duration", "Basis"), + NC_("ANALYSIS_Duration", "The basis") +}; + +const TranslateId ANALYSIS_Effect[] = +{ + NC_("ANALYSIS_Effect", "Returns the effective annual interest rate"), + NC_("ANALYSIS_Effect", "Nominal rate"), + NC_("ANALYSIS_Effect", "The nominal rate"), + NC_("ANALYSIS_Effect", "Npery"), + NC_("ANALYSIS_Effect", "The periods") +}; + +const TranslateId ANALYSIS_Cumprinc[] = +{ + NC_("ANALYSIS_Cumprinc", "Returns the cumulative principal on a loan to be paid between two periods"), + NC_("ANALYSIS_Cumprinc", "Rate"), + NC_("ANALYSIS_Cumprinc", "The rate"), + NC_("ANALYSIS_Cumprinc", "Nper"), + NC_("ANALYSIS_Cumprinc", "Number of payment periods"), + NC_("ANALYSIS_Cumprinc", "Pv"), + NC_("ANALYSIS_Cumprinc", "The present value"), + NC_("ANALYSIS_Cumprinc", "Start period"), + NC_("ANALYSIS_Cumprinc", "The start period"), + NC_("ANALYSIS_Cumprinc", "End period"), + NC_("ANALYSIS_Cumprinc", "The end period"), + NC_("ANALYSIS_Cumprinc", "Type"), + NC_("ANALYSIS_Cumprinc", "The type of maturity") +}; + +const TranslateId ANALYSIS_Cumipmt[] = +{ + NC_("ANALYSIS_Cumipmt", "Returns the cumulative interest to be paid between two periods"), + NC_("ANALYSIS_Cumipmt", "Rate"), + NC_("ANALYSIS_Cumipmt", "The rate"), + NC_("ANALYSIS_Cumipmt", "Nper"), + NC_("ANALYSIS_Cumipmt", "Number of payment periods"), + NC_("ANALYSIS_Cumipmt", "Pv"), + NC_("ANALYSIS_Cumipmt", "The present value"), + NC_("ANALYSIS_Cumipmt", "Start period"), + NC_("ANALYSIS_Cumipmt", "The start period"), + NC_("ANALYSIS_Cumipmt", "End period"), + NC_("ANALYSIS_Cumipmt", "The end period"), + NC_("ANALYSIS_Cumipmt", "Type"), + NC_("ANALYSIS_Cumipmt", "The type of maturity") +}; + +const TranslateId ANALYSIS_Price[] = +{ + NC_("ANALYSIS_Price", "Returns the price per 100 currency units face value of a security that pays periodic interest"), + NC_("ANALYSIS_Price", "Settlement"), + NC_("ANALYSIS_Price", "The settlement"), + NC_("ANALYSIS_Price", "Maturity"), + NC_("ANALYSIS_Price", "The maturity"), + NC_("ANALYSIS_Price", "Rate"), + NC_("ANALYSIS_Price", "The rate"), + NC_("ANALYSIS_Price", "Yield"), + NC_("ANALYSIS_Price", "The yield"), + NC_("ANALYSIS_Price", "Redemption"), + NC_("ANALYSIS_Price", "The redemption value"), + NC_("ANALYSIS_Price", "Frequency"), + NC_("ANALYSIS_Price", "The frequency"), + NC_("ANALYSIS_Price", "Basis"), + NC_("ANALYSIS_Price", "The basis") +}; + +const TranslateId ANALYSIS_Pricedisc[] = +{ + NC_("ANALYSIS_Pricedisc", "Returns the price per 100 currency units face value of a discounted security"), + NC_("ANALYSIS_Pricedisc", "Settlement"), + NC_("ANALYSIS_Pricedisc", "The settlement"), + NC_("ANALYSIS_Pricedisc", "Maturity"), + NC_("ANALYSIS_Pricedisc", "The maturity"), + NC_("ANALYSIS_Pricedisc", "Discount"), + NC_("ANALYSIS_Pricedisc", "The discount"), + NC_("ANALYSIS_Pricedisc", "Redemption"), + NC_("ANALYSIS_Pricedisc", "The redemption value"), + NC_("ANALYSIS_Pricedisc", "Basis"), + NC_("ANALYSIS_Pricedisc", "The basis") +}; + +const TranslateId ANALYSIS_Pricemat[] = +{ + NC_("ANALYSIS_Pricemat", "Returns the price per 100 currency units face value of a security that pays interest at maturity"), + NC_("ANALYSIS_Pricemat", "Settlement"), + NC_("ANALYSIS_Pricemat", "The settlement"), + NC_("ANALYSIS_Pricemat", "Maturity"), + NC_("ANALYSIS_Pricemat", "The maturity"), + NC_("ANALYSIS_Pricemat", "Issue"), + NC_("ANALYSIS_Pricemat", "The issue date"), + NC_("ANALYSIS_Pricemat", "Rate"), + NC_("ANALYSIS_Pricemat", "The rate"), + NC_("ANALYSIS_Pricemat", "Yield"), + NC_("ANALYSIS_Pricemat", "The yield"), + NC_("ANALYSIS_Pricemat", "Basis"), + NC_("ANALYSIS_Pricemat", "The basis") +}; + +const TranslateId ANALYSIS_Mduration[] = +{ + NC_("ANALYSIS_Mduration", "Returns the Macaulay modified duration for a security with an assumed par value of 100 currency units"), + NC_("ANALYSIS_Mduration", "Settlement"), + NC_("ANALYSIS_Mduration", "The settlement"), + NC_("ANALYSIS_Mduration", "Maturity"), + NC_("ANALYSIS_Mduration", "The maturity"), + NC_("ANALYSIS_Mduration", "Coupon"), + NC_("ANALYSIS_Mduration", "The coupon rate"), + NC_("ANALYSIS_Mduration", "Yield"), + NC_("ANALYSIS_Mduration", "The yield"), + NC_("ANALYSIS_Mduration", "Frequency"), + NC_("ANALYSIS_Mduration", "The frequency"), + NC_("ANALYSIS_Mduration", "Basis"), + NC_("ANALYSIS_Mduration", "The basis") +}; + +const TranslateId ANALYSIS_Nominal[] = +{ + NC_("ANALYSIS_Nominal", "Returns the annual nominal interest rate"), + NC_("ANALYSIS_Nominal", "Effective rate"), + NC_("ANALYSIS_Nominal", "The effective interest rate"), + NC_("ANALYSIS_Nominal", "Npery"), + NC_("ANALYSIS_Nominal", "The periods") +}; + +const TranslateId ANALYSIS_Dollarfr[] = +{ + NC_("ANALYSIS_Dollarfr", "Converts a price expressed as a decimal into a price expressed as a fraction"), + NC_("ANALYSIS_Dollarfr", "Decimal dollar"), + NC_("ANALYSIS_Dollarfr", "The decimal number"), + NC_("ANALYSIS_Dollarfr", "Fraction"), + NC_("ANALYSIS_Dollarfr", "The divisor") +}; + +const TranslateId ANALYSIS_Dollarde[] = +{ + NC_("ANALYSIS_Dollarde", "Converts a price expressed as a fraction into a price expressed as a decimal"), + NC_("ANALYSIS_Dollarde", "Fractional dollar"), + NC_("ANALYSIS_Dollarde", "The number as a fraction"), + NC_("ANALYSIS_Dollarde", "Fraction"), + NC_("ANALYSIS_Dollarde", "The divisor") +}; + +const TranslateId ANALYSIS_Yield[] = +{ + NC_("ANALYSIS_Yield", "Returns the yield on a security that pays periodic interest"), + NC_("ANALYSIS_Yield", "Settlement"), + NC_("ANALYSIS_Yield", "The settlement"), + NC_("ANALYSIS_Yield", "Maturity"), + NC_("ANALYSIS_Yield", "The maturity"), + NC_("ANALYSIS_Yield", "Rate"), + NC_("ANALYSIS_Yield", "The rate"), + NC_("ANALYSIS_Yield", "Price"), + NC_("ANALYSIS_Yield", "The price"), + NC_("ANALYSIS_Yield", "Redemption"), + NC_("ANALYSIS_Yield", "The redemption value"), + NC_("ANALYSIS_Yield", "Frequency"), + NC_("ANALYSIS_Yield", "The frequency"), + NC_("ANALYSIS_Yield", "Basis"), + NC_("ANALYSIS_Yield", "The basis") +}; + +const TranslateId ANALYSIS_Yielddisc[] = +{ + NC_("ANALYSIS_Yielddisc", "Returns the annual yield for a discounted security"), + NC_("ANALYSIS_Yielddisc", "Settlement"), + NC_("ANALYSIS_Yielddisc", "The settlement"), + NC_("ANALYSIS_Yielddisc", "Maturity"), + NC_("ANALYSIS_Yielddisc", "The maturity"), + NC_("ANALYSIS_Yielddisc", "Price"), + NC_("ANALYSIS_Yielddisc", "The price"), + NC_("ANALYSIS_Yielddisc", "Redemption"), + NC_("ANALYSIS_Yielddisc", "The redemption value"), + NC_("ANALYSIS_Yielddisc", "Basis"), + NC_("ANALYSIS_Yielddisc", "The basis") +}; + +const TranslateId ANALYSIS_Yieldmat[] = +{ + NC_("ANALYSIS_Yieldmat", "Returns the annual yield of a security that pays interest at maturity"), + NC_("ANALYSIS_Yieldmat", "Settlement"), + NC_("ANALYSIS_Yieldmat", "The settlement"), + NC_("ANALYSIS_Yieldmat", "Maturity"), + NC_("ANALYSIS_Yieldmat", "The maturity"), + NC_("ANALYSIS_Yieldmat", "Issue"), + NC_("ANALYSIS_Yieldmat", "The issue date"), + NC_("ANALYSIS_Yieldmat", "Rate"), + NC_("ANALYSIS_Yieldmat", "The rate"), + NC_("ANALYSIS_Yieldmat", "Price"), + NC_("ANALYSIS_Yieldmat", "The price"), + NC_("ANALYSIS_Yieldmat", "Basis"), + NC_("ANALYSIS_Yieldmat", "The basis") +}; + +const TranslateId ANALYSIS_Tbilleq[] = +{ + NC_("ANALYSIS_Tbilleq", "Returns the bond-equivalent yield for a treasury bill"), + NC_("ANALYSIS_Tbilleq", "Settlement"), + NC_("ANALYSIS_Tbilleq", "The settlement"), + NC_("ANALYSIS_Tbilleq", "Maturity"), + NC_("ANALYSIS_Tbilleq", "The maturity"), + NC_("ANALYSIS_Tbilleq", "Discount"), + NC_("ANALYSIS_Tbilleq", "The discount rate") +}; + +const TranslateId ANALYSIS_Tbillprice[] = +{ + NC_("ANALYSIS_Tbillprice", "Returns the price of 100 currency units face value for a treasury bill"), + NC_("ANALYSIS_Tbillprice", "Settlement"), + NC_("ANALYSIS_Tbillprice", "The settlement"), + NC_("ANALYSIS_Tbillprice", "Maturity"), + NC_("ANALYSIS_Tbillprice", "The maturity"), + NC_("ANALYSIS_Tbillprice", "Discount"), + NC_("ANALYSIS_Tbillprice", "The discount rate") +}; + +const TranslateId ANALYSIS_Tbillyield[] = +{ + NC_("ANALYSIS_Tbillyield", "Returns the yield for a treasury bill"), + NC_("ANALYSIS_Tbillyield", "Settlement"), + NC_("ANALYSIS_Tbillyield", "The settlement"), + NC_("ANALYSIS_Tbillyield", "Maturity"), + NC_("ANALYSIS_Tbillyield", "The maturity"), + NC_("ANALYSIS_Tbillyield", "Price"), + NC_("ANALYSIS_Tbillyield", "The price") +}; + +const TranslateId ANALYSIS_Oddfprice[] = +{ + NC_("ANALYSIS_Oddfprice", "Returns the price per $100 face value of a security with an odd first period"), + NC_("ANALYSIS_Oddfprice", "Settlement"), + NC_("ANALYSIS_Oddfprice", "The settlement"), + NC_("ANALYSIS_Oddfprice", "Maturity"), + NC_("ANALYSIS_Oddfprice", "The maturity"), + NC_("ANALYSIS_Oddfprice", "Issue"), + NC_("ANALYSIS_Oddfprice", "The issue date"), + NC_("ANALYSIS_Oddfprice", "First coupon"), + NC_("ANALYSIS_Oddfprice", "The first coupon date"), + NC_("ANALYSIS_Oddfprice", "Rate"), + NC_("ANALYSIS_Oddfprice", "The rate"), + NC_("ANALYSIS_Oddfprice", "Yield"), + NC_("ANALYSIS_Oddfprice", "The yield"), + NC_("ANALYSIS_Oddfprice", "Redemption"), + NC_("ANALYSIS_Oddfprice", "The redemption value"), + NC_("ANALYSIS_Oddfprice", "Frequency"), + NC_("ANALYSIS_Oddfprice", "The frequency"), + NC_("ANALYSIS_Oddfprice", "Basis"), + NC_("ANALYSIS_Oddfprice", "The basis") +}; + +const TranslateId ANALYSIS_Oddfyield[] = +{ + NC_("ANALYSIS_Oddfyield", "Returns the yield of a security with an odd first period"), + NC_("ANALYSIS_Oddfyield", "Settlement"), + NC_("ANALYSIS_Oddfyield", "The settlement"), + NC_("ANALYSIS_Oddfyield", "Maturity"), + NC_("ANALYSIS_Oddfyield", "The maturity"), + NC_("ANALYSIS_Oddfyield", "Issue"), + NC_("ANALYSIS_Oddfyield", "The issue date"), + NC_("ANALYSIS_Oddfyield", "First coupon"), + NC_("ANALYSIS_Oddfyield", "The first coupon date"), + NC_("ANALYSIS_Oddfyield", "Rate"), + NC_("ANALYSIS_Oddfyield", "The rate"), + NC_("ANALYSIS_Oddfyield", "Price"), + NC_("ANALYSIS_Oddfyield", "The price"), + NC_("ANALYSIS_Oddfyield", "Redemption"), + NC_("ANALYSIS_Oddfyield", "The redemption value"), + NC_("ANALYSIS_Oddfyield", "Frequency"), + NC_("ANALYSIS_Oddfyield", "The frequency"), + NC_("ANALYSIS_Oddfyield", "Basis"), + NC_("ANALYSIS_Oddfyield", "The basis") +}; + +const TranslateId ANALYSIS_Oddlprice[] = +{ + NC_("ANALYSIS_Oddlprice", "Returns the price per $100 face value of a security with an odd last period"), + NC_("ANALYSIS_Oddlprice", "Settlement"), + NC_("ANALYSIS_Oddlprice", "The settlement"), + NC_("ANALYSIS_Oddlprice", "Maturity"), + NC_("ANALYSIS_Oddlprice", "The maturity"), + NC_("ANALYSIS_Oddlprice", "Last interest"), + NC_("ANALYSIS_Oddlprice", "The last interest date"), + NC_("ANALYSIS_Oddlprice", "Rate"), + NC_("ANALYSIS_Oddlprice", "The rate"), + NC_("ANALYSIS_Oddlprice", "Yield"), + NC_("ANALYSIS_Oddlprice", "The yield"), + NC_("ANALYSIS_Oddlprice", "Redemption"), + NC_("ANALYSIS_Oddlprice", "The redemption value"), + NC_("ANALYSIS_Oddlprice", "Frequency"), + NC_("ANALYSIS_Oddlprice", "The frequency"), + NC_("ANALYSIS_Oddlprice", "Basis"), + NC_("ANALYSIS_Oddlprice", "The basis") +}; + +const TranslateId ANALYSIS_Oddlyield[] = +{ + NC_("ANALYSIS_Oddlyield", "Returns the yield of a security with an odd last period"), + NC_("ANALYSIS_Oddlyield", "Settlement"), + NC_("ANALYSIS_Oddlyield", "The settlement"), + NC_("ANALYSIS_Oddlyield", "Maturity"), + NC_("ANALYSIS_Oddlyield", "The maturity"), + NC_("ANALYSIS_Oddlyield", "Last interest"), + NC_("ANALYSIS_Oddlyield", "The last interest date"), + NC_("ANALYSIS_Oddlyield", "Rate"), + NC_("ANALYSIS_Oddlyield", "The rate"), + NC_("ANALYSIS_Oddlyield", "Price"), + NC_("ANALYSIS_Oddlyield", "The price"), + NC_("ANALYSIS_Oddlyield", "Redemption"), + NC_("ANALYSIS_Oddlyield", "The redemption value"), + NC_("ANALYSIS_Oddlyield", "Frequency"), + NC_("ANALYSIS_Oddlyield", "The frequency"), + NC_("ANALYSIS_Oddlyield", "Basis"), + NC_("ANALYSIS_Oddlyield", "The basis") +}; + +const TranslateId ANALYSIS_Xirr[] = +{ + NC_("ANALYSIS_Xirr", "Returns the internal rate of return for a non-periodic schedule of payments"), + NC_("ANALYSIS_Xirr", "Values"), + NC_("ANALYSIS_Xirr", "The values"), + NC_("ANALYSIS_Xirr", "Dates"), + NC_("ANALYSIS_Xirr", "The dates"), + NC_("ANALYSIS_Xirr", "Guess"), + NC_("ANALYSIS_Xirr", "The guess") +}; + +const TranslateId ANALYSIS_Xnpv[] = +{ + NC_("ANALYSIS_Xnpv", "Returns the net present value for a non-periodic schedule of payments"), + NC_("ANALYSIS_Xnpv", "Rate"), + NC_("ANALYSIS_Xnpv", "The rate"), + NC_("ANALYSIS_Xnpv", "Values"), + NC_("ANALYSIS_Xnpv", "The values"), + NC_("ANALYSIS_Xnpv", "Dates"), + NC_("ANALYSIS_Xnpv", "The dates") +}; + +const TranslateId ANALYSIS_Intrate[] = +{ + NC_("ANALYSIS_Intrate", "Returns the interest rate for a fully invested security"), + NC_("ANALYSIS_Intrate", "Settlement"), + NC_("ANALYSIS_Intrate", "The settlement"), + NC_("ANALYSIS_Intrate", "Maturity"), + NC_("ANALYSIS_Intrate", "The maturity"), + NC_("ANALYSIS_Intrate", "Investment"), + NC_("ANALYSIS_Intrate", "The investment"), + NC_("ANALYSIS_Intrate", "Redemption"), + NC_("ANALYSIS_Intrate", "The redemption value"), + NC_("ANALYSIS_Intrate", "Basis"), + NC_("ANALYSIS_Intrate", "The basis") +}; + +const TranslateId ANALYSIS_Coupncd[] = +{ + NC_("ANALYSIS_Coupncd", "Returns the first coupon date after the settlement date"), + NC_("ANALYSIS_Coupncd", "Settlement"), + NC_("ANALYSIS_Coupncd", "The settlement"), + NC_("ANALYSIS_Coupncd", "Maturity"), + NC_("ANALYSIS_Coupncd", "The maturity"), + NC_("ANALYSIS_Coupncd", "Frequency"), + NC_("ANALYSIS_Coupncd", "The frequency"), + NC_("ANALYSIS_Coupncd", "Basis"), + NC_("ANALYSIS_Coupncd", "The basis") +}; + +const TranslateId ANALYSIS_Coupdays[] = +{ + NC_("ANALYSIS_Coupdays", "Returns the number of days in the coupon period containing the settlement date"), + NC_("ANALYSIS_Coupdays", "Settlement"), + NC_("ANALYSIS_Coupdays", "The settlement"), + NC_("ANALYSIS_Coupdays", "Maturity"), + NC_("ANALYSIS_Coupdays", "The maturity"), + NC_("ANALYSIS_Coupdays", "Frequency"), + NC_("ANALYSIS_Coupdays", "The frequency"), + NC_("ANALYSIS_Coupdays", "Basis"), + NC_("ANALYSIS_Coupdays", "The basis") +}; + +const TranslateId ANALYSIS_Coupdaysnc[] = +{ + NC_("ANALYSIS_Coupdaysnc", "Returns the number of days from the settlement date to the next coupon date"), + NC_("ANALYSIS_Coupdaysnc", "Settlement"), + NC_("ANALYSIS_Coupdaysnc", "The settlement"), + NC_("ANALYSIS_Coupdaysnc", "Maturity"), + NC_("ANALYSIS_Coupdaysnc", "The maturity"), + NC_("ANALYSIS_Coupdaysnc", "Frequency"), + NC_("ANALYSIS_Coupdaysnc", "The frequency"), + NC_("ANALYSIS_Coupdaysnc", "Basis"), + NC_("ANALYSIS_Coupdaysnc", "The basis") +}; + +const TranslateId ANALYSIS_Coupdaybs[] = +{ + NC_("ANALYSIS_Coupdaybs", "Returns the number of days from the beginning of the coupon period to the settlement date"), + NC_("ANALYSIS_Coupdaybs", "Settlement"), + NC_("ANALYSIS_Coupdaybs", "The settlement"), + NC_("ANALYSIS_Coupdaybs", "Maturity"), + NC_("ANALYSIS_Coupdaybs", "The maturity"), + NC_("ANALYSIS_Coupdaybs", "Frequency"), + NC_("ANALYSIS_Coupdaybs", "The frequency"), + NC_("ANALYSIS_Coupdaybs", "Basis"), + NC_("ANALYSIS_Coupdaybs", "The basis") +}; + +const TranslateId ANALYSIS_Couppcd[] = +{ + NC_("ANALYSIS_Couppcd", "Returns the last coupon date preceding the settlement date"), + NC_("ANALYSIS_Couppcd", "Settlement"), + NC_("ANALYSIS_Couppcd", "The settlement"), + NC_("ANALYSIS_Couppcd", "Maturity"), + NC_("ANALYSIS_Couppcd", "The maturity"), + NC_("ANALYSIS_Couppcd", "Frequency"), + NC_("ANALYSIS_Couppcd", "The frequency"), + NC_("ANALYSIS_Couppcd", "Basis"), + NC_("ANALYSIS_Couppcd", "The basis") +}; + +const TranslateId ANALYSIS_Coupnum[] = +{ + NC_("ANALYSIS_Coupnum", "Returns the number of coupons payable between the settlement and maturity dates"), + NC_("ANALYSIS_Coupnum", "Settlement"), + NC_("ANALYSIS_Coupnum", "The settlement"), + NC_("ANALYSIS_Coupnum", "Maturity"), + NC_("ANALYSIS_Coupnum", "The maturity"), + NC_("ANALYSIS_Coupnum", "Frequency"), + NC_("ANALYSIS_Coupnum", "The frequency"), + NC_("ANALYSIS_Coupnum", "Basis"), + NC_("ANALYSIS_Coupnum", "The basis") +}; + +const TranslateId ANALYSIS_Fvschedule[] = +{ + NC_("ANALYSIS_Fvschedule", "Returns the future value of the initial principal after a series of compound interest rates are applied"), + NC_("ANALYSIS_Fvschedule", "Principal"), + NC_("ANALYSIS_Fvschedule", "The principal"), + NC_("ANALYSIS_Fvschedule", "Schedule"), + NC_("ANALYSIS_Fvschedule", "The schedule") +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/scaddins/inc/datefunc.hrc b/scaddins/inc/datefunc.hrc new file mode 100644 index 0000000000..d6285c2c74 --- /dev/null +++ b/scaddins/inc/datefunc.hrc @@ -0,0 +1,94 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include + +#define NC_(Context, String) TranslateId(Context, u8##String) + +const TranslateId DATE_FUNCDESC_DiffWeeks[] = +{ + NC_("DATE_FUNCDESC_DiffWeeks", "Calculates the number of weeks in a specific period"), + NC_("DATE_FUNCDESC_DiffWeeks", "Start date"), + NC_("DATE_FUNCDESC_DiffWeeks", "First day of the period"), + NC_("DATE_FUNCDESC_DiffWeeks", "End date"), + NC_("DATE_FUNCDESC_DiffWeeks", "Last day of the period"), + NC_("DATE_FUNCDESC_DiffWeeks", "Type"), + NC_("DATE_FUNCDESC_DiffWeeks", "Type of calculation: Type=0 means the time interval, Type=1 means calendar weeks.") +}; + +const TranslateId DATE_FUNCDESC_DiffMonths[] = +{ + NC_("DATE_FUNCDESC_DiffMonths", "Determines the number of months in a specific period."), + NC_("DATE_FUNCDESC_DiffMonths", "Start date"), + NC_("DATE_FUNCDESC_DiffMonths", "First day of the period."), + NC_("DATE_FUNCDESC_DiffMonths", "End date"), + NC_("DATE_FUNCDESC_DiffMonths", "Last day of the period."), + NC_("DATE_FUNCDESC_DiffMonths", "Type"), + NC_("DATE_FUNCDESC_DiffMonths", "Type of calculation: Type=0 means the time interval, Type=1 means calendar months.") +}; + +const TranslateId DATE_FUNCDESC_DiffYears[] = +{ + NC_("DATE_FUNCDESC_DiffYears", "Calculates the number of years in a specific period."), + NC_("DATE_FUNCDESC_DiffYears", "Start date"), + NC_("DATE_FUNCDESC_DiffYears", "First day of the period"), + NC_("DATE_FUNCDESC_DiffYears", "End date"), + NC_("DATE_FUNCDESC_DiffYears", "Last day of the period"), + NC_("DATE_FUNCDESC_DiffYears", "Type"), + NC_("DATE_FUNCDESC_DiffYears", "Type of calculation: Type=0 means the time interval, Type=1 means calendar years.") +}; + +const TranslateId DATE_FUNCDESC_IsLeapYear[] = +{ + NC_("DATE_FUNCDESC_IsLeapYear", "Returns 1 (TRUE) if the date is a day of a leap year, otherwise 0 (FALSE)."), + NC_("DATE_FUNCDESC_IsLeapYear", "Date"), + NC_("DATE_FUNCDESC_IsLeapYear", "Any day in the desired year") +}; + +const TranslateId DATE_FUNCDESC_DaysInMonth[] = +{ + NC_("DATE_FUNCDESC_DaysInMonth", "Returns the number of days of the month in which the date entered occurs"), + NC_("DATE_FUNCDESC_DaysInMonth", "Date"), + NC_("DATE_FUNCDESC_DaysInMonth", "Any day in the desired month") +}; + +const TranslateId DATE_FUNCDESC_DaysInYear[] = +{ + NC_("DATE_FUNCDESC_DaysInYear", "Returns the number of days of the year in which the date entered occurs."), + NC_("DATE_FUNCDESC_DaysInYear", "Date"), + NC_("DATE_FUNCDESC_DaysInYear", "Any day in the desired year") +}; + +const TranslateId DATE_FUNCDESC_WeeksInYear[] = +{ + NC_("DATE_FUNCDESC_WeeksInYear", "Returns the number of weeks of the year in which the date entered occurs"), + NC_("DATE_FUNCDESC_WeeksInYear", "Date"), + NC_("DATE_FUNCDESC_WeeksInYear", "Any day in the desired year") +}; + +const TranslateId DATE_FUNCDESC_Rot13[] = +{ + NC_("DATE_FUNCDESC_Rot13", "Encrypts or decrypts a text using the ROT13 algorithm"), + NC_("DATE_FUNCDESC_Rot13", "Text"), + NC_("DATE_FUNCDESC_Rot13", "Text to be encrypted or text already encrypted") +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/scaddins/inc/pricing.hrc b/scaddins/inc/pricing.hrc new file mode 100644 index 0000000000..c632a4e5b7 --- /dev/null +++ b/scaddins/inc/pricing.hrc @@ -0,0 +1,123 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#include + +#define NC_(Context, String) TranslateId(Context, u8##String) + +// function and parameter description +const TranslateId PRICING_FUNCDESC_OptBarrier[] = +{ + NC_("PRICING_FUNCDESC_OptBarrier", "Pricing of a barrier option"), + NC_("PRICING_FUNCDESC_OptBarrier", "Spot"), + NC_("PRICING_FUNCDESC_OptBarrier", "Price/value of the underlying asset"), + NC_("PRICING_FUNCDESC_OptBarrier", "Volatility"), + NC_("PRICING_FUNCDESC_OptBarrier", "Annual volatility of the underlying asset"), + NC_("PRICING_FUNCDESC_OptBarrier", "Rate"), + NC_("PRICING_FUNCDESC_OptBarrier", "Interest rate (continuously compounded)"), + NC_("PRICING_FUNCDESC_OptBarrier", "Foreign rate"), + NC_("PRICING_FUNCDESC_OptBarrier", "Foreign interest rate (continuously compounded)"), + NC_("PRICING_FUNCDESC_OptBarrier", "Maturity"), + NC_("PRICING_FUNCDESC_OptBarrier", "Time to maturity of the option in years"), + NC_("PRICING_FUNCDESC_OptBarrier", "Strike"), + NC_("PRICING_FUNCDESC_OptBarrier", "Strike level of the option"), + NC_("PRICING_FUNCDESC_OptBarrier", "Lower barrier"), + NC_("PRICING_FUNCDESC_OptBarrier", "Lower barrier (set to 0 for no lower barrier)"), + NC_("PRICING_FUNCDESC_OptBarrier", "Upper barrier"), + NC_("PRICING_FUNCDESC_OptBarrier", "Upper barrier (set to 0 for no upper barrier)"), + NC_("PRICING_FUNCDESC_OptBarrier", "Rebate"), + NC_("PRICING_FUNCDESC_OptBarrier", "Amount of money paid at maturity if barrier was hit"), + NC_("PRICING_FUNCDESC_OptBarrier", "Put/Call"), + NC_("PRICING_FUNCDESC_OptBarrier", "String to define if the option is a (p)ut or a (c)all"), + NC_("PRICING_FUNCDESC_OptBarrier", "Knock-In/Out"), + NC_("PRICING_FUNCDESC_OptBarrier", "String to define if the option is of type knock-(i)n or knock-(o)ut"), + NC_("PRICING_FUNCDESC_OptBarrier", "Barrier type"), + NC_("PRICING_FUNCDESC_OptBarrier", "String to define whether the barrier is observed (c)ontinuously or only at the (e)nd/maturity"), + NC_("PRICING_FUNCDESC_OptBarrier", "Greek"), + NC_("PRICING_FUNCDESC_OptBarrier", "Optional parameter, if left out then the function simply returns the option price; if set, the function returns price sensitivities (Greeks) to one of the input parameters; possible values are (d)elta, (g)amma, (t)heta, v(e)ga, v(o)lga, v(a)nna, (r)ho, rho(f)") +}; + +const TranslateId PRICING_FUNCDESC_OptTouch[] = +{ + NC_("PRICING_FUNCDESC_OptTouch", "Pricing of a touch/no-touch option"), + NC_("PRICING_FUNCDESC_OptTouch", "Spot"), + NC_("PRICING_FUNCDESC_OptTouch", "Price/value of the underlying asset"), + NC_("PRICING_FUNCDESC_OptTouch", "Volatility"), + NC_("PRICING_FUNCDESC_OptTouch", "Annual volatility of the underlying asset"), + NC_("PRICING_FUNCDESC_OptTouch", "Rate"), + NC_("PRICING_FUNCDESC_OptTouch", "Interest rate (continuously compounded)"), + NC_("PRICING_FUNCDESC_OptTouch", "Foreign rate"), + NC_("PRICING_FUNCDESC_OptTouch", "Foreign interest rate (continuously compounded)"), + NC_("PRICING_FUNCDESC_OptTouch", "Maturity"), + NC_("PRICING_FUNCDESC_OptTouch", "Time to maturity of the option in years"), + NC_("PRICING_FUNCDESC_OptTouch", "Lower barrier"), + NC_("PRICING_FUNCDESC_OptTouch", "Lower barrier (set to 0 for no lower barrier)"), + NC_("PRICING_FUNCDESC_OptTouch", "Upper barrier"), + NC_("PRICING_FUNCDESC_OptTouch", "Upper barrier (set to 0 for no upper barrier)"), + NC_("PRICING_FUNCDESC_OptTouch", "Foreign/Domestic"), + NC_("PRICING_FUNCDESC_OptTouch", "String to define if the option pays one unit of (d)omestic currency (cash or nothing) or (f)oreign currency (asset or nothing)"), + NC_("PRICING_FUNCDESC_OptTouch", "Knock-In/Out"), + NC_("PRICING_FUNCDESC_OptTouch", "String to define if the option is of type knock-(i)n (touch) or knock-(o)ut (no-touch)"), + NC_("PRICING_FUNCDESC_OptTouch", "Barrier type"), + NC_("PRICING_FUNCDESC_OptTouch", "String to define whether the barrier is observed (c)ontinuously or only at the (e)nd/maturity"), + NC_("PRICING_FUNCDESC_OptTouch", "Greek"), + NC_("PRICING_FUNCDESC_OptTouch", "Optional parameter, if left out then the function simply returns the option price; if set, the function returns price sensitivities (Greeks) to one of the input parameters; possible values are (d)elta, (g)amma, (t)heta, v(e)ga, v(o)lga, v(a)nna, (r)ho, rho(f)") +}; + +const TranslateId PRICING_FUNCDESC_OptProbHit[] = +{ + NC_("PRICING_FUNCDESC_OptProbHit", "Probability that an asset hits a barrier assuming it follows dS/S = mu dt + vol dW"), + NC_("PRICING_FUNCDESC_OptProbHit", "Spot"), + NC_("PRICING_FUNCDESC_OptProbHit", "Price/value S of the underlying asset"), + NC_("PRICING_FUNCDESC_OptProbHit", "Volatility"), + NC_("PRICING_FUNCDESC_OptProbHit", "Annual volatility of the underlying asset"), + NC_("PRICING_FUNCDESC_OptProbHit", "Drift"), + NC_("PRICING_FUNCDESC_OptProbHit", "Parameter mu in dS/S = mu dt + vol dW"), + NC_("PRICING_FUNCDESC_OptProbHit", "Maturity"), + NC_("PRICING_FUNCDESC_OptProbHit", "Time to maturity"), + NC_("PRICING_FUNCDESC_OptProbHit", "Lower barrier"), + NC_("PRICING_FUNCDESC_OptProbHit", "Lower barrier (set to 0 for no lower barrier)"), + NC_("PRICING_FUNCDESC_OptProbHit", "Upper barrier"), + NC_("PRICING_FUNCDESC_OptProbHit", "Upper barrier (set to 0 for no upper barrier)") +}; + +const TranslateId PRICING_FUNCDESC_OptProbInMoney[] = +{ + NC_("PRICING_FUNCDESC_OptProbInMoney", "Probability that an asset will at maturity end up between two barrier levels, assuming it follows dS/S = mu dt + vol dW (if the last two optional parameters (Strike, PutCall) are specified, the probability of S_T in [Strike, UpperBarrier] for a Call and S_T in [LowerBarrier, Strike] for a Put will be returned)"), + NC_("PRICING_FUNCDESC_OptProbInMoney", "Spot"), + NC_("PRICING_FUNCDESC_OptProbInMoney", "Price/value of the asset"), + NC_("PRICING_FUNCDESC_OptProbInMoney", "Volatility"), + NC_("PRICING_FUNCDESC_OptProbInMoney", "Annual volatility of the asset"), + NC_("PRICING_FUNCDESC_OptProbInMoney", "Drift"), + NC_("PRICING_FUNCDESC_OptProbInMoney", "Parameter mu from dS/S = mu dt + vol dW"), + NC_("PRICING_FUNCDESC_OptProbInMoney", "Maturity"), + NC_("PRICING_FUNCDESC_OptProbInMoney", "Time to maturity in years"), + NC_("PRICING_FUNCDESC_OptProbInMoney", "Lower barrier"), + NC_("PRICING_FUNCDESC_OptProbInMoney", "Lower barrier (set to 0 for no lower barrier)"), + NC_("PRICING_FUNCDESC_OptProbInMoney", "Upper barrier"), + NC_("PRICING_FUNCDESC_OptProbInMoney", "Upper barrier (set to 0 for no upper barrier)"), + NC_("PRICING_FUNCDESC_OptProbInMoney", "Strike"), + NC_("PRICING_FUNCDESC_OptProbInMoney", "Optional strike level"), + NC_("PRICING_FUNCDESC_OptProbInMoney", "Put/Call"), + NC_("PRICING_FUNCDESC_OptProbInMoney", "Optional (p)ut/(c)all indicator") +}; + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/scaddins/inc/strings.hrc b/scaddins/inc/strings.hrc new file mode 100644 index 0000000000..965845d8fb --- /dev/null +++ b/scaddins/inc/strings.hrc @@ -0,0 +1,141 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * This file incorporates work covered by the following license notice: + * + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed + * with this work for additional information regarding copyright + * ownership. The ASF licenses this file to you under the Apache + * License, Version 2.0 (the "License"); you may not use this file + * except in compliance with the License. You may obtain a copy of + * the License at http://www.apache.org/licenses/LICENSE-2.0 . + */ + +#pragma once + +#define NC_(Context, String) TranslateId(Context, u8##String) + +// function names as accessible from cells +#define PRICING_FUNCNAME_OptBarrier NC_("PRICING_FUNCNAME_OptBarrier", "OPT_BARRIER") +#define PRICING_FUNCNAME_OptTouch NC_("PRICING_FUNCNAME_OptTouch", "OPT_TOUCH") +#define PRICING_FUNCNAME_OptProbHit NC_("PRICING_FUNCNAME_OptProbHit", "OPT_PROB_HIT") +#define PRICING_FUNCNAME_OptProbInMoney NC_("PRICING_FUNCNAME_OptProbInMoney", "OPT_PROB_INMONEY") + +#define DATE_FUNCNAME_DiffWeeks NC_("DATE_FUNCNAME_DiffWeeks", "WEEKS") +#define DATE_FUNCNAME_DiffMonths NC_("DATE_FUNCNAME_DiffMonths", "MONTHS") +#define DATE_FUNCNAME_DiffYears NC_("DATE_FUNCNAME_DiffYears", "YEARS") +#define DATE_FUNCNAME_IsLeapYear NC_("DATE_FUNCNAME_IsLeapYear", "ISLEAPYEAR") +#define DATE_FUNCNAME_DaysInMonth NC_("DATE_FUNCNAME_DaysInMonth", "DAYSINMONTH") +#define DATE_FUNCNAME_DaysInYear NC_("DATE_FUNCNAME_DaysInYear", "DAYSINYEAR") +#define DATE_FUNCNAME_WeeksInYear NC_("DATE_FUNCNAME_WeeksInYear", "WEEKSINYEAR") +#define DATE_FUNCNAME_Rot13 NC_("DATE_FUNCNAME_Rot13", "ROT13") + +#define ANALYSIS_FUNCNAME_Workday NC_("ANALYSIS_FUNCNAME_Workday", "WORKDAY") +#define ANALYSIS_FUNCNAME_Yearfrac NC_("ANALYSIS_FUNCNAME_Yearfrac", "YEARFRAC") +#define ANALYSIS_FUNCNAME_Edate NC_("ANALYSIS_FUNCNAME_Edate", "EDATE") +#define ANALYSIS_FUNCNAME_Weeknum NC_("ANALYSIS_FUNCNAME_Weeknum", "WEEKNUM") +#define ANALYSIS_FUNCNAME_Eomonth NC_("ANALYSIS_FUNCNAME_Eomonth", "EOMONTH") +#define ANALYSIS_FUNCNAME_Networkdays NC_("ANALYSIS_FUNCNAME_Networkdays", "NETWORKDAYS") +#define ANALYSIS_FUNCNAME_Amordegrc NC_("ANALYSIS_FUNCNAME_Amordegrc", "AMORDEGRC") +#define ANALYSIS_FUNCNAME_Amorlinc NC_("ANALYSIS_FUNCNAME_Amorlinc", "AMORLINC") +#define ANALYSIS_FUNCNAME_Accrint NC_("ANALYSIS_FUNCNAME_Accrint", "ACCRINT") +#define ANALYSIS_FUNCNAME_Accrintm NC_("ANALYSIS_FUNCNAME_Accrintm", "ACCRINTM") +#define ANALYSIS_FUNCNAME_Received NC_("ANALYSIS_FUNCNAME_Received", "RECEIVED") +#define ANALYSIS_FUNCNAME_Disc NC_("ANALYSIS_FUNCNAME_Disc", "DISC") +#define ANALYSIS_FUNCNAME_Duration NC_("ANALYSIS_FUNCNAME_Duration", "DURATION") +#define ANALYSIS_FUNCNAME_Effect NC_("ANALYSIS_FUNCNAME_Effect", "EFFECT") +#define ANALYSIS_FUNCNAME_Cumprinc NC_("ANALYSIS_FUNCNAME_Cumprinc", "CUMPRINC") +#define ANALYSIS_FUNCNAME_Cumipmt NC_("ANALYSIS_FUNCNAME_Cumipmt", "CUMIPMT") +#define ANALYSIS_FUNCNAME_Price NC_("ANALYSIS_FUNCNAME_Price", "PRICE") +#define ANALYSIS_FUNCNAME_Pricedisc NC_("ANALYSIS_FUNCNAME_Pricedisc", "PRICEDISC") +#define ANALYSIS_FUNCNAME_Pricemat NC_("ANALYSIS_FUNCNAME_Pricemat", "PRICEMAT") +#define ANALYSIS_FUNCNAME_Mduration NC_("ANALYSIS_FUNCNAME_Mduration", "MDURATION") +#define ANALYSIS_FUNCNAME_Nominal NC_("ANALYSIS_FUNCNAME_Nominal", "NOMINAL") +#define ANALYSIS_FUNCNAME_Dollarfr NC_("ANALYSIS_FUNCNAME_Dollarfr", "DOLLARFR") +#define ANALYSIS_FUNCNAME_Dollarde NC_("ANALYSIS_FUNCNAME_Dollarde", "DOLLARDE") +#define ANALYSIS_FUNCNAME_Yield NC_("ANALYSIS_FUNCNAME_Yield", "YIELD") +#define ANALYSIS_FUNCNAME_Yielddisc NC_("ANALYSIS_FUNCNAME_Yielddisc", "YIELDDISC") +#define ANALYSIS_FUNCNAME_Yieldmat NC_("ANALYSIS_FUNCNAME_Yieldmat", "YIELDMAT") +#define ANALYSIS_FUNCNAME_Tbilleq NC_("ANALYSIS_FUNCNAME_Tbilleq", "TBILLEQ") +#define ANALYSIS_FUNCNAME_Tbillprice NC_("ANALYSIS_FUNCNAME_Tbillprice", "TBILLPRICE") +#define ANALYSIS_FUNCNAME_Tbillyield NC_("ANALYSIS_FUNCNAME_Tbillyield", "TBILLYIELD") +#define ANALYSIS_FUNCNAME_Oddfprice NC_("ANALYSIS_FUNCNAME_Oddfprice", "ODDFPRICE") +#define ANALYSIS_FUNCNAME_Oddfyield NC_("ANALYSIS_FUNCNAME_Oddfyield", "ODDFYIELD") +#define ANALYSIS_FUNCNAME_Oddlprice NC_("ANALYSIS_FUNCNAME_Oddlprice", "ODDLPRICE") +#define ANALYSIS_FUNCNAME_Oddlyield NC_("ANALYSIS_FUNCNAME_Oddlyield", "ODDLYIELD") +#define ANALYSIS_FUNCNAME_Xirr NC_("ANALYSIS_FUNCNAME_Xirr", "XIRR") +#define ANALYSIS_FUNCNAME_Xnpv NC_("ANALYSIS_FUNCNAME_Xnpv", "XNPV") +#define ANALYSIS_FUNCNAME_Intrate NC_("ANALYSIS_FUNCNAME_Intrate", "INTRATE") +#define ANALYSIS_FUNCNAME_Coupncd NC_("ANALYSIS_FUNCNAME_Coupncd", "COUPNCD") +#define ANALYSIS_FUNCNAME_Coupdays NC_("ANALYSIS_FUNCNAME_Coupdays", "COUPDAYS") +#define ANALYSIS_FUNCNAME_Coupdaysnc NC_("ANALYSIS_FUNCNAME_Coupdaysnc", "COUPDAYSNC") +#define ANALYSIS_FUNCNAME_Coupdaybs NC_("ANALYSIS_FUNCNAME_Coupdaybs", "COUPDAYBS") +#define ANALYSIS_FUNCNAME_Couppcd NC_("ANALYSIS_FUNCNAME_Couppcd", "COUPPCD") +#define ANALYSIS_FUNCNAME_Coupnum NC_("ANALYSIS_FUNCNAME_Coupnum", "COUPNUM") +#define ANALYSIS_FUNCNAME_Fvschedule NC_("ANALYSIS_FUNCNAME_Fvschedule", "FVSCHEDULE") +#define ANALYSIS_FUNCNAME_Iseven NC_("ANALYSIS_FUNCNAME_Iseven", "ISEVEN") +#define ANALYSIS_FUNCNAME_Isodd NC_("ANALYSIS_FUNCNAME_Isodd", "ISODD") +#define ANALYSIS_FUNCNAME_Gcd NC_("ANALYSIS_FUNCNAME_Gcd", "GCD") +#define ANALYSIS_FUNCNAME_Lcm NC_("ANALYSIS_FUNCNAME_Lcm", "LCM") +#define ANALYSIS_FUNCNAME_Multinomial NC_("ANALYSIS_FUNCNAME_Multinomial", "MULTINOMIAL") +#define ANALYSIS_FUNCNAME_Seriessum NC_("ANALYSIS_FUNCNAME_Seriessum", "SERIESSUM") +#define ANALYSIS_FUNCNAME_Quotient NC_("ANALYSIS_FUNCNAME_Quotient", "QUOTIENT") +#define ANALYSIS_FUNCNAME_Mround NC_("ANALYSIS_FUNCNAME_Mround", "MROUND") +#define ANALYSIS_FUNCNAME_Sqrtpi NC_("ANALYSIS_FUNCNAME_Sqrtpi", "SQRTPI") +#define ANALYSIS_FUNCNAME_Randbetween NC_("ANALYSIS_FUNCNAME_Randbetween", "RANDBETWEEN") +#define ANALYSIS_FUNCNAME_Besseli NC_("ANALYSIS_FUNCNAME_Besseli", "BESSELI") +#define ANALYSIS_FUNCNAME_Besselj NC_("ANALYSIS_FUNCNAME_Besselj", "BESSELJ") +#define ANALYSIS_FUNCNAME_Besselk NC_("ANALYSIS_FUNCNAME_Besselk", "BESSELK") +#define ANALYSIS_FUNCNAME_Bessely NC_("ANALYSIS_FUNCNAME_Bessely", "BESSELY") +#define ANALYSIS_FUNCNAME_Bin2Dec NC_("ANALYSIS_FUNCNAME_Bin2Dec", "BIN2DEC") +#define ANALYSIS_FUNCNAME_Bin2Hex NC_("ANALYSIS_FUNCNAME_Bin2Hex", "BIN2HEX") +#define ANALYSIS_FUNCNAME_Bin2Oct NC_("ANALYSIS_FUNCNAME_Bin2Oct", "BIN2OCT") +#define ANALYSIS_FUNCNAME_Delta NC_("ANALYSIS_FUNCNAME_Delta", "DELTA") +#define ANALYSIS_FUNCNAME_Dec2Bin NC_("ANALYSIS_FUNCNAME_Dec2Bin", "DEC2BIN") +#define ANALYSIS_FUNCNAME_Dec2Hex NC_("ANALYSIS_FUNCNAME_Dec2Hex", "DEC2HEX") +#define ANALYSIS_FUNCNAME_Dec2Oct NC_("ANALYSIS_FUNCNAME_Dec2Oct", "DEC2OCT") +#define ANALYSIS_FUNCNAME_Erf NC_("ANALYSIS_FUNCNAME_Erf", "ERF") +#define ANALYSIS_FUNCNAME_Erfc NC_("ANALYSIS_FUNCNAME_Erfc", "ERFC") +#define ANALYSIS_FUNCNAME_Gestep NC_("ANALYSIS_FUNCNAME_Gestep", "GESTEP") +#define ANALYSIS_FUNCNAME_Hex2Bin NC_("ANALYSIS_FUNCNAME_Hex2Bin", "HEX2BIN") +#define ANALYSIS_FUNCNAME_Hex2Dec NC_("ANALYSIS_FUNCNAME_Hex2Dec", "HEX2DEC") +#define ANALYSIS_FUNCNAME_Hex2Oct NC_("ANALYSIS_FUNCNAME_Hex2Oct", "HEX2OCT") +#define ANALYSIS_FUNCNAME_Imabs NC_("ANALYSIS_FUNCNAME_Imabs", "IMABS") +#define ANALYSIS_FUNCNAME_Imaginary NC_("ANALYSIS_FUNCNAME_Imaginary", "IMAGINARY") +#define ANALYSIS_FUNCNAME_Impower NC_("ANALYSIS_FUNCNAME_Impower", "IMPOWER") +#define ANALYSIS_FUNCNAME_Imargument NC_("ANALYSIS_FUNCNAME_Imargument", "IMARGUMENT") +#define ANALYSIS_FUNCNAME_Imcos NC_("ANALYSIS_FUNCNAME_Imcos", "IMCOS") +#define ANALYSIS_FUNCNAME_Imdiv NC_("ANALYSIS_FUNCNAME_Imdiv", "IMDIV") +#define ANALYSIS_FUNCNAME_Imexp NC_("ANALYSIS_FUNCNAME_Imexp", "IMEXP") +#define ANALYSIS_FUNCNAME_Imconjugate NC_("ANALYSIS_FUNCNAME_Imconjugate", "IMCONJUGATE") +#define ANALYSIS_FUNCNAME_Imln NC_("ANALYSIS_FUNCNAME_Imln", "IMLN") +#define ANALYSIS_FUNCNAME_Imlog10 NC_("ANALYSIS_FUNCNAME_Imlog10", "IMLOG10") +#define ANALYSIS_FUNCNAME_Imlog2 NC_("ANALYSIS_FUNCNAME_Imlog2", "IMLOG2") +#define ANALYSIS_FUNCNAME_Improduct NC_("ANALYSIS_FUNCNAME_Improduct", "IMPRODUCT") +#define ANALYSIS_FUNCNAME_Imreal NC_("ANALYSIS_FUNCNAME_Imreal", "IMREAL") +#define ANALYSIS_FUNCNAME_Imsin NC_("ANALYSIS_FUNCNAME_Imsin", "IMSIN") +#define ANALYSIS_FUNCNAME_Imsub NC_("ANALYSIS_FUNCNAME_Imsub", "IMSUB") +#define ANALYSIS_FUNCNAME_Imsum NC_("ANALYSIS_FUNCNAME_Imsum", "IMSUM") +#define ANALYSIS_FUNCNAME_Imsqrt NC_("ANALYSIS_FUNCNAME_Imsqrt", "IMSQRT") +#define ANALYSIS_FUNCNAME_Imtan NC_("ANALYSIS_FUNCNAME_Imtan", "IMTAN") +#define ANALYSIS_FUNCNAME_Imsec NC_("ANALYSIS_FUNCNAME_Imsec", "IMSEC") +#define ANALYSIS_FUNCNAME_Imcsc NC_("ANALYSIS_FUNCNAME_Imcsc", "IMCSC") +#define ANALYSIS_FUNCNAME_Imcot NC_("ANALYSIS_FUNCNAME_Imcot", "IMCOT") +#define ANALYSIS_FUNCNAME_Imsinh NC_("ANALYSIS_FUNCNAME_Imsinh", "IMSINH") +#define ANALYSIS_FUNCNAME_Imcosh NC_("ANALYSIS_FUNCNAME_Imcosh", "IMCOSH") +#define ANALYSIS_FUNCNAME_Imsech NC_("ANALYSIS_FUNCNAME_Imsech", "IMSECH") +#define ANALYSIS_FUNCNAME_Imcsch NC_("ANALYSIS_FUNCNAME_Imcsch", "IMCSCH") +#define ANALYSIS_FUNCNAME_Complex NC_("ANALYSIS_FUNCNAME_Complex", "COMPLEX") +#define ANALYSIS_FUNCNAME_Oct2Bin NC_("ANALYSIS_FUNCNAME_Oct2Bin", "OCT2BIN") +#define ANALYSIS_FUNCNAME_Oct2Dec NC_("ANALYSIS_FUNCNAME_Oct2Dec", "OCT2DEC") +#define ANALYSIS_FUNCNAME_Oct2Hex NC_("ANALYSIS_FUNCNAME_Oct2Hex", "OCT2HEX") +#define ANALYSIS_FUNCNAME_Convert NC_("ANALYSIS_FUNCNAME_Convert", "CONVERT") +#define ANALYSIS_FUNCNAME_Factdouble NC_("ANALYSIS_FUNCNAME_Factdouble", "FACTDOUBLE") + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ -- cgit v1.2.3