blocks|key|2101978|text|这可能不完全符合您的要求，因为它使用外接8!:0格式将无穷大更改为您想要的任何内容(包括“错误”)。当然，它看起来只是一个错误；它真正要做的是用'_'替换'error'，所以它可能不是您想要的。结果也是盒式字符串，可能不适合您的约束。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2101979|+++inf=:+'d<error>'&(8!:0)
+++%25+i.6
_+1+0.5+0.333333+0.25+0.2
+++inf+%25+i.6
┌─────┬───────────┬───────────┬───────────┬───────────┬───────────┐
│error│1.000000000│0.500000000│0.333333333│0.250000000│0.200000000│
└─────┴───────────┴───────────┴───────────┴───────────┴───────────┘|code-block|syntax|javascript|2101980|更多信息可以在J字典的8!：条目中找到外国连词。http://www.jsoftware.com/help/dictionary/dx008.htm|2101981|由于您的注释表明您确实想要触发错误，所以可以使用断言。关键字，用于在显示前测试“_”的结果，但它是以动词为基础的，并且没有我所知道的全局设置。|2101982|+++9!:35+[+1+NB.+to+set+the+assert.+flag+on
+++test+=:+3+:+0
​assert.+_~:%25y++NB.+to+see+if+_+shows+up+in+the+result+of+%25y
​%25y
​)
+++test+1+%2B+i.5
1+0.5+0.333333+0.25+0.2
+++test++i.5
%7Cassertion+failure:+test
%7C+++_~:%25y|2101983|entityMap|0|LINK|mutability|MUTABLE|url|http://www.jsoftware.com/help/dictionary/dx008.htm^0|K|4|20|3|25|7|0|0|O|1E|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|D|@$9|17|A|18|1|19]]|E|$]]|$1|M|3|N|5|6|7|1A|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|Q|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

This may not do exactly what you want because it uses the format foreign conjunction <code>8!:0</code> to change infinity to whatever you would like (including 'error'). Of course, it just looks like an error; what it is really doing is replacing <code>'_'</code> with <code>'error'</code> so it may not be what you want. The results are boxed strings as well, which may not fit your constraints.

<pre><code> inf=: 'd&lt;error&gt;'&amp;(8!:0)
 % i.6
_ 1 0.5 0.333333 0.25 0.2
 inf % i.6
┌─────┬───────────┬───────────┬───────────┬───────────┬───────────┐
│error│1.000000000│0.500000000│0.333333333│0.250000000│0.200000000│
└─────┴───────────┴───────────┴───────────┴───────────┴───────────┘
</code></pre>

More information can be found in the 8!: entry for foreign conjunctions in the J dictionary. <a href="http://www.jsoftware.com/help/dictionary/dx008.htm" rel="nofollow">http://www.jsoftware.com/help/dictionary/dx008.htm</a>

Since your comment indicates you do actually want to trigger the error, you could use the assert. keyword to test the result for '_' before display but it is on a verb by verb basis and there is not a global setting that I know.

<pre><code> 9!:35 [ 1 NB. to set the assert. flag on
 test =: 3 : 0
​assert. _~:%y NB. to see if _ shows up in the result of %y
​%y
​)
 test 1 + i.5
1 0.5 0.333333 0.25 0.2
 test i.5
|assertion failure: test
| _~:%y
</code></pre>

blocks|key|2102021|text|要完成您想要做的事情，最简单的方法是用assert.重新定义每个您想要使用这个行为的原语。这可能会对性能产生影响。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2102022|+++SafeFactorial+=:+3+:+0
p+=.+!+y
assert.+p+<+_
assert.+p+>+__
p
)
+++SafeFactorial+5
120
+++SafeFactorial+50
3.04141e64
+++SafeFactorial+500
%7Cassertion+failure:+SafeFactorial
%7C+++p<_|code-block|syntax|javascript|2102023|评论中有一个重要的警告：|2102024|J是一种面向数组的语言，它是一种罕见的情况，在这种情况下，只对单个数字进行操作。通常，阶乘之类的函数的输入是多个数字的数组，所以如果您设计一个函数来抛出这样的错误，它将完全阻止您获得任何结果，甚至如果一个原子是坏的，结果也是正确的。|blockquote|2102025|换句话说，当对数组进行操作时，无限结果通常是一种理想的行为。在引入额外的故障点之前，您应该仔细考虑。|2102026|entityMap^0|J|7|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|W|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|X|8|@]|D|@]|E|$]]|$1|M|3|N|5|O|7|Y|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|Z|8|@]|D|@]|E|$]]|$1|R|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|S|$]]

The most straightforward way to do what you're trying to do is redefine each primitive from which you want this behavior with an <code>assert.</code>. This will probably have performance implications.

<pre><code> SafeFactorial =: 3 : 0
p =. ! y
assert. p &lt; _
assert. p &gt; __
p
)
 SafeFactorial 5
120
 SafeFactorial 50
3.04141e64
 SafeFactorial 500
|assertion failure: SafeFactorial
| p&lt;_
</code></pre>

An important caveat from the comments:

<blockquote>
 J is an array oriented language, and it's a rare circumstance where
 one is operating only on a single number. Typically the input to
 functions like factorial are arrays of multiple numbers, and so if you
 design a function to throw an error like this, it will preclude you
 from getting any results at all, even correct results if one atom is
 bad.
</blockquote>

Put a different way, the infinite result is often a desirable behavior when operating on arrays. You should consider carefully before introducing additional failure points.

blocks|key|2102052|text|我的目标是得到数学上正确的结果。我突然得出结论，我应该尽早失败，而不是像在Java中那样给出不正确的结果。我所要求的都是戴恩和埃尔斯韦克斯所涵盖的，他们应该得到所有的赞扬。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2102053|不过，有些观察可能有助于其他人进入J思维：|2102054|首先，我已经知道了扩展的精度文本，并意识到动词x:将整数转换为扩展精度。如果我想要数学上正确的结果，在默认情况下，我应该养成使用这些东西的习惯。|offset|length|style|CODE|2102055|其次，我已经观察到动词，如并元i.，它返回超大型的结果而不是失败。这在J中很常见，我应该学会过滤我不想要的结果，而不是让我的程序总是出错。|2102056|entityMap^0|0|0|N|2|0|F|2|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@$F|Q|G|R|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@$F|T|G|U|H|I]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|M|$]]

My goal was to get mathematically correct results. I jumped to the conclusion that I should fail early instead of giving incorrect results as I would in Java. What I exactly asked for was covered by Dane and Eelvex and they deserve all credit for that.

Some observations though that might help others get in the J mindset:

Firstly, I was already aware of extended precision literals and became aware of the verb <code>x:</code> that converts integers to extended precision. If I want mathematically correct results by default I should get in the habit of using these things.

Secondly, I had already observed verbs like e.g. dyadic <code>i.</code> which return oversized results instead of failing. This is common in J and I should learn to filter results that I don't want instead of making my programs give errors all the time.

If you instruct J to calculate a large result on a default precision noun, you quickly run into cases where it says the result is infinity <code>_</code>. This is jarring because of what infinity means mathematically. 

How can I instruct J to give errors instead of infinity when standard precision is exceeded? Can I set this a default in my J installation?

e.g.

<pre><code> !1000x NB. Extended precision gives large finite result.
4023872600770937735437024339230039857193748642107146325437999104299385123986290205920442084869694048004799886101971960586316668729948085589013238296699445909974245040870737599188236277271887325197795059509952761208749754624970436014182780946464962910563938...

 !1000 NB. Default precision claims infinity. I'd generally prefer an error.
_
</code></pre>

How to force J to give error instead of incorrectly returning infinity?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

如果您指示J在默认精度名词上计算一个大的结果，那么您很快就会遇到这样的情况，即结果是无穷大的_。这是令人不快的，因为无穷大在数学上意味着什么。当超过标准精度时，我如何指示J给出错误而不是无穷大？我可以在我的J安装中设置这一默认设置吗？例如：   !1000x  NB. Extended precision gives ...

问如何强迫J给出错误而不是错误地返回无穷大？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何强迫J给出错误而不是错误地返回无穷大？EN