标签: infinite

我正在寻找创建滚动功能的资源,例如在这些网站上找到的功能:
Outpost Journal
Unfold

滚动条点击页面底部后,我希望它循环回到顶部.我对无限卷轴很熟悉,这不是我想要的.我还发现脚本会将相同的内容写入/添加到页面底部,但没有一个循环回到页面顶部.

在我的活动中,我使用ViewPager向左/向右滑动并相应地显示月视图.我将月份和年份值传递onCreate给PagerAdapter:

private static int NUM_AWESOME_VIEWS = 3;

viewPager = (ViewPager) v.findViewById(R.id.pager);
cAdapter = new CalendarPagerAdapter(this.getActivity().getApplicationContext(), date_value, fragmentManager, month, year);
viewPager.setAdapter(cAdapter);
viewPager.setOffscreenPageLimit(3);

日历从11月开始,然后滚动到1月.我希望日历能够向前和向后显示无限的视图.

PagerAdapter:

public CalendarPagerAdapter(Context context, int dv, FragmentManager fm, int month, int year){
    this.context = context;
    this.dv = dv;
    this.fm = fm;
    this.month = month;
    this.year = year;

}

public Object instantiateItem(View collection, int position) {
    Log.d("Object", "Instantiated");
    LayoutInflater inflater = (LayoutInflater) collection.getContext()
                     .getSystemService(Context.LAYOUT_INFLATER_SERVICE);

    View v =  inflater.inflate(R.layout.simple_calendar_view, null);

    _calendar.set(Calendar.MONTH, month);
    _calendar.set(Calendar.YEAR, year);

    month = _calendar.get(Calendar.MONTH) + …

我想要一个无限的非严格系列x ₁,x ₂,x ₃ ...我可以一次使用一个元素,而不是记住结果以保持我的内存使用不变.为了特殊性,我们假设它是一系列整数(例如自然数,奇数,素数),尽管这个问题可能适用于更一般的数据类型.

使用无限列表的最简单方法是使用Scala的Stream对象.一个常见的习惯用法是编写一个返回a的函数Stream,使用#::运算符为该系列添加一个术语,然后递归调用自身.例如,给定起始值和后继函数,以下内容生成无限的整数流.

  def infiniteList(n: Int, f: Int => Int): Stream[Int] = {
      n #:: infiniteList(f(n), f)
  }
  infiniteList(2, _*2+3).take(10) print
  // returns 2, 7, 17, 37, 77, 157, 317, 637, 1277, 2557, empty

(我意识到上面的内容相当于库调用Stream.iterate(2)(_*2+3).我在这里写了这个无限Stream成语的例子.)

但是,流会记住它们的结果,使它们的内存要求不是恒定的,并且可能非常大.该文件指出,如果你不坚持到的头部记忆化避免Stream,但在实践中,这可能会非常棘手.我可以实现无限列表代码,其中我不认为我持有任何流头,但如果它仍然有无限的内存要求,我必须弄清楚问题是我是否以某种方式处理我的流这会导致记忆,或者是否是其他东西.这可能是一个困难的调试任务,并且有代码味道,因为我试图欺骗一个明确的memoized数据结构来返回一个非memoized结果.

我想要的是具有Stream期望语义而没有记忆的东西.Scala中似乎不存在这样的对象.我一直在尝试使用迭代器来实现无限数字系列,但是当你开始想要对它们进行理解操作时,迭代器的可变性使得这很棘手.我也试着从头开始写我自己的代码,但目前还不清楚我应该在哪里开始(我继承Traversable？),或如何避免在重新实现的功能map,fold等等.

有人有一个很好的示例Scala代码的非严格,不可变,非记忆无限列表的实现？

更一般地说,我理解可遍历,可迭代,序列,流和视图的语义,但事实上,我发现这个问题非常令人烦恼,这让我觉得我误解了一些东西.在我看来,非严格性和非记忆性是完全正交的属性,但Scala似乎做出了一个设计决定,将它们统一起来Stream并且没有简单的方法将它们分开.这是对Scala的疏忽吗,还是我忽略的非严格和非记忆之间有一些深层的联系？

我意识到这个问题相当抽象.这是一些将其与特定问题联系起来的附加上下文.

我正在实施一个素数发生器的过程中遇到这个问题,如Meissa O'Niell的论文" Eratosthenes的真正的筛子 "所描述的那样,很难给出一个简单的例子,说明一个Iterator …

我正在尝试将无限滚动与我当前使用一种jQuery Masonry的网站结合起来.我试图理解javascript(和一般的html)的语言和基本功能,但它可能是非常压倒性的.我也看到了向网页添加无限滚动的不同方法,包括使用php.基本上,对于我的网站最好的方法,我没有方向感.任何提示或帮助非常感谢.我为这个话题缺乏知识而道歉,但我觉得这完全超出了我的想法...... @ _ @

这是我的网站.这是我个人的艺术品收藏:http: //themptyrm.com

有谁知道Python中是否存在无限可嵌套字典的标准类？

我发现自己重复这种模式:

d = defaultdict(lambda: defaultdict(lambda: defaultdict(int)))
d['abc']['def']['xyz'] += 1

如果我想添加"另一层"(例如d['abc']['def']['xyz']['wrt']),我必须定义另一个defaultdicts嵌套.

为了概括这种模式,我编写了一个简单的类来覆盖__getitem__自动创建下一个嵌套字典.

例如

d = InfiniteDict(('count',0),('total',0))
d['abc']['def']['xyz'].count += 0.24
d['abc']['def']['xyz'].total += 1
d['abc']['def']['xyz']['wrt'].count += 0.143
d['abc']['def']['xyz']['wrt'].total += 1

但是,有没有人知道这个想法的预先实现？我试过谷歌搜索,但我不确定这会被称为什么.

我在Windows 10上使用Visual Studio 2015,我还是一个新的编码器,我刚刚开始学习C#,当我在这个过程中,我发现了Math课程并且只是玩得开心,直到控制台输出:"∞"

这是一个控制台应用程序

这是代码:

var k = Math.Sqrt((Math.Pow(Math.Exp(5), Math.E)));
var l = Math.Sqrt((Math.Pow(Math.PI, Math.E)));
Console.WriteLine("number 1 : " + k);
Console.WriteLine("number 2 : " + l);
Console.ReadKey();
var subject = Math.Pow(Math.Sqrt((Math.Pow(Math.PI, Math.E))), Math.Sqrt((Math.Pow(Math.Exp(5), Math.E))));
Console.WriteLine(k + " ^ " + l + " = " + subject);
Console.ReadKey();
//output  :
/*number 1 : 893.998923601492
 number 2 : 4.73910938029088
 893.998923601492 ^ 4.73910938029088 = ?*/

为什么会这样？使用普通计算器,结果是:96985953901866.7

我知道无意识的无限循环通常会导致高CPU使用率.但是,我不太明白为什么.任何人都可以向我解释一下吗？

对于那些有可疑头脑的人来说,这不是家庭作业,只是好奇.

给定一个有限的字母表,是否有可能构建一个由反向词汇顺序的字母表组成的无限长单词列表？

即给出字母表 "ab"

是否可以构建列表:

["aaaaaa...", "baaaaa...", "abaaaa...", "bbaaaa...", "aabaaa...", ...]

where ...表示扩展到无限长度的列表(和列表列表).

一个天真的尝试是:

counters alphabet = [c:ounter | ounter <- counters alphabet, c <- alphabet]

但这不起作用,因为它是递归的.

当然,对于工作版本,如果您尝试打印结果,则只会看到第一个元素被打印为字母表中第一个元素的无限列表.但是,您应该能够这样做:

mapM_ (print . take 2) . take 4 . counters $ "ab"

并看到输出:

aa
ba
ab
bb

我有一个重要的无限循环,允许传感器不断更新其值.但是,当另一个传感器带来新值时,我想打破这个循环.如何从一个无限循环切换到另一个？

当前代码:

for(;;){

    SON_Start();
    // Wait 65ms for max range time
    delay10ms(7);
    // Read Range
    i = SON_Read(SON_ADDRESSES[sonarReading]);
    // pause
    delayMs(100);
        if(i<15)
        drive(200, RadCW);

    }

我想补充一下:

如果Sensor2返回一个读数(例如Sensor2 > 20),那么我想打破循环并转到另一个无限for循环来开始一个新函数.

我想定义似乎需要无限类型的东西.

必需:一个函数"吃"吃掉它除了"3"之外的所有参数,它返回3

eat 3 = 3
eat x = eat

所以基本上像"吃(+)foldl(Just 5)3"这样的任意表达式评估为3.但这里的问题是吃的类型.应该是什么？

我得到的最接近的运行代码是:

newtype Rec = MakeRec (Int -> Rec)

eat :: Int -> Rec
eat x = MakeRec eat


instance Show Rec where
     show _ = "EAT"

这适用于"吃6"而不是"吃6 7",如果我把(吃3 = 3)放在它的定义中它就不起作用.

我不确定这在Haskell中是否可行.(用什么论证来表明它是不可能的？)

更新:如下面的解决方案中所述,在编译时需要类型信息,以便编译器可以知道"eat foldl 3 foldl"是否无效.因此,这个问题的确切解决方案是不可能的.