math

24# xiaongxp


好象函数式有错，从网上的范例中看应该是：f(z) = c^2*z^4 - (c^4+1)*z^2 + c^2，C=e^(iπ/4)。但是牛顿的迭代我还是模糊的，运算式太复杂了。看了一下说明好象还与它的根有关。xiaongxp老师不妨也把牛顿的分形做一下介绍，作牛顿分形有什么技巧。谢谢。

math

27# 柳烟


http://www.fractalsciencekit.com/tutorial/examples/newton.htm，有个软件在这个网站，下载后有范例，里面有关于这个分形的信息。可是很多看不懂。

math

30# xiaongxp


comment:
  
  Attributed to Paul Carlson.
  
  Mandelbrot fractal based on Newton's method for
  finding roots applied to:
  
    c^2*z^4 - (c^4+1)*z^2 + c^2 = 0
  
  Set the Classic Controller to 'Gradient Map - Newton' and
  use the Julia preview window to explore the Julia fractals.
  
  Notes:
  
     f(z) = c^2*z^4 - (c^4+1)*z^2 + c^2
    f'(z) = 4*c^2*z^3 - 2*(c^4+1)*z
   f''(z) = 12*c^2*z^2 - 2*(c^4+1)
   
  The Newton fractal is given by:
  
    z = z - f(z)/f'(z)
   
  and the critical point is found by
  setting f''(z) = 0 and solving for z:
  
    12*c^2*z^2 - 2*(c^4+1) = 0
    12*c^2*z^2 = 2*(c^4+1)
    z^2 = (c^4+1)/(6*c^2)
    z = Sqrt((c^4+1)/(6*c^2))
   
  For general information on Newton fractals see:
    http://en.wikipedia.org/wiki/Newton_fractal
    http://mathworld.wolfram.com/NewtonsMethod.html
   
global:
  
  FSK.OverrideValue("AngleReferencePoint", AngleReferencePoint)
  FSK.OverrideValue("RootDetection", True)
  FSK.OverrideValue("MaxPower", Solver.MaxPower(SolverMethod))
  
  Complex coef[] = c^2, 0, -(c^4+1), 0, c^2
  
initialize:
  
  if (~IsJulia) {
    c2 = c^2
    c4 = c^4
    coef[] = c2, 0, -(c4+1), 0, c2
    z = Sqrt((c4+1)/(6*c2)) ' critical point
  }
  
iterate:
  
  z = Solver.ApplyToPolynomial(SolverMethod, SolverMethodArg, coef[], z)
  
properties:
  
  #include SolverMethodOptions
  
  #include AngleReferencePoints
  
  option AngleReferencePoint {
    type = AngleReferencePoints
    caption = "Angle Reference"
    default = AngleReferencePoints.PreviousOrbitPoint
  }

math

这是它的M集：

math

牛顿J集
6014
我试了那个软件也没找到那个图，要能从软件上找到就好了。
changxde 发表于 2010-7-11 20:28

你把这个文件在软件中打开：

math

好象是要经过一个变换才能得到那个图形：comment:
  
  Implements a transformation based on the composite function:
  
    z = G(F(z))
   
  Both F abd G are applied relative to a conjugating map
  defined as a Mobius transformation. For example, we define
  the conjugation of F with respect to the conjugating map
  MapF as:
  
    z = Mobius.TransformPoint(MapF, F(Mobius.InverseTransformPoint(MapF, z)))
  
  a similar conjugation is defined for G. Finally, the
  composite function is applied Power times to z.
  
global:
  '
  ' Initialize conjugating maps MapF and MapG.
  '
  const Mobius MapF = Mobius.Identity()
  const Mobius MapG = Mobius.Identity()
  const Complex ApplyMapF = ShiftF <> 0 || AngleF <> 0 || ScaleF <> 1 || InvertF
  const Complex ApplyMapG = ShiftG <> 0 || AngleG <> 0 || ScaleG <> 1 || InvertG
  
  if (ApplyMapF) {
    Mobius.Translate(MapF, ShiftF)
    Mobius.Rotate(MapF, DegreeToRadian(AngleF))
    Mobius.Scale(MapF, ScaleF)
   
    if (InvertF) {
      Mobius.ApplyInversion(MapF)
    }
  }
  if (ApplyMapG) {
    Mobius.Translate(MapG, ShiftG)
    Mobius.Rotate(MapG, DegreeToRadian(AngleG))
    Mobius.Scale(MapG, ScaleG)
   
    if (InvertG) {
      Mobius.ApplyInversion(MapG)
    }
  }
  
transform:
  
  if (ApplyMapF) {
    z = Mobius.TransformPoint(MapF, F(Mobius.InverseTransformPoint(MapF, z)))
  } else {
    z = F(z)
  }
  if (ApplyMapG) {
    z = Mobius.TransformPoint(MapG, G(Mobius.InverseTransformPoint(MapG, z)))
  } else {
    z = G(z)
  }
  z *= Scale
  
properties:
  
  #include ComplexFunctions
  
  divider {
    caption = "General"
  }
  option Scale {
    type = Float
    caption = "Scale"
    details = "Scale factor applied to composite value"
    default = 1
  }
  divider {
    caption = "F(z)"
  }
  option F {
    type = ComplexFunctions
    caption = "F(z)"
    default = Pow2
  }
  divider {
    caption = "Conjugating map applied to F(z)"
  }
  option ShiftF {
    type = Complex
    caption = "Shift"
    details = "Translation component"
    default = 0
  }
  option ScaleF {
    type = Float
    caption = "Scale"
    details = "Scale factor"
    default = 1
  }
  option AngleF {
    type = Float
    caption = "Angle"
    details = "Angle of rotation"
    default = 0
    range = [-360,360]
  }
  option InvertF {
    type = Boolean
    caption = "Invert"
    details = "Apply complex inversion"
    default = False
  }
  divider {
    caption = "G(z)"
  }
  option G {
    type = ComplexFunctions
    caption = "G(z)"
    default = Ident
  }
  divider {
    caption = "Conjugating map applied to G(z)"
  }
  option ShiftG {
    type = Complex
    caption = "Shift"
    details = "Translation component"
    default = 0
  }
  option ScaleG {
    type = Float
    caption = "Scale"
    details = "Scale factor"
    default = 1
  }
  option AngleG {
    type = Float
    caption = "Angle"
    details = "Angle of rotation"
    default = 0
    range = [-360,360]
  }
  option InvertG {
    type = Boolean
    caption = "Invert"
    details = "Apply complex inversion"
    default = False
  }

math

不必这么苛刻，changxde老师不是说了吗“还有待研究”。我想还是请changxde老师先说一下主要思路供大家参考，到底做了什么变换，其它问题都是大家知道的。至于着色我想xiaongxp老师会解决的。这样可能更快一些达到原图的实际效果。

math

原来就是这么简单的事，Z-Z+1/Z的变换。

math

68# xiaongxp
但一个象限几根的情况?比如说什么样的迭代式

math

在xiaongxp老师着色的基础上加上et变化（改ln(et)为0.2et，感觉也不错：