text:
c
c -------------------------------------------------------------
c
      subroutine errest (nvar,naux,lcheck)
c
      implicit double precision (a-h,o-z)

      include  "call.i"

c
c     #   no sense computing new time step if just for error estimation,
c     #   vtime removed from arg list to stepgrid, but new dt not used

c :::::::::::::::::::::::::: ERREST :::::::::::::::::::::::::::::::::::
c for all grids at level lcheck:
c  estimate the error by taking a large (2h,2k) step based on the
c  values in the old storage loc., then take one regular (and for
c  now wasted) step based on the new info.   compare using an
c  error relation for a pth order  accurate integration formula.
c  flag error plane as either bad (needs refinement), or good.
c
c  call the regular integrator on a grid twice as coarse.
c  initialize such a grid directly, instead of trick dimensioning.
c  this is to make other l1 type estimates easier to program.
c :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
c
       hx   = hxposs(lcheck)
       hy   = hyposs(lcheck)
       hx2  = 2.d0*hx
       hy2  = 2.d0*hy
       mptr = lstart(lcheck)
 5     continue
          nx     = node(ndihi,mptr) - node(ndilo,mptr) + 1
          ny     = node(ndjhi,mptr) - node(ndjlo,mptr) + 1
          mitot  = nx + 2*nghost
          mjtot  = ny + 2*nghost
          locnew = node(store1,mptr)
          locold = node(store2,mptr)
          locaux = node(storeaux,mptr)
          mi2tot = nx/2  + 2*nghost
          mj2tot = ny/2  + 2*nghost
          time   = rnode(timemult,mptr)
          dt     = possk(lcheck)
          tpre   = time - dt
c
c     prepare double the stencil size worth of boundary values,
c            then coarsen them for the giant step integration.
c
          midub = nx+4*nghost
          mjdub = ny+4*nghost
          locdub = igetsp(midub*mjdub*(nvar+naux))
          locbgc = igetsp(mi2tot*mj2tot*(nvar+naux))
          node(errptr,mptr) = locbgc
          ng2 = 2*nghost

c         # transfer soln. into grid with twice the ghost cells
          call copysol(alloc(locdub),alloc(locold),nvar,mitot,mjtot,
     1              nghost,midub,mjdub,ng2)

c
          if (naux .gt. 0) then
              locaxb = locdub + midub*mjdub*nvar
              locaxc = locbgc + mi2tot*mj2tot*nvar
              xl     = rnode(cornxlo, mptr)
              yb     = rnode(cornylo, mptr)
              maxmx = midub - 4*nghost
              mx = maxmx
              maxmy = mjdub - 4*nghost
              my = maxmy
              call setaux(maxmx,maxmy,2*nghost,mx,my,xl,yb,hx,hy,
     &                    naux,alloc(locaxb))
              call auxcoarsen(alloc(locaxb),midub,mjdub,
     1                     alloc(locaxc),mi2tot,mj2tot,naux,auxtype)
          else
              locaxb = 1
          endif

c         # fill it - use enlarged (before coarsening) aux arrays
          call bound(tpre,nvar,ng2,alloc(locdub),midub,mjdub,mptr,
     1               alloc(locaxb),naux)

c         coarsen by 2 in every direction
          call coarsen(alloc(locdub),midub,mjdub,
     1                 alloc(locbgc),mi2tot,mj2tot,nvar)
          call reclam(locdub,midub*mjdub*(nvar+naux))
c
c
c************************************************************************
c        changed. now locbig filled from spest, always, even if no
c        user estimation routine. reclaim space later tho.

c We now fill bndry values at time t = time, in preparation
c for calculating the solution on the grid mptr for error estimation.
c
c          locbig = igetsp(mitot*mjtot*nvar)
c          node(tempptr,mptr) = locbig
c         # straight copy into scratch array so don't mess up latest soln.
c          do 10 i = 1, mitot*mjtot*nvar
c 10          alloc(locbig+i-1) = alloc(locnew+i-1)
c
c          call bound(time,nvar,nghost,alloc(locbig),mitot,mjtot,mptr,
c     1               alloc(locaux),naux)

c************************************************************************
c
       mptr = node(levelptr,mptr)
       if (mptr .ne. 0) go to 5
c
       hx   = hxposs(lcheck)
       hy   = hyposs(lcheck)
       hx2  = 2.d0*hx
       hy2  = 2.d0*hy
       dt   = possk(lcheck)
       dt2    = 2. * dt

       mptr = lstart(lcheck)
 25    continue
          nx     = node(ndihi,mptr) - node(ndilo,mptr) + 1
          ny     = node(ndjhi,mptr) - node(ndjlo,mptr) + 1
          mitot  = nx+ 2*nghost
          mjtot  = ny+ 2*nghost
          mi2tot = nx/2 + 2*nghost
          mj2tot = ny/2 + 2*nghost
c
c         # this scratch storage will be used both for regular and half
c         # sized grid. different dimensions in stepgrid - do not reuse.
          locfp = igetsp(mitot*mjtot*nvar)
          locfm = igetsp(mitot*mjtot*nvar)
          locgp = igetsp(mitot*mjtot*nvar)
          locgm = igetsp(mitot*mjtot*nvar)
          locaux = node(storeaux,mptr)
c
          locbgc = node(errptr,mptr)
c
          locaxc = locbgc+nvar*mi2tot*mj2tot
c should we set to 1 if naux=0?
c
          evol = evol + (nx/2)*(ny/2)
          xlow = rnode(cornxlo,mptr) - nghost*hx2
          ylow = rnode(cornylo,mptr) - nghost*hy2
          call stepgrid(alloc(locbgc),alloc(locfm),alloc(locfp),
     1                alloc(locgm),alloc(locgp),
     2                mi2tot,mj2tot,nghost,
     3                dt2,dtnew2,hx2,hy2,nvar,
     4                xlow,ylow,tpre,mptr,naux,alloc(locaxc))
c
c  the one giant step based on old values is done. now take
c  one regular step based on new values.
c
      evol   = evol + nx * ny
      xlow   = rnode(cornxlo,mptr) - nghost*hx
      ylow   = rnode(cornylo,mptr) - nghost*hy
      locbig = node(tempptr,mptr)
      loctmp = node(store2,mptr)
c
c **********************************************************************
c ****** changed. spatial error now done from separate routine spest ******
c
c estimate spatial component of error - use old values before
c integration to get accurate boundary gradients
c
c     locerrsp = igetsp(mitot*mjtot)
c     call errsp(alloc(locbig), alloc(locerrsp), mitot,mjtot,
c    &           nvar, mptr,nghost, eprint, outunit)

c **********************************************************************

      call stepgrid(alloc(locbig),alloc(locfm),alloc(locfp),
     1            alloc(locgm),alloc(locgp),
     2            mitot,mjtot,nghost,
     3            dt,dtnew,hx,hy,nvar,
     4            xlow,ylow,time,mptr,naux,alloc(locaux))
c
      call reclam(locfp, mitot*mjtot*nvar)
      call reclam(locfm, mitot*mjtot*nvar)
      call reclam(locgp, mitot*mjtot*nvar)
      call reclam(locgm, mitot*mjtot*nvar)
c

      call errf1(alloc(locbig),nvar,
     1          alloc(locbgc),mptr,mi2tot,mj2tot,
     2          mitot,mjtot,alloc(loctmp))

      call reclam(locbgc,mi2tot*mj2tot*(nvar+naux))

c      reclaiming locbig is now done from bufnst, since this routine
c      will not be called if tol<0
c      call reclam(locbig,mitot*mjtot*nvar)
c
      mptr = node(levelptr, mptr)
      if (mptr .ne. 0) go to 25
c
      return
      end


text:
OC.L10N.register(
    "files_versions",
    {
    "Versions" : "Versões",
    "Failed to revert {file} to revision {timestamp}." : "Falha ao reverter {file} para a revisão {timestamp}.",
    "_%n byte_::_%n bytes_" : ["%n byte","%n bytes"],
    "Restore" : "Restaurar",
    "No other versions available" : "Nenhuma outra versão disponível"
},
"nplurals=2; plural=(n > 1);");

redpajama_set_name: RedPajamaGithub


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<title>EscherProperty (POI API Documentation)</title>
<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">

JavaScript is disabled on your browser.

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Prev Class

Next Class

Frames

No Frames

All Classes

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method

org.apache.poi.ddf

Class EscherProperty

java.lang.Object

org.apache.poi.ddf.EscherProperty

Direct Known Subclasses:

EscherComplexProperty, EscherSimpleProperty

public abstract class EscherProperty
extends java.lang.Object

This is the abstract base class for all escher properties.

Author:

Glen Stampoultzis (glens at apache.org)

See Also:

EscherOptRecord

Constructor Summary

Constructors

Constructor and Description

EscherProperty(short id)

The id is distinct from the actual property number.

EscherProperty(short propertyNumber,
              boolean isComplex,
              boolean isBlipId)

Constructs a new escher property.

Method Summary

Methods

Modifier and Type
Method and Description

short
getId()

java.lang.String
getName()

short
getPropertyNumber()

int
getPropertySize()

Most properties are just 6 bytes in length.

boolean
isBlipId()

boolean
isComplex()

abstract int
serializeComplexPart(byte[] data,
                    int pos)

Escher properties consist of a simple fixed length part and a complex variable length part.

abstract int
serializeSimplePart(byte[] data,
                   int pos)

Escher properties consist of a simple fixed length part and a complex variable length part.

java.lang.String
toXml(java.lang.String tab)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

EscherProperty

public EscherProperty(short id)

The id is distinct from the actual property number.  The id includes the property number the blip id
 flag and an indicator whether the property is complex or not.

EscherProperty

public EscherProperty(short propertyNumber,
              boolean isComplex,
              boolean isBlipId)

Constructs a new escher property.  The three parameters are combined to form a property
 id.

Method Detail

getId

public short getId()

getPropertyNumber

public short getPropertyNumber()

isComplex

public boolean isComplex()

isBlipId

public boolean isBlipId()

getName

public java.lang.String getName()

getPropertySize

public int getPropertySize()

Most properties are just 6 bytes in length.  Override this if we're
 dealing with complex properties.

toXml

public java.lang.String toXml(java.lang.String tab)

serializeSimplePart

public abstract int serializeSimplePart(byte[] data,
                      int pos)

Escher properties consist of a simple fixed length part and a complex variable length part.
 The fixed length part is serialized first.

serializeComplexPart

public abstract int serializeComplexPart(byte[] data,
                       int pos)

Escher properties consist of a simple fixed length part and a complex variable length part.
 The fixed length part is serialized first.

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Prev Class

Next Class

Frames

No Frames

All Classes

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method

                Copyright 2014 The Apache Software Foundation or
        its licensors, as applicable.


text:
package com.sc.td;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class User implements Iterable<User>{
	private int id;
	private int age;
	 private List<User> userList=new ArrayList<User>();
	public User(int id,int age){
		this.id = id;
		this.age = age;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public Iterator<User> iterator() {
		// TODO Auto-generated method stub
		 return new MyIterator();//返回一个MyIterator实例对象
	}

	class MyIterator implements Iterator<User>{
		private int index =0;
		@Override
        public boolean hasNext() {
            return index!=userList.size();
        }

        @Override
        public User next() {
            return userList.get(index++);
        }

	}
}


text:
title: "Side swept in a  hoodie"
excerpt: "PaperFaces portrait of @likejunx drawn with Paper for iOS on an iPad."
image:
  path: &image /assets/images/paperfaces-likejunx-twitter.jpg
  feature: *image
  thumbnail: /assets/images/paperfaces-likejunx-twitter-150.jpg
categories: [paperfaces]
tags: [portrait, illustration, Paper for iOS]
---

PaperFaces portrait of [@likejunx](https://twitter.com/likejunx).

{% include_cached boilerplate/paperfaces.md %}


text:
using System;

namespace uScoober.Binary
{
    internal static class BinaryCodedDecimal
    {
        public static byte Pack(int value) {
            if (value < 0 || value > 99) {
                throw new ArgumentOutOfRangeException("value");
            }
            return (byte)(((value / 10) << 4) | (value % 10));
        }

        public static int Unpack(byte value) {
            return (value >> 4) * 10 + (value & 0x0F);
        }
    }
}