精华内容
下载资源
问答
  • FOLD

    2019-10-24 12:35:10
    FOLD
  • Linux fold命令用法详解

    2021-01-09 21:10:58
    Linux fold命令 Linux fold命令用于限制文件列宽。 fold指令会从指定的文件里读取内容,将超过限定列宽的列加入增列字符后,输出到标准输出设备。若不指定任何文件名称,或是所给予的文件名为”-“,则fold指令会从...
  • scala-fold:可折叠-源码

    2021-04-30 19:32:20
    scala-fold Scala中的可折叠 介绍 该库定义了Foldl数据类型(左折),可以将其以应用样式进行组合,从而使所得的折痕只需要在给定结构上进行一次遍历。 图书馆有常见的折痕。 您始终可以通过提供阶跃函数和初始值...
  • 用于查找径向基神经网络模型的网络参数的程序 MATLAB 函数“newrb”用于为给定数据集训练神经网络。... 传播(网络参数)将影响模型性能。 该程序可用于获得给定数据集的“传播常数”的最佳值。 获得显示交叉验证误差...
  • Hash :: Fold-展平和展平嵌套的hashrefs 概要 use Hash::Fold qw( flatten unflatten ) ; my $object = bless { foo => ' bar ' }; my $nested = { foo => $object , baz => { a => ' b ' , c => [ ' d ' , { e ...
  • matlab代码生成输入结构体fold2Bloch fold2Bloch实用程序旨在展开通过Vienna Ab initio Simulation Package()获得的超级电池的能带结构,并以原始表示形式计算有效的能带结构。 它有助于大规模电子结构计算的解释...
  •  实现paper fold(纸张折叠)样式的视图切换效果。手指向左滑动视图,新视图以一种折叠展开的样式进入主界面。手指向右滑动视图,当前视图则以折叠的形式推出主界面。 [优才 · Code4App]编译测试,适用环境:...
  • DFT的matlab源代码fold2Bloch 用DFT-(L)APW码获得的第一性原理电子能带结构的展开 贡献者: 安东·博坎楚克(Anton Bokhanchuk) 埃里亚斯·阿斯曼(Elias Assmann) 谢赫·贾米尔·艾哈迈德(Sheikh Jamil Ahmed...
  • Linux基础命令---fold-附件资源
  • Fault Fold Forward. Geological App for Faults and Folds simulation. Developed by Richard Allmendinger.
  • TensorFlow_Fold QuickStart

    2017-03-23 15:09:56
    http://blog.csdn.net/okcd00/article/details/65443813 博文相关PPT
  • 淡紫色褶皱 这个软件包可以像Vim一样执行文本折叠。 它具有以下功能: 折叠活动区域; 良好的视觉反馈:很明显,文本的哪一部分被折叠; 从{{{ }}}之间的区域自动创建折叠(标记可自定义);...
  • 前端开源库-travis-fold

    2019-08-29 17:39:38
    前端开源库-travis-foldTravis Fold,用于发送Travis CI输出折叠语法的微型模块
  • 折叠钮 用于折叠/展开由target属性指定的元素的自定义元素。 建立并推送gh页 $ tool/gh-pages.dart $ git push origin gh-pages
  • ae的插件
  • How To Fold It

    2016-11-08 22:31:23
    How To Fold It MIT 几何折叠算法主讲教授专著
  • Fold

    2016-12-20 06:47:15
    Read the statement of problem E: Edge to understand how to fold a sheet of paper and how to interpret the input. We define a "stripe" to be a maximally large part of the sheet that has no folding line...
  • fold命令会从指定的文件里读取内容,将超过限定列宽的列加入增列字符后,输出到标准输出设备。若不指定任何文件名称,或是所给予的文件名为”-“,则fold指令会从标准输入设备读取数据。 语法格式:fold [参数] ...
  • fold函数 在函数式编程中,Map和Fold是两个非常有用的运算符,它们属于每种函数式语言。 如果Map和Fold运算符是如此强大且必不可少,那么您如何解释说即使Java编程语言缺少这两个运算符,我们也可以使用Java来完成...

    fold函数

    在函数式编程中,Map和Fold是两个非常有用的运算符,它们属于每种函数式语言。 如果Map和Fold运算符是如此强大且必不可少,那么您如何解释说即使Java编程语言缺少这两个运算符,我们也可以使用Java来完成工作? 事实是,使用Java进行编码时,您已经进行了Map和Fold,只是每次都使用循环手动进行操作。

    免责声明:我不是函数式编程的参考,本文不过是一个简短的介绍。 FP爱好者可能不太喜欢它。

    您已经熟悉了

    想象一下不含增值税的数量的List <Double>。 我们希望将此列表转换为包含增值税的另一个相应列表。 首先,我们定义一种将增值税加到一个单一金额中的方法:

    public double addVAT(double amount, double rate) {return amount * (1 + rate);}

    现在让我们将此方法应用于列表中的每个金额:

    public List<Double> addVAT(List<Double> amounts, double rate){
      final List<Double> amountsWithVAT = new ArrayList<Double>();
      for(double amount : amounts){
         amountsWithVAT.add(addVAT(amount, rate));
      }
      return amountsWithVAT;
    }

    在这里,我们创建了另一个输出列表,对于输入列表的每个元素,我们对其应用addVAT()方法,然后将结果存储到大小完全相同的输出列表中。 恭喜,正如我们刚刚手工完成的,在方法addVAT()的输入列表上有一个Map。 让我们再做一次。

    现在我们要使用货币汇率将每个金额转换为另一种货币,因此我们需要一种新的方法:

    public double convertCurrency(double

    public double convertCurrency(double amount, double currencyRate){return amount / currencyRate;}

    现在,我们可以将此方法应用于列表中的每个元素:

    public List<Double> convertCurrency(List<Double> amounts, double currencyRate){
       final List<Double> amountsInCurrency = new ArrayList<Double>();
       for(double amount : amounts){
          amountsInCurrency.add(convertCurrency(amount, currencyRate));
       }
       return amountsInCurrency;
    }

    注意,除了在步骤2处调用的方法外,两种接受列表的方法是如何相似的:

    1. 创建一个输出列表,
    2. 为输入列表中的每个元素调用给定方法 ,并将结果存储到输出列表中
    3. 返回输出列表。

    您经常在Java中执行此操作,而这恰恰是Map运算符:将给定方法someMethod (T):T应用于list <T>的每个元素,这将为您提供另一个相同大小的list <T>。

    功能语言认识到这种特殊需求(在集合的每个元素上应用一种方法)非常普遍,因此他们将其直接封装到内置的Map运算符中。 这样,给定addVAT(double,double)方法,我们可以使用Map运算符直接编写如下代码:

    List amountsWithVAT = map (addVAT, amounts, rate)

    是的,第一个参数是函数,因为函数是函数语言中的一等公民,因此可以将它们作为参数传递。 与for循环相比,使用Map运算符更简洁,更不易出错,其意图也更加明确,但是我们在Java中没有它……

    因此,这些示例的要点在于,您已经不熟悉甚至不知道函数式编程的关键概念:Map运算符。

    现在是Fold运算符

    回到金额列表,现在我们需要将总金额计算为每个金额的总和。 超级容易,让我们循环执行一下:

    public double totalAmount(List<Double> amounts){
       double sum = 0;
       for(double amount : amounts){
          sum += amount;
       }
       return sum;
    }

    基本上,我们只是在列表上进行了折叠,使用函数“ + =”将每个元素折叠为一个元素,这里是一个数字,一次递增地折叠。 这类似于Map运算符,除了结果不是列表而是单个元素(标量)。

    这又是您通常用Java编写的那种代码,现在您已经用功能语言为它命名:“ Fold ”或“ Reduce”。 Fold运算符通常在函数式语言中是递归的,因此在此不再对其进行描述。 但是,我们可以使用某种可变状态在迭代之间累加结果,从而以迭代形式实现相同的目的。 在这种方法中,Fold采用一种内部可变状态的方法,该方法期望一个元素,例如someMethod(T),并将其重复应用于输入列表<T>中的每个元素,直到我们得到一个单个元素T,即折叠操作的结果。

    与Fold一起使用的典型函数是求和,逻辑与与或,List.add()或List.addAll(),StringBuilder.append(),max或min等。Fold的思维方式类似于SQL中的聚合函数

    形状思考

    直观地思考(带有草率的图片),Map接收一个大小为n的列表,并返回另一个大小相同的列表:

    另一方面,Fold获取大小为n的列表,并返回单个元素(标量):

    您可能还记得我之前关于谓词的文章 ,这些文章通常用于将集合过滤为元素较少的集合。 实际上,此过滤器运算符是在大多数功能语言中补充Map和Fold的第三种标准运算符。

    Eclipse模板

    由于Map和Fold很常见,因此有必要为它们创建Eclipse模板,例如Map:

    在Java中更接近地图和折叠

    Map和Fold是期望函数作为参数的构造,而在Java中,传递方法的唯一方法是将其包装到接口中。

    在Apache Commons Collections中,有两个接口对于我们的需求特别有趣: Transformer (具有一个方法transform(T):T )和Closure (具有一个方法execute(T):void) 。 类CollectionUtils提供了方法collect(Iterator,Transformer) ,它基本上是Java集合的穷人Map运算符,以及提供了可以使用闭包来模拟Fold运算符的forAllDo()方法。

    使用Google Guava, Iterables类提供了静态方法transform(Iterable,Function) ,该方法基本上是Map运算符。

    List<Double> exVat = Arrays.asList(new Double[] { 99., 127., 35. });
     Iterable<Double> incVat = Iterables.transform(exVat, new Function<Double, Double>() {
       public Double apply(Double exVat) {
         return exVat * (1.196);
       }
     });
     System.out.println(incVat); //print [118.404, 151.892, 41.86]

    类似的变换()方法,也可在类解释为解释和地图为地图。

    要在Java中模拟Fold运算符,可以使用Closure接口,例如Apache Commons Collection中的Closure接口,仅使用一个带有一个参数的单一方法,因此必须在内部保留当前的-mutable-状态,就像'+ =确实。

    不幸的是,Guava中没有Fold,尽管它经常被要求提供 ,甚至没有类似闭包的函数,但是创建自己的函数并不难,例如,您可以使用以下方式实现上述总计:

    // the closure interface with same input/output type
    public interface Closure<T> {
     T execute(T value);
    }
    
    // an example of a concrete closure
    public class SummingClosure implements Closure<Double> {
     private double sum = 0;
    
     public Double execute(Double amount) {
       sum += amount; // apply '+=' operator
       return sum; // return current accumulated value
     }
    }
    
    // the poor man Fold operator
    public final static <T> T foreach(Iterable<T> list, Closure<T> closure) {
     T result = null;
     for (T t : list) {
       result = closure.execute(t);
     }
     return result;
    }
    
    @Test // example of use
    public void testFold() throws Exception {
     SummingClosure closure = new SummingClosure();
    
     List<Double> exVat = Arrays.asList(new Double[] { 99., 127., 35. });
     Double result = foreach(exVat, closure);
     System.out.println(result); // print 261.0
    }

    不仅用于收藏:可折叠在树木和其他建筑物上

    Map and Fold的功能不仅限于简单的集合,还可以扩展到任何可导航的结构,尤其是树和图。

    想象一棵使用带有其子节点的类Node的树。 最好将深度优先搜索和广度优先搜索(DFS和BFS)编码成两个接受Closure作为单个参数的通用方法:

    public class Node ...{
       ...
       public void dfs(Closure closure){...}
       public void bfs(Closure closure){...}
    }

    过去,我经常使用这种技术,我可以说它可以大大减少类的大小,仅使用一种通用方法,而不是许多看起来相似的方法(每个方法都会重做自己的树遍历)。 更重要的是,可以使用模拟闭包对遍历本身进行单元测试。 每个封盖也可以独立进行单元测试,所有这些都使您的生活变得更加简单。

    访客模式可以实现非常相似的想法,您可能已经很熟悉。 我在代码和其他几个团队的代码中多次看到,Visitor非常适合在遍历数据结构期间累积状态。 在这种情况下,Visitor只是闭合中传递给折叠的一种特殊情况。

    Map-Reduce上的一个字

    您可能听说过Map-Reduce模式,是的,其中的“ Map”和“ Reduce”一词指的是我们刚刚看到的相同的函数运算符Map和Fold(也称为Reduce)。 尽管实际应用更加复杂,但很容易注意到Map 令人尴尬地并行的,这对并行计算有很大帮助。

    参考:来自我们的JCG合作伙伴的 日常Java中的Map和Fold功能编程思考   Cyrille Martraire 博客上的Cyrille Martraire


    翻译自: https://www.javacodegeeks.com/2012/03/functional-programming-with-map-and.html

    fold函数

    展开全文
  • FOLD(柔性折纸列表数据结构网络)是一种文件格式(扩展.fold )用于描述折纸机型:折痕图案,山-谷的图案,折叠状态等主要是,一个FOLD文件可以存储与顶点,边,面的网状,以及它们之间的链接,以及可选的2D或3D...
  • flink fold 最近我们在代码审查期间进行了长时间的讨论,不管scala.Option.fold()是惯用的还是聪明的,或者是scala.Option.fold()和棘手的? 让我们首先描述问题所在。 Option.fold有两件事:将函数f映射到Option的...

    flink fold

    最近我们在代码审查期间进行了长时间的讨论,不管scala.Option.fold()是惯用的还是聪明的,或者是scala.Option.fold()和棘手的? 让我们首先描述问题所在。 Option.fold有两件事:将函数f映射到Option的值(如果有)上,或者在不存在的情况下返回替代alt 。 使用简单的模式匹配,我们可以如下实现它:



    val option: Option[T] = //...
    def alt: R = //...
    def f(in: T): R = //...
     
    val x: R = option match {
        case Some(v) => f(v)
        case None => alt
    }

    如果您喜欢getOrElsefold实际上是mapgetOrElse的组合:

    val x: R = option map f getOrElse alt

    或者,如果您仍然是C程序员,但仍想使用Cala编写Scala编译器,请执行以下操作:

    val x: R = if (option.isDefined)
        f(option.get)
    else
        alt

    有趣的是,这类似于fold()的实际实现方式,但这是一个实现细节。 好的,以上所有内容都可以用单个Option.fold()代替:

    val x: R = option.fold(alt)(f)

    从技术上讲,您甚至可以使用/:\:运算符( alt /: option )–但这只是受虐狂。 我在使用option.fold()惯用语时遇到三个问题。 首先–除了可读性之外,什么都没有。 我们正在折叠(减少) Option –的确没有多大意义。 其次,它通过以失​​败(不存在, alt )条件开始,然后跟随状态块( f函数;另请参见:将map-getOrElse重构为fold逆转普通的正则负情况 。 有趣的是,如果将其命名为mapOrElse则该方法对我来说非常mapOrElse

    /**
     * Hypothetical in Option
     */
    def mapOrElse[B](f: A => B, alt: => B): B =
        this map f getOrElse alt

    实际上,Scalaz中已经有这样的方法,称为OptionW.cata卡塔 这是马丁·奥德斯基(Martin Odersky)所说的

    “我个人发现像cata这样的方法需要两个闭包,因为参数通常会夸大它。 您真的通过map + getOrElse获得了可读性吗? 想一想您的代码的新手[…]”

    尽管cata具有一定的理论背景 ,但Option.fold听起来像是随机的名称冲突,除了混乱之外,什么都没有带来。 我知道您会说什么, TraversableOnce已经fold ,我们正在做同样的事情。 为什么是随机冲突而不是扩展TraversableOnce描述的协定? Scala集合中的fold()方法通常仅委托foldLeft() / foldRight() (对于给定的数据结构更好地工作)之一,因此它不能保证顺序,并且折叠功能必须是关联的。 但是在Option.fold() ,契约是不同的:折叠函数只接受一个参数,而不是两个。 如果您阅读我以前的关于折痕的文章,则知道折减函数始终采用两个参数:当前元素和累加值(第一次迭代期间的初始值)。 但是Option.fold()仅接受一个参数:当前Option值! 这破坏了一致性,尤其是当实现Option.foldLeft()Option.foldRight()具有正确的协定时(但这并不意味着它们更具可读性)。

    理解option折叠的唯一方法是将Option想象为具有01元素的序列。 那有点道理,对吗? 没有。

    def double(x: Int) = x * 2
     
    Some(21).fold(-1)(double)   //OK: 42
    None.fold(-1)(double)       //OK: -1

    但:

    Some(21).toList.fold(-1)(double)
    <console>: error: type mismatch;
     found   : Int => Int
     required: (Int, Int) => Int
                  Some(21).toList.fold(-1)(double)
                                           ^

    如果我们将Option[T]视为List[T] ,则尴尬的Option.fold()会中断,因为它的类型与TraversableOnce.fold() 。 这是我最大的担心。 我不明白为什么不按类型系统(特征?)定义折叠并严格执行。 作为一个例子看看:

    在Haskell中

    Data.Foldable类型类描述Haskell中的各种折叠Data.Foldable 。 在Scala中有熟悉的foldl / foldr / foldl1 / foldr1 ,因此命名为foldLeft / foldRight / reduceLeft / reduceRight 。 它们具有与Scala相同的类型,并且对所有可以折叠的类型(包括Maybe ,列表,数组等)的行为都不足为奇。还有一个名为fold的函数,但它的含义完全不同:

    class Foldable t where
        fold :: Monoid m => t m -> m

    尽管其他折叠非常复杂,但此折叠几乎不带一个m s的可折叠容器(必须为Monoid s)并返回相同的Monoid类型。 快速回顾:如果类型存在一个中性值,并且一个操作使用两个值而只产生一个,则该类型可以是Monoid 。 在其中一个参数为中性值的情况下应用该函数会产生另一个参数。 String[Char] )是一个很好的示例,其中空字符串为中性值( mempty ),字符串连接为此类操作( mappend )。 请注意,可以使用两种不同的方法来构造数字的单素体:在中性值为0x + 0 == 0 + x == x对于任何x )的情况下以及与中性1乘法( x * 1 == 1 * x == x对于任何x )。 让我们坚持下去。 如果我折叠空字符串列表,我将得到一个空字符串。 但是,当列表包含许多元素时,它们将被串联起来:

    > fold ([] :: [String])
    ""
    > fold [] :: String
    ""
    > fold ["foo", "bar"]
    "foobar"

    在第一个示例中,我们必须显式说明空列表[]的类型。 否则,Haskell编译器将无法弄清列表中元素的类型,因此无法选择哪个Monoid实例。 在第二个示例中,我们声明从fold []返回的任何内容都应该是String 。 据此,编译器推断[]实际上必须具有[String]类型。 最后fold是最简单的:程序会折叠列表中的元素并将其连接起来,因为连接是在Monoid String类型类实例中定义的操作。

    返回选项(或更确切地说, Maybe )。 折叠具有类型参数为Monoid Maybe monad(我不能相信我刚刚说过)有一个有趣的解释:它要么返回Maybe内部的值,要么返回默认的Monoid值:

    > fold (Just "abc")
    "abc"
    > fold Nothing :: String
    ""

    Just "abc"与Scala中的Some("abc")相同。 您可以在此处看到,如果Maybe StringNothing ,则返回中性的String monoid值,即为空字符串。

    摘要

    Haskell表明折叠(也Maybe超过Maybe )至少可以保持一致。 在Scala中, Option.foldOption.fold无关,令人困惑List.fold可读。 我建议您避免使用它,而应该使用更详细的map / getOrElse转换或模式匹配。

    PS:我是否提到过还有Either.fold() (甚至有不同的合同),但是没有Try.fold()吗?

    翻译自: https://www.javacodegeeks.com/2014/06/option-fold-considered-unreadable.html

    flink fold

    展开全文
  • Fold算法实现最短路径

    2013-05-11 23:19:39
    很好的空间分析最短路径算法,可以借鉴学习的例子
  • C++ Fold表达式

    2019-12-30 11:33:13
    fold参数包只提供1个元素时,(rest+...) 即 ((one) + ...) 的值是one,虽然+运算符需要两个操作数,而我只给他一个,因此编译器没有考虑+运算,而是直接返回one值。当fold参数包提供0个元素时,对于+操作,编译器...
    #include <iostream>
    using namespace std;
     
    class Operant{
    public:
        int i_;
        Operant(int i){ 
            cout << "Create [Operant "<< i << "]"<< endl;
            i_ = i; 
        }
    }; 
    
    Operant operator+(Operant left, Operant right ){
    
        cout << "[Operant " << left.i_ <<"] + [Operant " << right.i_ << "]" << endl;
    
        int a = left.i_ + right.i_;
        Operant ret(a);
        return ret;
    } 
     
    template<typename... T> 
    decltype(auto) sum1( T&&... rest )  
    {  
        return ( rest + ...  );
    }
    
    template<typename I, typename... T> 
    decltype(auto) sum2( I&& init, T&&... rest )  
    {  
        return ( rest + ... + init  );
    }
      
    Operant zero(0);  
    Operant one(1),two(2),four(4);
    
    int main()
    {
        sum1(one,two,four); 
        sum2(zero,one,two,four); 
    }

    (... + (1,2,4)) 等价于 ((1+2) + 4)
     ( (1,2,4) + ... )   等价于 (1 + (2+4))   注意:不是((4+2) + 1)
     ( 0 +... + (1,2,4))  等价于 (((0+1) + 2) + 4)
     ( (1,2,4)+ ... + 0)  等价于 (1+ (2 + (4 + 0)))

    #include <iostream>
    using namespace std;
     
    class Operant{
    public:
        int i_;
        Operant(int i){ 
            i_ = i; 
        }
    }; 
    
    Operant& showme(Operant& a){
        cout << "[I am Operant "<< a.i_ << "]"<< endl;
        return a;
    }
    
    Operant operator+(Operant left, Operant right ){
    
        cout << "[Operant " << left.i_ <<"] + [Operant " << right.i_ << "]" << endl;
    
        int a = left.i_ + right.i_;
        Operant ret(a);
        return ret;
    } 
     
    template<typename... T> 
    decltype(auto) sum1( T&&... rest )  
    {  
        return (   showme(rest) + ...  );
    }
    
    Operant zero(0);  
    Operant one(1),two(2),four(4);
    
    int main()
    {
        sum1(zero,one,two,four); 
    }

    参数包可以调函数,类似showme(rest)这样,实际上把(zero,one,two,four)参数包转化为(showme(zero),showme(one),showme(two),showme(four))这个新的参数包。至于先后调用顺序,我的编译器总是先调用showme(four)。至于是先做函数调用结束后才开始处理+运算,我的编译器在(showme(rest)+...)和(...+showme(rest))完全不同。但是至少保证在做+运算之前,已经经过showme函数处理了。

    #include <iostream>
    using namespace std;
     
    class Operant{
    public:
        int i_;
        Operant(int i){ 
            i_ = i; 
        }
    }; 
     
    template<typename... T> 
    decltype(auto) sum1( T&&... rest )  
    {  
        return ( rest + ... );
    }
    
    Operant zero(0);  
    Operant one(1),two(2),four(4);
    
    int main()
    {
        sum1(one); 
    }

    当fold参数包只提供1个元素时,(rest+...) 即 ((one) + ...) 的值是one,虽然+运算符需要两个操作数,而我只给他一个,因此编译器没有考虑+运算,而是直接返回one值。当fold参数包提供0个元素时,对于+操作,编译器会报错,即sum1() 报错。注意,&&运算fold提供空参数包时,编译器返回true。
    1) Logical AND (&&). The value for the empty pack is true
    2) Logical OR (||). The value for the empty pack is false
    3) The comma operator (,). The value for the empty pack is void()

    #include <iostream>
    using namespace std;
    
    template<typename Arg>
    void show_one(Arg arg)
    {
       std::cout << arg << " ";
    }
    
    template<typename... Args>
    void show_all(Args... args)
    {
        ( show_one(args) , ... );
    }
    
    int main()
    {
        show_all(1,2,"hello",3.1415f);
        cout << endl ;
    }

    如果只想对一批参数分别调函数处理,而不想把结果做运算合并,只需用逗号表达式的参数包形式。

    展开全文
  • PySpark fold foldByKey用法

    2021-05-30 17:07:03
    但是当分区内和分区间算法相同时,便可以简化使用fold foldByKey这2个方法; 使用示例 # -*- coding: utf-8 -*- """ (C) rgc All rights reserved create time '2021/5/26 19:37' Usage: fold 用法 foldByKey 用法 "...

    用法

    当RDD分区内和分区间算法不同时,使用aggregate aggregateByKey等2个方法;
    但是当分区内和分区间算法相同时,便可以简化使用fold foldByKey这2个方法;

    使用示例

    # -*- coding: utf-8 -*-
    """
    (C) rgc
    All rights reserved
    create time '2021/5/26 19:37'
    
    Usage:
    fold 用法
    foldByKey 用法
    """
    # 构建spark
    from pyspark.conf import SparkConf
    from pyspark.context import SparkContext
    
    conf = SparkConf()
    # 使用本地模式;且 executor设置为1个方便debug
    conf.setMaster('local[1]').setAppName('rgc')
    sc = SparkContext(conf=conf)
    
    rdd = sc.parallelize([2, 1, 3, 4, 4], 1)
    
    
    def seq_func(x: tuple, y: int or float) -> tuple:
        """
        计算函数
        :param x: 指  zeroValue 参数 也就是(2,0)
        :param y: 指 具体的元素
        :return: 元素的累加,元素的个数
        """
        return x[0] + y, x[1] + 1
    
    
    def comb_func(x: tuple, y: tuple) -> tuple:
        """
        计算函数
        :param x: 第一个元素 类型 元祖
        :param y: 第二个元素 类型 元祖
        :return:
        """
        return x[0] + y[0], x[1] + y[1]
    
    
    # fold:rdd分区内和分区间使用相同的函数进行聚合计算;
    # 注意: 初始值 会参与分区内和分区间的计算;
    # 所以 每个分区内的一次初始值(5) + 分区内的元素(2+1+3+4+4) + 分区间的一次初始值(5) = 24
    rdd_res = rdd.map(lambda x: (x, 1)).fold((5, 0), comb_func)
    print(rdd_res)  # (24,5)
    
    # foldByKey:rdd分区内 所有元素先根据key进行分组,然后分区内和分区间使用 相同的函数 对每个key对应的values 进行聚合计算;
    # 注意: 初始值 只参与分区内的计算,不参与分区间计算
    rdd_res = rdd.map(lambda x: (x, 1)).foldByKey((1, 0), seq_func)
    print(rdd_res.collect())  # [(2, (2, 1)), (1, (2, 1)), (3, (2, 1)), (4, (3, 2))]
    

    注意

    • fold方法和aggregate通过查看源码发现 其会调用collect()方法;而collect()方法会将Executor端每个分区所有执行的结果收集到Driver端,然后在Driver端进行分区间操作;也就是Driver端如果内存不够时 会报错;
    展开全文
  • 下面代码表示累计求和。 main(){ Iterable<int> iterable = {1,3,5,7};... int result= iterable.fold(0, (curr, next) => curr+next);//对当前和下一个求和,结果给result print(result);//输出 }
  • Optodes的位置决定器(fOLD) 该工具箱允许基于基于五种分割方法的解剖学界标的光电二极管布置。 或者,也可以加载体积fMRI数据(NIfTI或ANALYZE)作为fNIRS光电二极管位置的遮罩。 在使用fOLD之前,请仔细阅读其...
  • kotlin-fold变换

    2021-06-08 00:36:51
    val list = listOf(1, 2, 3, 4, 5, 6) val str = list.fold(StringBuilder()) { a, i -> a.append(i) } println(str) 控制台输出:
  • 最近我们在代码审查期间进行了冗长的讨论,不管scala.Option.fold()是惯用的还是聪明的,或者是scala.Option.fold()和棘手的? 让我们首先描述问题所在。 Option.fold有两件事:将函数f映射到Option的值(如果有的话...
  • Android一个让你轻易实现折叠fold效果的开源库.rar,太多无法一一验证是否可用,程序如果跑不起来需要自调,部分代码功能进行参考学习。
  • fold = torch.nn.Fold(output_size=(4, 4), kernel_size=(2, 2), stride=2) inputs_restore = fold(patches) print(inputs_restore) print(inputs_restore.size()) Fold的操作通过设定output_size=(4, 4),完成与...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,103
精华内容 17,641
关键字:

fold