Power BI to users without Power BI

So I've asked a similar question, but I thought I'd ask it more generally to get as many ideas as possible.

So I've asked a similar question, but I thought I'd ask it more generally to get as many ideas as possible.

I have Power BI Pro. I am tasked with creating reports for hundreds of recipients, each one personalized to that specific user.

My organization will not pay out for everyone else to have Power BI enabled, although everyone will have an O365 account.

How do I share my reports created in Power BI to users without Power BI? Factoring in there are several hundred of them to produce every week by a team of 2 people.

Thanks in advance!

How to append current and previous sessions side by side filtered by two independent slicers

<strong>Objective:</strong>&nbsp;I would like obtain the difference between current and previous sessions based on date slicers I want the output to be 4 columns as such:

Objective: I would like obtain the difference between current and previous sessions based on date slicers I want the output to be 4 columns as such:

  • Date
  • Current Sessions (see measure below)
  • Previous Sessions (see measure below)
  • Difference (no measure calculated yet).

Situation: I currently have two measures

  • Current Sessions: SUM(Sales[Sessions])
  • Previous Sessions (thanks to @Alexis Olson):
VAR datediffs = DATEDIFF( CALCULATE (MAX ( 'Date'[Date] ) ), CALCULATE (MAX ('Previous Date'[Date])), DAY ) RETURN CALCULATE(SUM(Sales[Sessions]), USERELATIONSHIP('Previous Date'[Date],'Date'[Date]), DATEADD('Date'[Date],datediffs,DAY) )

I have three tables.

  • Sales
  • Date
  • Previous Date (carbon copy of Date table)

My previous date table is 1:1 inactive relationship with the Date table. Date table is 1 to many active relationship with my Sales Table.

I have two slicers at all time comparing the same amount of days from different time periods (e.g. Jan 1th to Jan 7th 2019 vs Dec 25st to Dec 31th 2019) If i put current sessions, previous sessions and a date column from any of the three tables

+----------+------------------+-------------------+------------+
|   date   | current sessions | previous sessions | difference |
+----------+------------------+-------------------+------------+
| Jan 8th  |            10000 |             70000 |       3000 |
| Jan 9th  |            20000 |             10000 |      10000 |
| Jan 10th |            15000 |             16000 |      -1000 |
| Jan 11th |            14000 |             12000 |       2000 |
| Jan 12th |            12000 |             14000 |      -2000 |
| Jan 13th |            11000 |             16000 |      -5000 |
| Jan 14th |            15000 |             18000 |      -3000 |
+----------+------------------+-------------------+------------+

When I put the Sessions date on the table along with sessions and previous sessions, I get the sessions amounts right for each day but the previous session amounts doesn't calculate correctly I assume because its being filtered by the date rows.

How can I override that table filter and force it to get the exact previous sessions amounts? Basically have both results appended to each other.The following shows my problem. the previous session is the same on each day and is basically the amount of dec 31st jan 2018 because the max date is different for each row but I want it to be based on the slicer. 


migrate power bi collection to power bi embeded

I tried to follow the article to migrate power bi collection to power bi embedded (<a href="https://docs.microsoft.com/en-us/power-bi/developer/migrate-from-powerbi-embedded" target="_blank">msdn article here</a>). However, I got stuck very quickly.

I tried to follow the article to migrate power bi collection to power bi embedded (msdn article here). However, I got stuck very quickly.

For example, in our app, we use these nuget packages (Microsoft.PowerBI.Api and powerbi.core), and these are some of our usages:

client.Reports.GetReportsAsync(this.workspaceCollection, this.workspaceId)

client.Reports.DeleteReportAsync(this.workspaceCollection, this.workspaceId, report.Id);

client.Imports.PostImportFileWithHttpMessage(this.workspaceCollection,this.workspaceId,File.OpenRead(localPath), "Main Report");

client.Datasets.GetGatewayDatasourcesAsync(workspaceCollection, workspaceId, dataset.Id);

client.Gateways.PatchDatasourceAsync(workspaceCollection,workspaceId,datasources.Value[0].GatewayId,datasources.Value[0].Id,
delta);

client.Datasets.GetDatasetsAsync(workspaceCollection, workspaceId);

I can download all reports and move to power BI embedded, but as workspace collection will be retired, will we still be able to use above methods? If not, are there any alternative functions to use?

Power BI in Office 365

I am asked to work on a Dashboard project using Power BI. This will be implemented in Office 365 site. I was unable to find a properly explaining tutorial related to Power BI in office 356. I am having following confusions in Power BI for Office 365.

I am asked to work on a Dashboard project using Power BI. This will be implemented in Office 365 site. I was unable to find a properly explaining tutorial related to Power BI in office 356. I am having following confusions in Power BI for Office 365.

  • What is the different between Power BI in Office 365 and MS Office Excel.?
  • What is the connection betweer Power BI in Office 365 and MS Office Excel.?
  • Can I create a Power BI report in Office 365 without my locally installed Office Excel?
  • Is Q & A feature already included in Power BI or is it something else?
  • Can a Power BI view included in a website component?
  • What is the different between Excel Web services and Power BI?
  • Would like know resources for examples of how to ?

Is the following idea correct?

Power BI has the same visualization power as Office Excel Application. We create Visualizations using Power BI in locally using Office Excel and then we upload it to Office 365 and we can Interact with the visualizations as the same in the web?

Is it that everything has to be done in the local Office Excel file noting has to be done in Office 365?

Even though there are data sources configuration for Power BI in Office 365. That is to create Odata?

Thanks in Advance :)

Add tag for powerbi-custom-visuals

Power BI is a self-service analytics tool.

Some background details

Power BI is a self-service analytics tool.

Stack Overflow already has several Power BI related tags (8 in total). Aside from the main powerbitag, there are tags for specific platforms e.g. powerbi-desktop and powerbi-mobile and tags for specific aspects of Power BI such as powerbi-embedded and powerbi-datasource. Custom visuals fit the latter category.

Custom visuals are visualization plugins for Power BI - mostly written by the community and typically open-source. Compared to general Power BI questions, questions related to custom visuals are relevant to a different audience (developers, rather than typical Power BI users), they tend to focus on different topics, and typically require different knowledge and skill-set to answer.

At the time of writing this, there are 119 questions about Power BI custom visual development, their capabilities, API and usage.

These two reasons justify adding a separate tag for custom visuals.

Tag suggestion

Suggesting to add a powerbi-custom-visuals tag, with the following description:

Questions about Power BI custom visuals: their development, capabilities and usage. Power BI is a self-service analytics tool. Custom visuals are visualization plugins for Power BI, written in TypeScript or JavaScript using the Custom Visuals SDK.

I don't have a high enough reputation to add the tag myself.

Power BI in general, and custom visuals in particular already have official documentation and a developer forum. So this is in line with Stack Overflow's product-support policy ("Stack Overflow can help support your product but it can't be the only support.").

Fair disclosure: I'm a Microsoft employee, working in Power BI extensions development team. This is my personal SE account, and I occasionally contribute to SE sites on my personal time and in an unofficial manner.

support status-completed 

Converting double to BigDecimal in Java

I wrote a Java program that calculates values for&nbsp;<a href="https://en.wikipedia.org/wiki/Riemann_zeta_function" target="_blank">the Riemann Zeta Function</a>. Inside the program, I made a library to calculate necessary complex functions such as atan, cos, etc. Everything inside both programs is accessed through the&nbsp;<code>double</code>&nbsp;and&nbsp;<code>BigDecimal</code>&nbsp;data types. This creates major issues when evaluating large values for the Zeta function.

I wrote a Java program that calculates values for the Riemann Zeta Function. Inside the program, I made a library to calculate necessary complex functions such as atan, cos, etc. Everything inside both programs is accessed through the double and BigDecimal data types. This creates major issues when evaluating large values for the Zeta function.

The numerical approximation for the Zeta function references

Directly evaluating this approximation at high values creates issues when s has a large complex form, such as s = (230+30i). I am very grateful to get information about this here. The evaluation of S2.minus(S1) creates errors because I wrote something wrong in the adaptiveQuad method.

As an example, Zeta(2+3i) through this program generates

Calculation of the Riemann Zeta Function in the form Zeta(s) = a + ib.

Enter the value of [a] inside the Riemann Zeta Function: 2
Enter the value of [b] inside the Riemann Zeta Function: 3
The value for Zeta(s) is 7.980219851133409E-1 - 1.137443081631288E-1*i
Total time taken is 0.469 seconds.

Which is correct.

Zeta(100+0i) generates

Calculation of the Riemann Zeta Function in the form Zeta(s) = a + ib.

Enter the value of [a] inside the Riemann Zeta Function: 100
Enter the value of [b] inside the Riemann Zeta Function: 0
The value for Zeta(s) is 1.000000000153236E0
Total time taken is 0.672 seconds.

Which is also correct as compared to Wolfram. The problem is due to something inside the method labelled adaptiveQuad.

Zeta(230+30i) generates

Calculation of the Riemann Zeta Function in the form Zeta(s) = a + ib.

Enter the value of [a] inside the Riemann Zeta Function: 230
Enter the value of [b] inside the Riemann Zeta Function: 30
The value for Zeta(s) is 0.999999999999093108519845391615339162047254997503854254342793916541606842461539820124897870147977114468145672577664412128509813042591501204781683860384769321084473925620572315416715721728082468412672467499199310913504362891199180150973087384370909918493750428733837552915328069343498987460727711606978118652477860450744628906250 - 38.005428584222228490409289204403133867487950535704812764806874887805043029499897666636162309572126423385487374863788363786029170239477119910868455777891701471328505006916099918492113970510619110472506796418206225648616641319533972054228283869713393805956289770456519729094756021581247296126093715429306030273437500E-15i
Total time taken is 1.746 seconds.

The imaginary part is a bit off as compared to Wolfram.

The algorithm to evaluate the integral is known as Adaptive Quadrature and a double Java implementation is found here. The adaptive quad method applies the following

// adaptive quadrature
public static double adaptive(double a, double b) {
double h = b - a;
double c = (a + b) / 2.0;
double d = (a + c) / 2.0;
double e = (b + c) / 2.0;
double Q1 = h/6 * (f(a) + 4f(c) + f(b));
double Q2 = h/12 * (f(a) + 4f(d) + 2f(c) + 4*f(e) + f(b));
if (Math.abs(Q2 - Q1) <= EPSILON)
return Q2 + (Q2 - Q1) / 15;
else
return adaptive(a, c) + adaptive(c, b);
}

Here is my fourth attempt at writing the program

/**************************************************************************
**
** Abel-Plana Formula for the Zeta Function
**


** Axion004
** 08/16/2015
**
** This program computes the value for Zeta(z) using a definite integral
** approximation through the Abel-Plana formula. The Abel-Plana formula
** can be shown to approximate the value for Zeta(s) through a definite
** integral. The integral approximation is handled through the Composite
** Simpson's Rule known as Adaptive Quadrature.
**************************************************************************/

import java.util.;
import java.math.
;

public class AbelMain5 extends Complex {
private static MathContext MC = new MathContext(512,
RoundingMode.HALF_EVEN);
public static void main(String[] args) {
AbelMain();
}

// Main method
public static void AbelMain() {
    double re = 0, im = 0;
    double start, stop, totalTime;
    Scanner scan = new Scanner(System.in);
    System.out.println("Calculation of the Riemann Zeta " +
            "Function in the form Zeta(s) = a + ib.");
    System.out.println();
    System.out.print("Enter the value of [a] inside the Riemann Zeta " +
            "Function: ");
    try {
            re = scan.nextDouble();
    }
    catch (Exception e) {
       System.out.println("Please enter a valid number for a.");
    }
    System.out.print("Enter the value of [b] inside the Riemann Zeta " +
            "Function: ");
    try {
            im = scan.nextDouble();
    }
    catch (Exception e) {
       System.out.println("Please enter a valid number for b.");
    }
    start = System.currentTimeMillis();
    Complex z = new Complex(new BigDecimal(re), new BigDecimal(im));
    System.out.println("The value for Zeta(s) is " + AbelPlana(z));
    stop = System.currentTimeMillis();
    totalTime = (double) (stop-start) / 1000.0;
    System.out.println("Total time taken is " + totalTime + " seconds.");
}

/**
 * The definite integral for Zeta(z) in the Abel-Plana formula.
     * &lt;br&gt; Numerator = Sin(z * arctan(t))
     * &lt;br&gt; Denominator = (1 + t^2)^(z/2) * (e^(2*pi*t) - 1)
 * @param t - the value of t passed into the integrand.
     * @param z - The complex value of z = a + i*b
 * @return the value of the complex function.
*/
public static Complex f(double t, Complex z) {
    Complex num = (z.multiply(Math.atan(t))).sin();
    Complex D1 = new Complex(1 + t*t).pow(z.divide(TWO));
    Complex D2 = new Complex(Math.pow(Math.E, 2.0*Math.PI*t) - 1.0);
    Complex den = D1.multiply(D2);
    return num.divide(den, MC);
}

/**
 * Adaptive quadrature - See http://www.mathworks.com/moler/quad.pdf
 * @param a - the lower bound of integration.
     * @param b - the upper bound of integration.
     * @param z - The complex value of z = a + i*b
 * @return the approximate numerical value of the integral.
*/
public static Complex adaptiveQuad(double a, double b, Complex z) {
    double EPSILON = 1E-10;
    double step = b - a;
    double c = (a + b) / 2.0;
    double d = (a + c) / 2.0;
    double e = (b + c) / 2.0;

    Complex S1 = (f(a, z).add(f(c, z).multiply(FOUR)).add(f(b, z))).
            multiply(step / 6.0);
    Complex S2 = (f(a, z).add(f(d, z).multiply(FOUR)).add(f(c, z).multiply
            (TWO)).add(f(e, z).multiply(FOUR)).add(f(b, z))).multiply
            (step / 12.0);
    Complex result = (S2.subtract(S1)).divide(FIFTEEN, MC);

    if(S2.subtract(S1).mod() &lt;= EPSILON)
        return S2.add(result);
    else
        return adaptiveQuad(a, c, z).add(adaptiveQuad(c, b, z));
}

/**
 * The definite integral for Zeta(z) in the Abel-Plana formula.
     * &lt;br&gt; value =  1/2 + 1/(z-1) + 2 * Integral
     * @param z - The complex value of z = a + i*b
 * @return the value of Zeta(z) through value and the
     * quadrature approximation.
*/
public static Complex AbelPlana(Complex z) {
    Complex C1 = ONEHALF.add(ONE.divide(z.subtract(ONE), MC));
    Complex C2  =  TWO.multiply(adaptiveQuad(1E-16, 100.0, z));
    if ( z.real().doubleValue() == 0 &amp;&amp; z.imag().doubleValue() == 0)
        return new Complex(0.0, 0.0);
    else
        return C1.add(C2);
}

}

Complex numbers (BigDecimal)

/**************************************************************************
**
** Complex Numbers
**


** Axion004
** 08/20/2015
**
** This class is necessary as a helper class for the calculation of
** imaginary numbers. The calculation of Zeta(z) inside AbelMain is in
** the form of z = a + i*b.
**************************************************************************/

import java.math.BigDecimal;
import java.math.MathContext;
import java.text.DecimalFormat;
import java.text.NumberFormat;

public class Complex extends Object{
private BigDecimal re;
private BigDecimal im;

/**
    BigDecimal constant for zero
*/
final static Complex ZERO = new Complex(BigDecimal.ZERO) ;

/**
    BigDecimal constant for one half
*/
final static Complex ONEHALF = new Complex(new BigDecimal(0.5));

/**
    BigDecimal constant for one
*/
final static Complex ONE = new Complex(BigDecimal.ONE);

/**
    BigDecimal constant for two
*/
final static Complex TWO = new Complex(new BigDecimal(2.0));

/**
    BigDecimal constant for four
*/
final static Complex FOUR = new Complex(new BigDecimal(4.0)) ;

/**
    BigDecimal constant for fifteen
*/
final static Complex FIFTEEN = new Complex(new BigDecimal(15.0)) ;

/**
    Default constructor equivalent to zero
*/
public Complex() {
    re = BigDecimal.ZERO;
    im = BigDecimal.ZERO;
}

/**
    Constructor with real part only
    @param x Real part, BigDecimal
*/
public Complex(BigDecimal x) {
    re = x;
    im = BigDecimal.ZERO;
}

/**
    Constructor with real part only
    @param x Real part, double
*/
public Complex(double x) {
    re = new BigDecimal(x);
    im = BigDecimal.ZERO;
}

/**
    Constructor with real and imaginary parts in double format.
    @param x Real part
    @param y Imaginary part
*/
public Complex(double x, double y) {
    re= new BigDecimal(x);
    im= new BigDecimal(y);
}

/**
    Constructor for the complex number z = a + i*b
    @param re Real part
    @param im Imaginary part
*/
public Complex (BigDecimal re, BigDecimal im) {
    this.re = re;
    this.im = im;
}

/**
    Real part of the Complex number
    @return Re[z] where z = a + i*b.
*/
public BigDecimal real() {
    return re;
}

/**
    Imaginary part of the Complex number
    @return Im[z] where z = a + i*b.
*/
public BigDecimal imag() {
    return im;
}

/**
    Complex conjugate of the Complex number
    in which the conjugate of z is z-bar.
    @return z-bar where z = a + i*b and z-bar = a - i*b
*/
public Complex conjugate() {
    return new Complex(re, im.negate());
}

/**
 * Returns the sum of this and the parameter.

   @param augend the number to add
   @param mc the context to use
   @return this + augend
 */
public Complex add(Complex augend,MathContext mc)
{
    //(a+bi)+(c+di) = (a + c) + (b + d)i
    return new Complex(
        re.add(augend.re,mc),
        im.add(augend.im,mc));
}

/**
   Equivalent to add(augend, MathContext.UNLIMITED)
   @param augend the number to add
   @return this + augend
 */
public Complex add(Complex augend)
{
    return add(augend, MathContext.UNLIMITED);
}

/**
    Addition of Complex number and a double.
    @param d is the number to add.
    @return z+d where z = a+i*b and d = double
*/
public Complex add(double d){
    BigDecimal augend = new BigDecimal(d);
    return new Complex(this.re.add(augend, MathContext.UNLIMITED),
            this.im);
}

/**
 * Returns the difference of this and the parameter.
   @param subtrahend the number to subtract
   @param mc the context to use
   @return this - subtrahend
 */
public Complex subtract(Complex subtrahend, MathContext mc)
{
    //(a+bi)-(c+di) = (a - c) + (b - d)i
    return new Complex(
        re.subtract(subtrahend.re,mc),
        im.subtract(subtrahend.im,mc));
}

/**
 * Equivalent to subtract(subtrahend, MathContext.UNLIMITED)
   @param subtrahend the number to subtract
   @return this - subtrahend
 */
public Complex subtract(Complex subtrahend)
{
    return subtract(subtrahend,MathContext.UNLIMITED);
}

/**
    Subtraction of Complex number and a double.
    @param d is the number to subtract.
    @return z-d where z = a+i*b and d = double
*/
public Complex subtract(double d){
    BigDecimal subtrahend = new BigDecimal(d);
    return new Complex(this.re.subtract(subtrahend, MathContext.UNLIMITED),
            this.im);
}

/**
 * Returns the product of this and the parameter.
   @param multiplicand the number to multiply by
   @param mc the context to use
   @return this * multiplicand
 */
public Complex multiply(Complex multiplicand, MathContext mc)
{
    //(a+bi)(c+di) = (ac - bd) + (ad + bc)i
    return new Complex(
        re.multiply(multiplicand.re,mc).subtract(im.multiply
            (multiplicand.im,mc),mc),
        re.multiply(multiplicand.im,mc).add(im.multiply
            (multiplicand.re,mc),mc));
}

/**
   Equivalent to multiply(multiplicand, MathContext.UNLIMITED)
   @param multiplicand the number to multiply by
   @return this * multiplicand
 */
public Complex multiply(Complex multiplicand)
{
    return multiply(multiplicand,MathContext.UNLIMITED);
}

/**
    Complex multiplication by a double.
    @param d is the double to multiply by.
    @return z*d where z = a+i*b and d = double
*/
public Complex multiply(double d){
    BigDecimal multiplicand = new BigDecimal(d);
    return new Complex(this.re.multiply(multiplicand, MathContext.UNLIMITED)
            ,this.im.multiply(multiplicand, MathContext.UNLIMITED));
}

/**
    Modulus of a Complex number or the distance from the origin in
    * the polar coordinate plane.
    @return |z| where z = a + i*b.
*/
public double mod() {
    if ( re.doubleValue() != 0.0 || im.doubleValue() != 0.0)
        return Math.sqrt(re.multiply(re).add(im.multiply(im))
                .doubleValue());
    else
        return 0.0;
}

/**
 * Modulus of a Complex number squared
 * @param z = a + i*b
 * @return |z|^2 where z = a + i*b
*/
public double abs(Complex z) {
    double doubleRe = re.doubleValue();
    double doubleIm = im.doubleValue();
    return doubleRe * doubleRe + doubleIm * doubleIm;
}

public Complex divide(Complex divisor)
{
    return divide(divisor,MathContext.UNLIMITED);
}

/**
    * The absolute value squared.
    * @return The sum of the squares of real and imaginary parts.
    * This is the square of Complex.abs() .
    */
public BigDecimal norm()
{
            return re.multiply(re).add(im.multiply(im)) ;
}

/**
    * The absolute value of a BigDecimal.
    * @param mc amount of precision
    * @return BigDecimal.abs()
    */
public BigDecimal abs(MathContext mc)
{
            return BigDecimalMath.sqrt(norm(),mc) ;
}

/** The inverse of the the Complex number.
      @param mc amount of precision
      @return 1/this
    */
public Complex inverse(MathContext mc)
{
            final BigDecimal hyp = norm() ;
            /* 1/(x+iy)= (x-iy)/(x^2+y^2 */
            return new Complex( re.divide(hyp,mc), im.divide(hyp,mc)
                    .negate() ) ;
}

/** Divide through another BigComplex number.
    @param oth the other complex number
    @param mc amount of precision
    @return this/other
    */
public Complex divide(Complex oth, MathContext mc)
{
            /* implementation: (x+iy)/(a+ib)= (x+iy)* 1/(a+ib) */
            return multiply(oth.inverse(mc),mc) ;
}

/**
Division of Complex number by a double.
@param d is the double to divide
@return new Complex number z/d where z = a+i*b
*/
public Complex divide(double d){
BigDecimal divisor = new BigDecimal(d);
return new Complex(this.re.divide(divisor, MathContext.UNLIMITED),
this.im.divide(divisor, MathContext.UNLIMITED));
}

/**
    Exponential of a complex number (z is unchanged).
    &lt;br&gt; e^(a+i*b) = e^a * e^(i*b) = e^a * (cos(b) + i*sin(b))
    @return exp(z) where z = a+i*b
*/
public Complex exp () {
    return new Complex(Math.exp(re.doubleValue()) * Math.cos(im.
            doubleValue()), Math.exp(re.doubleValue()) *
            Math.sin(im.doubleValue()));
}

 /**
    The Argument of a Complex number or the angle in radians
    with respect to polar coordinates.
    &lt;br&gt; Tan(theta) = b / a, theta = Arctan(b / a)
    &lt;br&gt; a is the real part on the horizontal axis
    &lt;br&gt; b is the imaginary part of the vertical axis
    @return arg(z) where z = a+i*b.
*/
public double arg() {
    return Math.atan2(im.doubleValue(), re.doubleValue());
}

/**
    The log or principal branch of a Complex number (z is unchanged).
    &lt;br&gt; Log(a+i*b) = ln|a+i*b| + i*Arg(z) = ln(sqrt(a^2+b^2))
    * + i*Arg(z) = ln (mod(z)) + i*Arctan(b/a)
    @return log(z) where z = a+i*b
*/
public Complex log() {
    return new Complex(Math.log(this.mod()), this.arg());
}

/**
    The square root of a Complex number (z is unchanged).
    Returns the principal branch of the square root.
    &lt;br&gt; z = e^(i*theta) = r*cos(theta) + i*r*sin(theta)
    &lt;br&gt; r = sqrt(a^2+b^2)
    &lt;br&gt; cos(theta) = a / r, sin(theta) = b / r
    &lt;br&gt; By De Moivre's Theorem, sqrt(z) = sqrt(a+i*b) =
    * e^(i*theta / 2) = r(cos(theta/2) + i*sin(theta/2))
    @return sqrt(z) where z = a+i*b
*/
public Complex sqrt() {
    double r = this.mod();
    double halfTheta = this.arg() / 2;
    return new Complex(Math.sqrt(r) * Math.cos(halfTheta), Math.sqrt(r) *
            Math.sin(halfTheta));
}

/**
    The real cosh function for Complex numbers.
    &lt;br&gt; cosh(theta) = (e^(theta) + e^(-theta)) / 2
    @return cosh(theta)
*/
private double cosh(double theta) {
    return (Math.exp(theta) + Math.exp(-theta)) / 2;
}

/**
    The real sinh function for Complex numbers.
    &lt;br&gt; sinh(theta) = (e^(theta) - e^(-theta)) / 2
    @return sinh(theta)
*/
private double sinh(double theta) {
    return (Math.exp(theta) - Math.exp(-theta)) / 2;
}

 /**
    The sin function for the Complex number (z is unchanged).
    &lt;br&gt; sin(a+i*b) = cosh(b)*sin(a) + i*(sinh(b)*cos(a))
    @return sin(z) where z = a+i*b
*/
public Complex sin() {
    return new Complex(cosh(im.doubleValue()) * Math.sin(re.doubleValue()),
            sinh(im.doubleValue())* Math.cos(re.doubleValue()));
}

/**
    The cos function for the Complex number (z is unchanged).
    &lt;br&gt; cos(a +i*b) = cosh(b)*cos(a) + i*(-sinh(b)*sin(a))
    @return cos(z) where z = a+i*b
*/
public Complex cos() {
    return new Complex(cosh(im.doubleValue()) * Math.cos(re.doubleValue()),
            -sinh(im.doubleValue()) * Math.sin(re.doubleValue()));
}

/**
    The hyperbolic sin of the Complex number (z is unchanged).
    &lt;br&gt; sinh(a+i*b) = sinh(a)*cos(b) + i*(cosh(a)*sin(b))
    @return sinh(z) where z = a+i*b
*/
public Complex sinh() {
    return new Complex(sinh(re.doubleValue()) * Math.cos(im.doubleValue()),
            cosh(re.doubleValue()) * Math.sin(im.doubleValue()));
}

/**
    The hyperbolic cosine of the Complex number (z is unchanged).
    &lt;br&gt; cosh(a+i*b) = cosh(a)*cos(b) + i*(sinh(a)*sin(b))
    @return cosh(z) where z = a+i*b
*/
public Complex cosh() {
    return new Complex(cosh(re.doubleValue()) *Math.cos(im.doubleValue()),
            sinh(re.doubleValue()) * Math.sin(im.doubleValue()));
}

/**
    The tan of the Complex number (z is unchanged).
    &lt;br&gt; tan (a+i*b) = sin(a+i*b) / cos(a+i*b)
    @return tan(z) where z = a+i*b
*/
public Complex tan() {
    return (this.sin()).divide(this.cos());
}

/**
    The arctan of the Complex number (z is unchanged).
    &lt;br&gt; tan^(-1)(a+i*b) = 1/2 i*(log(1-i*(a+b*i))-log(1+i*(a+b*i))) =
    &lt;br&gt; -1/2 i*(log(i*a - b+1)-log(-i*a + b+1))
    @return arctan(z) where z = a+i*b
*/
public Complex atan(){
    Complex ima = new Complex(0.0,-1.0);    //multiply by negative i
    Complex num = new Complex(this.re.doubleValue(),this.im.doubleValue()
            -1.0);
    Complex den = new Complex(this.re.negate().doubleValue(),this.im
            .negate().doubleValue()-1.0);
    Complex two = new Complex(2.0, 0.0);    // divide by 2
    return ima.multiply(num.divide(den).log()).divide(two);
}

/**
 * The Math.pow equivalent of two Complex numbers.
 * @param z - the complex base in the form z = a + i*b
 * @return z^y where z = a + i*b and y = c + i*d
*/
public Complex pow(Complex z){
    Complex a = z.multiply(this.log(), MathContext.UNLIMITED);
    return a.exp();
}

/**
 * The Math.pow equivalent of a Complex number to the power
     * of a double.
 * @param d - the double to be taken as the power.
 * @return z^d where z = a + i*b and d = double
*/
 public Complex pow(double d){
     Complex a=(this.log()).multiply(d);
     return a.exp();
 }

/**
    Override the .toString() method to generate complex numbers, the
    * string representation is now a literal Complex number.
    @return a+i*b, a-i*b, a, or i*b as desired.
*/
public String toString() {

    NumberFormat formatter = new DecimalFormat();
    formatter = new DecimalFormat("#.###############E0");

    if (re.doubleValue() != 0.0 &amp;&amp; im.doubleValue()  &gt; 0.0) {
        return formatter.format(re) + " + " + formatter.format(im)
                +"*i";
    }
    if (re.doubleValue() !=0.0 &amp;&amp; im.doubleValue() &lt; 0.0) {
        return formatter.format(re) + " - "+ formatter.format(im.negate())
                + "*i";
    }
    if (im.doubleValue() == 0.0) {
        return formatter.format(re);
    }
    if (re.doubleValue() == 0.0) {
        return formatter.format(im) + "*i";
    }
    return formatter.format(re) + " + i*" + formatter.format(im);
}

}

I am reviewing the answer below.

One problem may be due to

Complex num = (z.multiply(Math.atan(t))).sin();
Complex D1 = new Complex(1 + tt).pow(z.divide(TWO));
Complex D2 = new Complex(Math.pow(Math.E, 2.0
Math.PI*t) - 1.0);
Complex den = D1.multiply(D2, MathContext.UNLIMITED);

I am not applying BigDecimal.pow(BigDecimal). Although, I don't think this is the direct issue which causes the floating point arithmetic to create differences.

Edit: I tried a new integral approximation of the Zeta function. Ultimately, I will develop a new method to calculate BigDecimal.pow(BigDecimal).