Latex3: \tl_if_integer परिभाषित करें:n

यहां बेहतर:

\prg_new_conditional:Npnn \tl_if_integer:n #1 { p, T, F, TF }
{
  \tl_if_blank:nTF{#1}
    {
      \prg_return_false:
    }
    {
      \tl_if_blank:oTF { \__int_to_roman:w -0#1 }
      {
        \prg_return_true:
      }
      {
        \prg_return_false:
      }
    }
}

नाम अजीब लगता है: यह वास्तव में एक पूर्णांक की जांच नहीं करता है (उदाहरण के लिए -5 एक पूर्णांक है लेकिन झूठा रिटर्न देता है, +7 झूठा भी लौटाता है)। यह एक परीक्षण की तरह लगता है यदि केवल अंक मौजूद हैं।

@zauguin नाम के लिए ठीक है लेकिन फ़ंक्शन उपयोगी है, और यह जांचने के लिए टेक्स बुक के पुराने टिक से मेल खाता है कि क्या अंक। मैं मानता हूं कि रेगेक्स का उपयोग करके पूर्णांक लागू किया जा सकता है लेकिन यह धीमा होगा

आपकी टिप्पणियों से बेहतर हुआ:

\prg_new_conditional:Npnn \tl_if_digit:n #1 { p, T, F, TF }
{
  \tl_if_blank:nTF{#1}
    {
      \prg_return_false:
    }
    {
      \tl_if_blank:oTF { \__int_to_roman:w -0#1 }
      {
        \prg_return_true:
      }
      {
        \prg_return_false:
      }
    }
  }
\prg_generate_conditional_variant:Nnn \tl_if_digit:n { o } { p, T, F, TF }
\prg_new_conditional:Npnn \__tl_if_integer:n #1 { p, T, F, TF }
{
    \exp_args:No\str_if_eq:onTF{\tl_head:n{#1}}{+}
    {
      \exp_args:No\tl_if_digit:oTF{\tl_tail:n{#1}}
      {
        \prg_return_true:
      }
      {
        \prg_return_false:
      }
    }
    {
      \exp_args:No\str_if_eq:onTF{\tl_head:n{#1}}{-}
      {
        \exp_args:No\tl_if_digit:oTF{\tl_tail:n{#1}}
        {
          \prg_return_true:
        }
        {
          \prg_return_false:
        }
      }
      {
        \prg_return_false:
      }
    }
}
\prg_new_conditional:Npnn \tl_if_integer:n #1 { p, T, F, TF }
{
  % fast path
  \tl_if_digit:nTF{#1}
  {
    \prg_return_true:
  }
  {
    % slow path
    \__tl_if_integer:nTF{#1}
    {
      \prg_return_true:
    }
    {
      \prg_return_false:
    }
  }
}

@ बास्टियन-रौकेरीज़ टीएक्स एक संख्या के सामने कई संकेत स्वीकार करता है, इसलिए आपका परीक्षण आमतौर पर पर्याप्त होता है लेकिन हमेशा नहीं। क्या इसे लागू किया जाना चाहिए, यह इस तरह के कई संकेतों की अनुमति दे सकता है:

\ExplSyntaxOn
\prg_new_conditional:Npnn \str_if_integer:n #1 { p, T, F, TF }
  { \exp_after:wN \__str_if_integer_sign:N \tl_to_str:n {#1} \scan_stop: }
\cs_new:Npn \__str_if_integer_sign:N #1
  {
    \if:w $
        \if_meaning:w - #1 F \fi:
        \if_meaning:w + #1 F \fi: $
      \exp_after:wN \__str_if_integer_digits:w \exp_after:wN #1
    \else:
      \exp_after:wN \__str_if_integer_sign:N
    \fi:
  }
\cs_new:Npn \__str_if_integer_digits:w #1 \scan_stop:
  {
    \tl_if_blank:nTF {#1}
      { \prg_return_false: }
      {
        \tl_if_blank:oTF { \__int_to_roman:w -0#1 }
          { \prg_return_true: }
          { \prg_return_false: }
      }
  }

\cs_new:Npn \test #1
  { \typeout { #1: \str_if_integer:nTF {#1} { INT } { NOT } } }

\test {   }
\test { ~ }
\test { 1 }
\test { - }
\test { -1 }
\test { +1 }
\test { +-+-+-1 }

\stop

तर्क में टोकन के विस्तार को रोकने के लिए परीक्षण str है। मेरा और आपका कार्यान्वयन दोनों संकेत का विस्तार नहीं करते हैं, लेकिन अंकों का विस्तार करते हैं \romannumeral । एक tl संस्करण को संभवतः आवश्यकतानुसार सब कुछ विस्तारित करना होगा।

मैं सहमत हूं कि \str_if_integer:nTF प्रदान करना समझदारी होगी, लेकिन यह अभी तक स्पष्ट नहीं है कि अनुमत पूर्णांक क्या होने चाहिए। संभावित रूप से संकेतों के बीच रिक्त स्थान की अनुमति दी जानी चाहिए, लेकिन एक पूर्णांक के भीतर नहीं क्योंकि टीएक्स इसे अस्वीकार करता है?

\romannumeral पर आधारित कोड अंकों की लंबी स्ट्रिंग के लिए "संख्या बहुत बड़ी" त्रुटि के साथ विराम देता है। संभवतः हमें एक धीमी प्रक्रिया की आवश्यकता होती है जो एक समय में केवल कुछ अंकों को पकड़ लेती है, लेकिन फिर अंकों के बीच रिक्त स्थान का पता लगाने में परेशानी होती है।

एक विकल्प/जोड़ \str_to_integer:nF होगा जो स्ट्रिंग को स्वच्छ करता है यदि यह एक पूर्णांक की तरह "पर्याप्त" दिखता है (हम कुछ हद तक ढीला होने का फैसला कर सकते हैं (लेकिन अच्छी तरह से प्रलेखित)) और अन्यथा इनपुट स्ट्रीम में अपना दूसरा तर्क छोड़ देता है।

@blefloch \romannumeral की प्रलेखित सीमा क्या है?

@ bastien-roucaries सबसे बड़ा पूर्णांक TeX संभाल सकता है: 2³¹−1 = 2147483647।

@PhelypeOleinik ऐसा लगता है कि @blefloch का अर्थ है कि +-+-+-+-+-+-+-+-+-+-+-+-+000000000000000000000000000000000000000000000000000000000 \romannumeral तोड़ सकता है ...

तो अधिकतम स्ट्रिंग आकार क्या है?

@ Bastien-roucaries \romannumeral केवल एक गैर-शून्य संख्या के लिए "संख्या बहुत बड़ी" के साथ टूटता है। जब तक परिणामी पूर्णांक [−2³¹−1, 2³¹−1] श्रेणी के भीतर है, तब तक TeX शून्य की एक मनमाने ढंग से लंबी स्ट्रिंग ले सकता है।

@ bastien-roucaries @blefloch मैं हेक्साडेसिमल या ऑक्टल प्रारूप में पूर्णांक नहीं भूलूंगा। और

-`a

एक पूर्णांक भी है।

l3bitset \__bitset_test_digits:nTF में अंकों के लिए एक आंतरिक परीक्षण है। यह संकेतों को संभालता नहीं है क्योंकि यह अनावश्यक था लेकिन इसे पूर्णांक अभिव्यक्तियों को संभालना चाहिए।

जैसा कि @ eg9 ने अभी संकेत दिया है, यहाँ वास्तविक उपयोग का मामला क्या है? क्या यह एक उपयोगकर्ता स्तर का दस्तावेज़ है जो अंकों की एक स्ट्रिंग के लिए जाँच करता है, या एक जाँच है कि स्ट्रिंग एक expl3 पूर्णांक फ़ंक्शन के लिए एक मान्य इनपुट है। उत्तरार्द्ध एक expl3 संदर्भ में अधिक उपयोगी लगता है, और मूल रूप से इसका मतलब है कि \numexpr#1 के बाद कुछ भी नहीं बचा है, इसलिए अंकों के शाब्दिक तारों की धीमी जांच की आवश्यकता नहीं होगी।

@davidcarlisle यह बग पहले मामले के बारे में है, लेकिन मैं दूसरा उपयोग करना चाहूंगा

मुझे नहीं लगता कि मैं L3 प्रोग्रामिंग परत को यादृच्छिक एक्सटेंशन के साथ विस्तारित करने के पक्ष में हूं जो (संभवतः) विशेष परिस्थितियों में उपयोगी हैं लेकिन नियमित रूप से आवश्यक उपयोग मामलों को स्पष्ट नहीं करते हैं। मेरे लिए यह एक ऐसा उदाहरण है। अगर हम उससे शुरू करते हैं, तो हम कहां खत्म होते हैं? तब हमें कितने विशेष "क्या यह कुछ X है" का समर्थन करना चाहिए? इस पर मेरा वोट नहीं है; मूल भाषा के लिए नहीं।

@FrankMittelbach यह जानना कि हम कुछ गणना कर सकते हैं या नहीं TL पर उपयोगी है। दूसरा रेगेक्स का उपयोग करके किया जा सकता है, लेकिन इस नुकसान के साथ कि यह विस्तृत संदर्भ में काम नहीं करता है (और मुझे इस परीक्षण को विस्तृत संदर्भ में काम करने की आवश्यकता है)

इसमें कोई शक नहीं। लेकिन क्या यह मूल भाषा में शामिल होने की गारंटी देने के लिए पर्याप्त उपयोगी है (या वास्तव में जरूरत पड़ने पर केवल कुछ पैकेज कोड के हिस्से के रूप में प्रदान किया जाना है)? यहां मेरे लिए यही सवाल है और अब तक मैंने वास्तव में ऐसे तर्क नहीं देखे हैं जो इसे शामिल करने के पक्ष में हों।

आप "क्या यह एक आयाम है", "क्या यह स्किप के रूप में है", "क्या यह सिर्फ अक्षर है", "क्या इसमें गैर-असीसी वर्ण हैं", "क्या यह एक तिथि प्रारूप है", और, के लिए एक ही प्रश्न पूछ सकते हैं। और ... संभावनाएं काफी खुली हैं और उनमें से अधिकतर के लिए आप एक या दो उपयोग केस बना सकते हैं। लेकिन 99% बार वे वहीं बैठेंगे और जगह लेंगे। और जबकि अंतरिक्ष एक प्रीमियम नहीं है जैसा कि अतीत में था, यह अभी भी कोर सिस्टम की जटिलता और रखरखाव को जोड़ता है। तो फिर, क्या यह कार्यक्षमता व्यापक और बार-बार उपयोग के साथ है? यदि हां, और मैं इसके लिए ठोस तर्क सुनता हूं तो इसे शामिल करने के लिए एक उम्मीदवार माना जा सकता है। यदि नहीं, तो इसे उस कोड के हिस्से के रूप में लागू किया जाना चाहिए जिसे इसकी आवश्यकता है।

@FrankMittelbach समस्या यहाँ biblatex के लिए विशिष्ट है। हमें परीक्षण करने की आवश्यकता है कि क्या कुछ फ़ील्ड एक पूर्णांक है (पृष्ठ संख्या के बारे में सोचें) और इसलिए विस्तार योग्य संदर्भ में उस पर कुछ अंकगणित करें।
ठीक है ती विशिष्ट है लेकिन मुश्किल हिस्सा विस्तार योग्य सामान है।
हो सकता है कि इस तरह के परीक्षण को केवल प्रलेखित किया जाना चाहिए। दस्तावेज़ पढ़ना मुझे नहीं पता कि कैसे करना है, और इसके अलावा biblatex कोर सोचता है कि यदि एक पूर्णांक एक टोकन है तो परीक्षण करना (संगत का विस्तार करना) संभव नहीं है।

समाधान रेगेक्स विस्तार योग्य प्रस्तुत करना हो सकता है (मुझे लगता है कि यह अच्छा होगा)

मुझे गलत मत समझो, मैं इसके खिलाफ बिल्कुल भी नहीं हूं कि हम इस काम को करने के लिए बाइबिलटेक्स की तरफ से आपकी मदद करते हैं, और यह अच्छी तरह से हो सकता है कि कोर पर हम कुछ कार्यक्षमता खो रहे हैं जो कि इसका समर्थन करने के लिए मूल में होना चाहिए। मेरा मुद्दा यह है कि कोर को खुद को "सामान्य" जरूरतों तक सीमित रखना चाहिए और विशेष कोड लिखने के लिए बुनियादी सामान्य आधार प्रदान करना चाहिए, लेकिन सभी प्रकार के एक्सटेंशन प्रदान नहीं करना चाहिए जो कि बहुत ही कम उपयोग किए जाते हैं (उदाहरण के लिए इस मामले में जब biblatex उपयोग नहीं होता है)। अन्यथा हम अंततः आदेशों के एक बहुत फूले हुए सेट के साथ समाप्त हो जाएंगे।

चीजों को विस्तार से काम करना आम तौर पर एक भारी कीमत के साथ आता है, या तो सीमित कार्यक्षमता या गति की हानि या दोनों में। इसलिए मुझे संदेह है कि रेगेक्स को विस्तार योग्य बनाने का प्रयास करना एक अच्छा विचार है, लेकिन मैंने उस पर @blefloch टिप्पणी करने दी।

लेकिन अपने उपयोग के मामले को अधिक विस्तार से जाने बिना: कहीं आपके क्षेत्र स्थापित किए जा रहे हैं और यह विस्तार से नहीं किया गया है क्योंकि इसमें असाइनमेंट की आवश्यकता होगी, इसलिए उस स्तर पर आप यह निर्धारित कर सकते हैं कि आपके पास एक पूर्णांक या कुछ और है और उस तथ्य को रिकॉर्ड करें जो कर सकता है फिर विस्तार से उपयोग किया जाए (सुनिश्चित नहीं है कि यह मदद करता है या संभव है, लेकिन यह बार-बार क्षेत्र का परीक्षण करने से बच जाएगा)।